From 3dd875c2f87206cd79ade4417471f3ccb0189e5e Mon Sep 17 00:00:00 2001 From: Lana243 Date: Thu, 18 Apr 2024 18:15:10 +0300 Subject: [PATCH 1/2] seminar06-planning --- seminar06-planning/hw.ipynb | 481 + seminar06-planning/py_planning/__init__.py | 2 + seminar06-planning/py_planning/data_types.py | 104 + seminar06-planning/py_planning/planner.py | 30 + .../py_planning/planning_server.py | 153 + seminar06-planning/py_planning/py_planning.py | 44 + seminar06-planning/scenarios/static01.txt | 1 + seminar06-planning/scenarios/static02.txt | 1 + seminar06-planning/simulator/LICENSE | 21 + seminar06-planning/simulator/css/dash.css | 353 + seminar06-planning/simulator/dist/Dash.js | 1 + .../simulator/dist/PathPlannerWorker.js | 1 + .../simulator/images/examples/crosswalks.png | Bin 0 -> 183540 bytes .../images/examples/dodging_a_speeder.png | Bin 0 -> 156330 bytes .../images/examples/lane_blockage.png | Bin 0 -> 175091 bytes .../simulator/images/examples/merging.png | Bin 0 -> 217803 bytes .../images/examples/one_car_overtake.png | Bin 0 -> 199751 bytes .../simulator/images/examples/peloton.png | Bin 0 -> 181740 bytes .../simulator/images/examples/rough_road.png | Bin 0 -> 216392 bytes .../images/examples/two_car_overtake.png | Bin 0 -> 211344 bytes .../simulator/images/ladavaz.glb | Bin 0 -> 13189132 bytes seminar06-planning/simulator/images/stone.jpg | Bin 0 -> 658657 bytes seminar06-planning/simulator/images/wheel.png | Bin 0 -> 7658 bytes seminar06-planning/simulator/images/wheel.xcf | Bin 0 -> 50882 bytes seminar06-planning/simulator/index.html | 635 + seminar06-planning/simulator/js/Dash.js | 6 + seminar06-planning/simulator/js/GPGPU.js | 542 + seminar06-planning/simulator/js/Helpers.js | 5 + seminar06-planning/simulator/js/Simulator.js | 939 + seminar06-planning/simulator/js/Utils.js | 151 + .../simulator/js/autonomy/DynamicObstacle.js | 99 + .../simulator/js/autonomy/LanePath.js | 307 + .../simulator/js/autonomy/MovingAverage.js | 25 + .../simulator/js/autonomy/Path.js | 60 + .../simulator/js/autonomy/StaticObstacle.js | 58 + .../autonomy/control/AutonomousController.js | 181 + .../js/autonomy/control/FollowController.js | 177 + .../js/autonomy/control/ManualController.js | 39 + .../js/autonomy/path-planning/CubicPath.js | 205 + .../autonomy/path-planning/ExternalPlanner.js | 53 + .../js/autonomy/path-planning/PathPlanner.js | 470 + .../js/autonomy/path-planning/QuinticPath.js | 72 + .../js/autonomy/path-planning/RoadLattice.js | 24 + .../gpgpu-programs/graphSearch.js | 267 + .../gpgpu-programs/graphSearchShared.js | 308 + .../gpgpu-programs/optimizeCubicPaths.js | 269 + .../gpgpu-programs/optimizeQuinticPaths.js | 204 + .../gpgpu-programs/pathFromVehicleCosts.js | 131 + .../gpgpu-programs/slDynamicObstacleGrid.js | 115 + .../gpgpu-programs/slObstacleGrid.js | 51 + .../gpgpu-programs/slObstacleGridDilation.js | 72 + .../gpgpu-programs/xyObstacleCostGrid.js | 44 + .../gpgpu-programs/xyObstacleGrid.js | 75 + .../path-planning/gpgpu-programs/xyslMap.js | 88 + .../js/objects/BufferGeometryUtils.js | 1371 + .../simulator/js/objects/CarObject.js | 122 + .../js/objects/DynamicObstacleObject.js | 59 + .../simulator/js/objects/GLTFLoader.js | 4669 ++ .../simulator/js/objects/MapObject.js | 68 + .../js/objects/StaticObstacleObject.js | 32 + .../simulator/js/objects/TDSLoader.js | 1145 + .../simulator/js/physics/Car.js | 122 + .../simulator/js/physics/Physics.js | 18 + .../simulator/js/simulator/Dashboard.js | 132 + .../js/simulator/DynamicObstacleEditor.js | 185 + .../simulator/js/simulator/Editor.js | 672 + .../simulator/js/simulator/OrbitControls.js | 1048 + .../js/simulator/PathPlannerConfigEditor.js | 159 + .../simulator/js/simulator/ScenarioManager.js | 252 + .../simulator/js/simulator/ShareManager.js | 49 + .../js/simulator/TopDownCameraControls.js | 66 + .../simulator/js/simulator/examples.js | 17 + seminar06-planning/simulator/models/suv.js | 1 + .../simulator/package-lock.json | 14381 +++++ seminar06-planning/simulator/package.json | 22 + .../simulator/vendor/THREE.MeshLine.js | 477 + .../simulator/vendor/bulma.min.css | 2 + .../simulator/vendor/fontawesome-all.js | 5 + seminar06-planning/simulator/vendor/three.js | 45983 ++++++++++++++++ .../simulator/webpack.config.js | 22 + .../simulator/workers/.gitignore | 1 + .../simulator/workers/PathPlannerWorker.js | 86 + 82 files changed, 78030 insertions(+) create mode 100644 seminar06-planning/hw.ipynb create mode 100644 seminar06-planning/py_planning/__init__.py create mode 100644 seminar06-planning/py_planning/data_types.py create mode 100644 seminar06-planning/py_planning/planner.py create mode 100644 seminar06-planning/py_planning/planning_server.py create mode 100644 seminar06-planning/py_planning/py_planning.py create mode 100644 seminar06-planning/scenarios/static01.txt create mode 100644 seminar06-planning/scenarios/static02.txt create mode 100644 seminar06-planning/simulator/LICENSE create mode 100644 seminar06-planning/simulator/css/dash.css create mode 100644 seminar06-planning/simulator/dist/Dash.js create mode 100644 seminar06-planning/simulator/dist/PathPlannerWorker.js create mode 100644 seminar06-planning/simulator/images/examples/crosswalks.png create mode 100644 seminar06-planning/simulator/images/examples/dodging_a_speeder.png create mode 100644 seminar06-planning/simulator/images/examples/lane_blockage.png create mode 100644 seminar06-planning/simulator/images/examples/merging.png create mode 100644 seminar06-planning/simulator/images/examples/one_car_overtake.png create mode 100644 seminar06-planning/simulator/images/examples/peloton.png create mode 100644 seminar06-planning/simulator/images/examples/rough_road.png create mode 100644 seminar06-planning/simulator/images/examples/two_car_overtake.png create mode 100644 seminar06-planning/simulator/images/ladavaz.glb create mode 100644 seminar06-planning/simulator/images/stone.jpg create mode 100644 seminar06-planning/simulator/images/wheel.png create mode 100644 seminar06-planning/simulator/images/wheel.xcf create mode 100644 seminar06-planning/simulator/index.html create mode 100644 seminar06-planning/simulator/js/Dash.js create mode 100644 seminar06-planning/simulator/js/GPGPU.js create mode 100644 seminar06-planning/simulator/js/Helpers.js create mode 100644 seminar06-planning/simulator/js/Simulator.js create mode 100644 seminar06-planning/simulator/js/Utils.js create mode 100644 seminar06-planning/simulator/js/autonomy/DynamicObstacle.js create mode 100644 seminar06-planning/simulator/js/autonomy/LanePath.js create mode 100644 seminar06-planning/simulator/js/autonomy/MovingAverage.js create mode 100644 seminar06-planning/simulator/js/autonomy/Path.js create mode 100644 seminar06-planning/simulator/js/autonomy/StaticObstacle.js create mode 100644 seminar06-planning/simulator/js/autonomy/control/AutonomousController.js create mode 100644 seminar06-planning/simulator/js/autonomy/control/FollowController.js create mode 100644 seminar06-planning/simulator/js/autonomy/control/ManualController.js create mode 100644 seminar06-planning/simulator/js/autonomy/path-planning/CubicPath.js create mode 100644 seminar06-planning/simulator/js/autonomy/path-planning/ExternalPlanner.js create mode 100644 seminar06-planning/simulator/js/autonomy/path-planning/PathPlanner.js create mode 100644 seminar06-planning/simulator/js/autonomy/path-planning/QuinticPath.js create mode 100644 seminar06-planning/simulator/js/autonomy/path-planning/RoadLattice.js create mode 100644 seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/graphSearch.js create mode 100644 seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/graphSearchShared.js create mode 100644 seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/optimizeCubicPaths.js create mode 100644 seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/optimizeQuinticPaths.js create mode 100644 seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/pathFromVehicleCosts.js create mode 100644 seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/slDynamicObstacleGrid.js create mode 100644 seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/slObstacleGrid.js create mode 100644 seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/slObstacleGridDilation.js create mode 100644 seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/xyObstacleCostGrid.js create mode 100644 seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/xyObstacleGrid.js create mode 100644 seminar06-planning/simulator/js/autonomy/path-planning/gpgpu-programs/xyslMap.js create mode 100644 seminar06-planning/simulator/js/objects/BufferGeometryUtils.js create mode 100644 seminar06-planning/simulator/js/objects/CarObject.js create mode 100644 seminar06-planning/simulator/js/objects/DynamicObstacleObject.js create mode 100644 seminar06-planning/simulator/js/objects/GLTFLoader.js create mode 100644 seminar06-planning/simulator/js/objects/MapObject.js create mode 100644 seminar06-planning/simulator/js/objects/StaticObstacleObject.js create mode 100644 seminar06-planning/simulator/js/objects/TDSLoader.js create mode 100644 seminar06-planning/simulator/js/physics/Car.js create mode 100644 seminar06-planning/simulator/js/physics/Physics.js create mode 100644 seminar06-planning/simulator/js/simulator/Dashboard.js create mode 100644 seminar06-planning/simulator/js/simulator/DynamicObstacleEditor.js create mode 100644 seminar06-planning/simulator/js/simulator/Editor.js create mode 100644 seminar06-planning/simulator/js/simulator/OrbitControls.js create mode 100644 seminar06-planning/simulator/js/simulator/PathPlannerConfigEditor.js create mode 100644 seminar06-planning/simulator/js/simulator/ScenarioManager.js create mode 100644 seminar06-planning/simulator/js/simulator/ShareManager.js create mode 100644 seminar06-planning/simulator/js/simulator/TopDownCameraControls.js create mode 100644 seminar06-planning/simulator/js/simulator/examples.js create mode 100644 seminar06-planning/simulator/models/suv.js create mode 100644 seminar06-planning/simulator/package-lock.json create mode 100644 seminar06-planning/simulator/package.json create mode 100644 seminar06-planning/simulator/vendor/THREE.MeshLine.js create mode 100644 seminar06-planning/simulator/vendor/bulma.min.css create mode 100644 seminar06-planning/simulator/vendor/fontawesome-all.js create mode 100644 seminar06-planning/simulator/vendor/three.js create mode 100644 seminar06-planning/simulator/webpack.config.js create mode 100644 seminar06-planning/simulator/workers/.gitignore create mode 100644 seminar06-planning/simulator/workers/PathPlannerWorker.js diff --git a/seminar06-planning/hw.ipynb b/seminar06-planning/hw.ipynb new file mode 100644 index 0000000..ab1f463 --- /dev/null +++ b/seminar06-planning/hw.ipynb @@ -0,0 +1,481 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Install python dependencies" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: jsonpickle in /opt/anaconda3/lib/python3.11/site-packages (3.0.3)\n", + "Requirement already satisfied: dacite in /opt/anaconda3/lib/python3.11/site-packages (1.8.1)\n", + "Requirement already satisfied: shapely in /opt/anaconda3/lib/python3.11/site-packages (2.0.3)\n", + "Requirement already satisfied: numpy<2,>=1.14 in /opt/anaconda3/lib/python3.11/site-packages (from shapely) (1.26.4)\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install jsonpickle dacite shapely" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Run the planning server (should be executed only once)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import py_planning\n", + "py_planning.init()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# # you can also open http://127.0.0.1:8008 in your browser\n", + "\n", + "from IPython.display import IFrame\n", + "IFrame('http://127.0.0.1:8008', width=\"100%\", height=650)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Lane centering" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from enum import IntEnum\n", + "import math\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Case failed: Collision with static object\n" + ] + } + ], + "source": [ + "from py_planning.data_types import PlannedPath, PlannedState, State, Position # data types used by planner interface\n", + "from shapely.geometry import LineString, Point\n", + "\n", + "import time\n", + "\n", + "\"\"\"\n", + "find closest point on a polyline to the given point\n", + "\"\"\"\n", + "def get_index_of_closest_point(line: LineString, point: Point):\n", + " closest_point_index = None\n", + " min_distance = float('inf')\n", + "\n", + " for i, line_point in enumerate(line.coords):\n", + " line_point = Point(line_point)\n", + " distance = point.distance(line_point)\n", + " if distance < min_distance:\n", + " min_distance = distance\n", + " closest_point_index = i\n", + "\n", + " return closest_point_index\n", + "\n", + "\n", + "\"\"\"\n", + "This function is called by the simulator for each tick.\n", + "It should return recent planned trajectory up to date with the environment state.\n", + "'state' parameter contains current world observations and vehicle state.\n", + "\"\"\"\n", + "def do_plan(state: State) -> PlannedPath:\n", + " vehicle_pose = state.vehicle_pose\n", + " vehicle_pos = Point(vehicle_pose.pos.x, vehicle_pose.pos.y) # current position of the AV\n", + "\n", + " centerline = LineString([(p.x, p.y) for p in state.lane_path.centerline])\n", + "\n", + " closest_index = get_index_of_closest_point(centerline, vehicle_pos)\n", + " current_velocity = vehicle_pose.velocity\n", + "\n", + " # we leave some previous poses to make AV control stable\n", + " prev_poses_count = 3\n", + " max_poses_count = 50\n", + " first_pose_index = max(closest_index - prev_poses_count, 0)\n", + "\n", + " # as a baseline here we just follow the centerline\n", + " planned_states = [\n", + " PlannedState(pos=p, velocity=current_velocity) for p in state.lane_path.centerline\n", + " ][first_pose_index:first_pose_index+ max_poses_count]\n", + "\n", + " return PlannedPath(states=planned_states)\n", + " \n", + "\n", + "# run the case in the simulator, watch the visualization\n", + "py_planning.run_planner(\n", + " do_plan,\n", + " stop_on_fail=True # set to False to continue planning after case fail (useful for debugging)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Graph geometry planning" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def create_rotation_matrix(yaw):\n", + " T = np.zeros((len(yaw), 2, 2))\n", + " T[:, 0, 0] = np.cos(yaw)\n", + " T[:, 0, 1] = -np.sin(yaw)\n", + " T[:, 1, 0] = np.sin(yaw)\n", + " T[:, 1, 1] = np.cos(yaw)\n", + "\n", + " return T\n", + " \n", + "class Layer():\n", + " class Id(IntEnum):\n", + " X = 0\n", + " Y = 1\n", + " YAW = 2\n", + " COST = 3\n", + " PARENT = 4\n", + " SIZE = 5\n", + "\n", + " def __init__(self, N=None, nodes=None):\n", + " assert (N is None) ^ (nodes is None)\n", + " if N is not None:\n", + " self.nodes = np.zeros((N, Layer.Id.SIZE))\n", + " if nodes is not None:\n", + " assert nodes.shape[1] == Layer.Id.SIZE\n", + " self.nodes = nodes\n", + " \n", + " @property\n", + " def x(self):\n", + " return self.nodes[:, Layer.Id.X]\n", + " \n", + " @property\n", + " def y(self):\n", + " return self.nodes[:, Layer.Id.Y]\n", + " \n", + " @property\n", + " def yaw(self):\n", + " return self.nodes[:, Layer.Id.YAW]\n", + " \n", + " @property\n", + " def cost(self):\n", + " return self.nodes[:, Layer.Id.COST]\n", + " \n", + " @property\n", + " def parent(self):\n", + " return self.nodes[:, Layer.Id.PARENT]\n", + " \n", + " @property\n", + " def N(self):\n", + " return self.nodes.shape[0]\n", + " \n", + " @property\n", + " def M(self):\n", + " return self.nodes.shape[1]\n", + " \n", + " \n", + "def arc_primitive(c, ds):\n", + " if c == 0:\n", + " return 0, ds, 0\n", + " else:\n", + " dyaw = c * ds\n", + " return dyaw, 1 / c * math.sin(dyaw), 1 / c * (1 - math.cos(dyaw))\n", + "\n", + "\n", + "class Graph(list):\n", + " def nodes_num(self):\n", + " nodes = 0\n", + " for layer in self:\n", + " nodes += layer.N\n", + " return nodes\n", + "\n", + "\n", + "def search(initial_state, lane_path, obstacles, curvature_primitives=[-0.2, 0., 0.2], ds=1, tree_depth=6, sparse=True):\n", + " graph = Graph()\n", + " initial_layer = Layer(1)\n", + " initial_layer.nodes[:, Layer.Id.X] = initial_state.vehicle_pose.pos.x\n", + " initial_layer.nodes[:, Layer.Id.Y] = initial_state.vehicle_pose.pos.y\n", + " initial_layer.nodes[:, Layer.Id.YAW] = initial_state.vehicle_pose.rot\n", + " graph.append(initial_layer) \n", + " \n", + " for i in range(tree_depth):\n", + " X_c = graph[-1]\n", + " X_n = _make_step(X_c, ds, curvature_primitives, lane_path, obstacles)\n", + " if sparse:\n", + " X_n = _sparsify(X_n)\n", + "\n", + " graph.append(X_n)\n", + "\n", + " return graph, _restore_path(graph, np.argmin(graph[-1].nodes[:, Layer.Id.COST]))\n", + "\n", + "\n", + "def _make_step(X_c, ds, curvature_primitives, lane_path, obstacles):\n", + " N = X_c.N\n", + " X_n = Layer(N * len(curvature_primitives))\n", + "\n", + " for i, c in enumerate(curvature_primitives):\n", + " # assumme instant change of curvature and movement along circle\n", + " dyaw, dx, dy = arc_primitive(c, ds)\n", + " shift = np.array([dx, dy])\n", + "\n", + " yaw_c = X_c.yaw\n", + " T = create_rotation_matrix(yaw_c)\n", + "\n", + " X_n.x[i * N : (i + 1) * N] = X_c.x + T[:, 0] @ shift\n", + " X_n.y[i * N : (i + 1) * N] = X_c.y + T[:, 1] @ shift\n", + " X_n.yaw[i * N : (i + 1) * N] = yaw_c + dyaw\n", + " X_n.parent[i * N : (i + 1) * N] = np.arange(N)\n", + " X_n.cost[i * N : (i + 1) * N] = X_c.cost + c ** 2 \n", + " # _update_cost(X_n.nodes[i * N : (i + 1) * N, :], lane_path, obstacles)\n", + "\n", + " return X_n\n", + "\n", + "\n", + "# def _update_cost(X_n, lane_path, obstacles):\n", + "# centerline = LineString([(p.x, p.y) for p in lane_path])\n", + "# for i, node in enumerate(X_n):\n", + "# _, d = get_index_of_closest_point(centerline, Point(node[Layer.Id.X], node[Layer.Id.Y]))\n", + "# X_n[i, Layer.Id.COST] += d\n", + "# # obstacles = get_closest_static_obstacles(obstacles, node[Layer.Id.X], node[Layer.Id.Y], 1)\n", + "# # if len(obstacles) > 0:\n", + "# # d_to_closest_static = dist(node[Layer.Id.X], node[Layer.Id.Y], obstacles[0])\n", + "# # if d_to_closest_static < 2 * max(obstacles[0].w, obstacles[0].h):\n", + "# # X_n[i, Layer.Id.COST] = np.inf\n", + "# # else:\n", + "# # X_n[i, Layer.Id.COST] += 10 * np.exp(-d_to_closest_static + 2 * max(obstacles[0].w, obstacles[0].h))\n", + " \n", + "\n", + "\n", + "def _sparsify(layer, min_nodes=5, step_x=1, step_y=1,step_yaw=0.1):\n", + " if layer.N < min_nodes:\n", + " return layer\n", + "\n", + " def node_to_key(x, y, yaw):\n", + " return (round(x / step_x), round(y / step_y), round(yaw / step_yaw))\n", + " d = {}\n", + " for i in range(layer.N):\n", + " key = node_to_key(layer.x[i], layer.y[i], layer.yaw[i])\n", + " if key in d:\n", + " d[key] = min(d[key], (layer.cost[i], i))\n", + " else:\n", + " d[key] = (layer.cost[i], i)\n", + " indx = list(map(lambda value: value[1][1], d.items()))\n", + " layer.nodes = layer.nodes[indx]\n", + "\n", + " return layer\n", + "\n", + "\n", + "def _restore_path(graph, i):\n", + " path = Graph()\n", + " for j in range(len(graph)):\n", + " layer = graph[-j - 1]\n", + " path.append(Layer(nodes=np.copy(layer.nodes[i:i+1])))\n", + " i = int(layer.parent[i])\n", + "\n", + " # fix parent linkage\n", + " path[-1].parent[:] = 0\n", + "\n", + " path.reverse()\n", + " return path" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Exception while planning: Traceback (most recent call last):\n", + " File \"/Users/moomin/shad/dash/py_planning/planning_server.py\", line 51, in plan_request\n", + " response = self.do_plan(beatify_state(state))\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/var/folders/_b/djhkvpzn4v5_rm3tpbktdpd99dp62b/T/ipykernel_15244/1317474386.py\", line 32, in do_graph_planning\n", + " print(state.dynamicObstacles)\n", + " ^^^^^^^^^^^^^^^^^^^^^^\n", + "AttributeError: 'State' object has no attribute 'dynamicObstacles'\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "----------------------------------------\n", + "Exception occurred during processing of request from ('127.0.0.1', 60202)\n", + "Traceback (most recent call last):\n", + " File \"/opt/anaconda3/lib/python3.11/socketserver.py\", line 317, in _handle_request_noblock\n", + " self.process_request(request, client_address)\n", + " File \"/opt/anaconda3/lib/python3.11/socketserver.py\", line 348, in process_request\n", + " self.finish_request(request, client_address)\n", + " File \"/Users/moomin/shad/dash/py_planning/planning_server.py\", line 105, in finish_request\n", + " self.RequestHandlerClass(\n", + " File \"/Users/moomin/shad/dash/py_planning/planning_server.py\", line 18, in __init__\n", + " super().__init__(*args, **kwargs)\n", + " File \"/opt/anaconda3/lib/python3.11/socketserver.py\", line 755, in __init__\n", + " self.handle()\n", + " File \"/opt/anaconda3/lib/python3.11/http/server.py\", line 436, in handle\n", + " self.handle_one_request()\n", + " File \"/opt/anaconda3/lib/python3.11/http/server.py\", line 424, in handle_one_request\n", + " method()\n", + " File \"/Users/moomin/shad/dash/py_planning/planning_server.py\", line 29, in do_POST\n", + " self.plan_request()\n", + " File \"/Users/moomin/shad/dash/py_planning/planning_server.py\", line 64, in plan_request\n", + " self.wfile.write(jsonpickle.dumps(postprocess_planned_path(response)).encode('utf-8'))\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/Users/moomin/shad/dash/py_planning/data_types.py\", line 99, in postprocess_planned_path\n", + " for i in range(len(planned_path.states)):\n", + " ^^^^^^^^^^^^^^^^^^^\n", + "AttributeError: 'dict' object has no attribute 'states'\n", + "----------------------------------------\n" + ] + } + ], + "source": [ + "from py_planning.data_types import PlannedPath, PlannedState, State, Position # data types used by planner interface\n", + "from shapely.geometry import LineString, Point\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\"\"\"\n", + "find closest point on a polyline to the given point\n", + "\"\"\"\n", + "def get_index_of_closest_point(line: LineString, point: Point):\n", + " closest_point_index = None\n", + " min_distance = float('inf')\n", + "\n", + " for i, line_point in enumerate(line.coords):\n", + " line_point = Point(line_point)\n", + " distance = point.distance(line_point)\n", + " if distance < min_distance:\n", + " min_distance = distance\n", + " closest_point_index = i\n", + "\n", + " return closest_point_index, min_distance\n", + "\n", + "\n", + "def dist(x, y, static_obstacle):\n", + " return (x - static_obstacle.p[0]) ** 2 + (y - static_obstacle.p[1]) ** 2\n", + "\n", + "\n", + "def get_closest_static_obstacles(static_obstacles,x, y, k):\n", + " obstacles = sorted(static_obstacles, key=lambda obstacle: dist(x, y, obstacle))\n", + " return obstacles[:min(len(obstacles), k)]\n", + "\n", + "\n", + "def do_graph_planning(state: State) -> PlannedPath:\n", + " print(state.dynamic_obstacles)\n", + " vehicle_pose = state.vehicle_pose\n", + " vehicle_pos = Point(vehicle_pose.pos.x, vehicle_pose.pos.y) # current position of the AV\n", + " centerline = LineString([(p.x, p.y) for p in state.lane_path.centerline])\n", + " closest_index, _ = get_index_of_closest_point(centerline, vehicle_pos)\n", + " lane_path = state.lane_path.centerline[max(0, closest_index - 20) : min(len(state.lane_path.centerline), closest_index + 20) : 2]\n", + " obstacles = get_closest_static_obstacles(state.static_obstacles, state.vehicle_pose.pos.x, state.vehicle_pose.pos.y, 1)\n", + "\n", + " ds = 1\n", + " graph, path = search(state, lane_path, obstacles, tree_depth=12, ds=ds)\n", + " planned_path = list(map(lambda layer: PlannedState(pos=Position(float(layer.nodes[0, Layer.Id.X]), float(layer.nodes[0, Layer.Id.Y])), velocity=state.vehicle_pose.velocity, rot=float(layer.nodes[0, Layer.Id.YAW])), path))\n", + " return PlannedPath(states=planned_path) \n", + "\n", + "\n", + "py_planning.run_planner(\n", + " do_graph_planning,\n", + " stop_on_fail=True # set to False to continue planning after case fail (useful for debugging)\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/seminar06-planning/py_planning/__init__.py b/seminar06-planning/py_planning/__init__.py new file mode 100644 index 0000000..1531101 --- /dev/null +++ b/seminar06-planning/py_planning/__init__.py @@ -0,0 +1,2 @@ +from .py_planning import init, run_planner +from . import data_types diff --git a/seminar06-planning/py_planning/data_types.py b/seminar06-planning/py_planning/data_types.py new file mode 100644 index 0000000..24921b2 --- /dev/null +++ b/seminar06-planning/py_planning/data_types.py @@ -0,0 +1,104 @@ +from dataclasses import dataclass, field +from typing import List, Optional +import itertools + +@dataclass +class Position: + x: float + y: float + +@dataclass +class Size: + w: float + h: float + +@dataclass +class VehiclePose: + pos: Position + rot: float + velocity: float + curv: float + +@dataclass +class MultipleLanePath: + centerlines: List[List[Position]] + leftBoundaries: List[List[Position]] + rightBoundaries: List[List[Position]] + +@dataclass +class LanePath: + centerline: List[Position] + left_boundaries: List[Position] + right_boundaries: List[Position] + +@dataclass +class StaticObstacle: + p: List[float] # координаты препятствия в виде кортежа (x, y) + r: float # угол поворота (вращение) + w: float # ширина препятствия + h: float # высота препятствия + +@dataclass +class DynamicObstacle: + type: str + startPos: Position + velocity: Position + size: Size + parallel: bool + +@dataclass +class _RawState: + vehiclePose: VehiclePose + vehicleStation: float + lanePath: MultipleLanePath + startTime: float + dynamicObstacles: List[DynamicObstacle] + staticObstacles: List[StaticObstacle] + +@dataclass +class State: + vehicle_pose: VehiclePose # current AV position and velocity + vehicle_station: float # current 'station' that is the distance travelled along the centerline + lane_path: LanePath + start_time: float + dynamic_obstacles: List[DynamicObstacle] + static_obstacles: List[StaticObstacle] + +@dataclass +class PlannedState: + pos: Position + velocity: float + acceleration: float = 0 + rot: Optional[float] = field(default=None) + curv: Optional[float] = field(default=None) + +@dataclass +class PlannedPath: + states: List[PlannedState] + + +def _merge_multiple_lane_paths(multiple_lane_paths: MultipleLanePath) -> LanePath: + return LanePath( + centerline=list(p for p in itertools.chain(*multiple_lane_paths.centerlines)), + left_boundaries=list(p for p in itertools.chain(*multiple_lane_paths.leftBoundaries)), + right_boundaries=list(p for p in itertools.chain(*multiple_lane_paths.rightBoundaries)) + ) + +def beatify_state(raw_state: _RawState) -> State: + return State( + start_time=raw_state.startTime, + vehicle_pose=raw_state.vehiclePose, + vehicle_station=raw_state.vehicleStation, + dynamic_obstacles=raw_state.dynamicObstacles, + static_obstacles=raw_state.staticObstacles, + lane_path=_merge_multiple_lane_paths(raw_state.lanePath) + ) + +# this is essential for correct json serialization +def postprocess_planned_path(planned_path: PlannedPath) -> PlannedPath: + for i in range(len(planned_path.states)): + planned_path.states[i].acceleration = float(planned_path.states[i].acceleration) + planned_path.states[i].velocity = float(planned_path.states[i].velocity) + planned_path.states[i].pos.x = float(planned_path.states[i].pos.x) + planned_path.states[i].pos.y = float(planned_path.states[i].pos.y) + return planned_path diff --git a/seminar06-planning/py_planning/planner.py b/seminar06-planning/py_planning/planner.py new file mode 100644 index 0000000..418d547 --- /dev/null +++ b/seminar06-planning/py_planning/planner.py @@ -0,0 +1,30 @@ + +from shapely.geometry import LineString, Point + +def get_index_of_closest_point(line: LineString, point: Point): + closest_point_index = None + min_distance = float('inf') + + for i, line_point in enumerate(line.coords): + line_point = Point(line_point) + distance = point.distance(line_point) + if distance < min_distance: + min_distance = distance + closest_point_index = i + + return closest_point_index + + +def do_plan(state): + vehicle_pose = state['vehiclePose'] + vehicle_pos = Point(vehicle_pose['pos']['x'], vehicle_pose['pos']['y']) + + all_centerlines = [] + for centerline in state['lanePath']['centerlines']: + all_centerlines.extend(centerline) + + centerline = LineString([(p['x'], p['y']) for p in all_centerlines]) + + closest_index = get_index_of_closest_point(centerline, vehicle_pos) + + return [{'pos': p, 'velocity': vehicle_pose['velocity'], 'acceleration': 0} for p in all_centerlines][max(closest_index-3, 0):max(closest_index-3, 0) + 50] diff --git a/seminar06-planning/py_planning/planning_server.py b/seminar06-planning/py_planning/planning_server.py new file mode 100644 index 0000000..d8c4ea6 --- /dev/null +++ b/seminar06-planning/py_planning/planning_server.py @@ -0,0 +1,153 @@ +import json +import jsonpickle +import traceback + +from http.server import BaseHTTPRequestHandler, HTTPServer +from urllib.parse import urlparse +from dacite import from_dict +from shapely.geometry import Point + +from .data_types import _RawState, beatify_state, PlannedPath, postprocess_planned_path + + +class JSONRequestHandler(BaseHTTPRequestHandler): + def __init__(self, do_plan, on_case_status, verify_planned_trajectory, *args, **kwargs): + self.do_plan = do_plan + self.on_case_status = on_case_status + self.verify_planned_trajectory = verify_planned_trajectory + super().__init__(*args, **kwargs) + + def do_OPTIONS(self): + self.send_response(200) + self.end_headers() + + def do_POST(self): + # Parse query data & params to find out what was passed + parsed_path = urlparse(self.path) + try: + if parsed_path.path == '/plan': + self.plan_request() + elif parsed_path.path == '/notify_case_status': + self.notify_case_status_request() + elif parsed_path.path == '/ping': + self.ping_request() + else: + self.send_response(404) + except BrokenPipeError: + pass + + def ping_request(self): + # Send the "200 OK" response + self.send_response(200) + self.send_header('Content-type', 'application/json') + self.end_headers() + self.wfile.write('{"status": "ok"}') + + def plan_request(self): + content_length = int(self.headers['Content-Length']) + post_data = self.rfile.read(content_length) + try: + state = from_dict(data_class=_RawState, data=json.loads(post_data)) + response = self.do_plan(beatify_state(state)) + if not self.verify_planned_trajectory(response): + response = {'status': 'error', 'message': 'trajectory verification failed'} + except Exception: + print('Exception while planning: ', traceback.format_exc()) + response = {'status': 'error', 'message': traceback.format_exc()} + + # Send the "200 OK" response + self.send_response(200) + self.send_header('Content-type', 'application/json') + self.end_headers() + + # Send the response + self.wfile.write(jsonpickle.dumps(postprocess_planned_path(response)).encode('utf-8')) + + def notify_case_status_request(self): + content_length = int(self.headers['Content-Length']) + post_data = self.rfile.read(content_length) + response = "" + status = {} + try: + status = json.loads(post_data) + except json.JSONDecodeError: + response = {'status': 'error', 'message': 'Invalid JSON'} + + self.on_case_status(status) + + # Send the "200 OK" response + self.send_response(200) + self.send_header('Content-type', 'application/json') + self.end_headers() + + # Send the response + self.wfile.write(jsonpickle.dumps(response).encode('utf-8')) + + def end_headers(self): + self.send_header('Access-Control-Allow-Origin', '*') + self.send_header('Access-Control-Allow-Methods', 'POST') + self.send_header('Access-Control-Allow-Headers', 'Content-Type') + BaseHTTPRequestHandler.end_headers(self) + + def log_message(self, format, *args): + pass # Override the log_message method to silence all logs + + +class PlanningServer(HTTPServer): + def __init__(self, server_address): + super().__init__(server_address, JSONRequestHandler) + self.handles_planning_requests = True + self.case_completed = False + self.fail_reason = '' + self.stop_on_fail = True + + def finish_request(self, request, client_address): + self.RequestHandlerClass( + self.do_plan, + self.on_case_status, + self.verify_planned_trajectory, + request, client_address, self) + + def set_planner(self, do_plan): + self.do_plan = do_plan + + def set_stop_on_fail(self, stop_on_fail): + self.stop_on_fail = stop_on_fail + + def on_case_status(self, status): + status_string = status["status"] + self.handles_planning_requests = False + if status_string == 'reset': + self.fail_reason = '' + self.handles_planning_requests = True + if status_string == 'completed': + self.fail_reason = '' + self.case_completed = True + if status_string == 'failed': + self.case_completed = False + self.fail_reason = status["reason"] + if not self.stop_on_fail: + self.handles_planning_requests = True + + def verify_planned_trajectory(self, planned_path: PlannedPath): + if len(planned_path.states) < 2: + print("Invalid planned trajectory: too short.") + self.handles_planning_requests = False + self.case_completed = False + return False + + MAX_VELOCITY = 30.0 # m/s + for state in planned_path.states: + if state.velocity > MAX_VELOCITY: + print("Invalid planned trajectory: too high velocity: ", state.velocity, " > ",MAX_VELOCITY) + self.handles_planning_requests = False + self.case_completed = False + return False + + return True + + def run(self): + self.handles_planning_requests = True + while self.handles_planning_requests: + self.handle_request() + return self.case_completed diff --git a/seminar06-planning/py_planning/py_planning.py b/seminar06-planning/py_planning/py_planning.py new file mode 100644 index 0000000..ec6d95b --- /dev/null +++ b/seminar06-planning/py_planning/py_planning.py @@ -0,0 +1,44 @@ +from threading import Thread +from .planning_server import PlanningServer + + +def _run_visualization_server(): + def server_thread(): + from http.server import HTTPServer, SimpleHTTPRequestHandler + + class Handler(SimpleHTTPRequestHandler): + def __init__(self, *args, **kwargs): + super().__init__(*args, directory='./simulator', **kwargs) + + def log_message(self, format, *args): + pass # Override the log_message method to silence all logs + + def end_headers(self): + self.send_header('Cache-Control', 'no-store, no-cache, must-revalidate') + self.send_header('Pragma', 'no-cache') + self.send_header('Expires', '0') + SimpleHTTPRequestHandler.end_headers(self) + + httpd = HTTPServer(("127.0.0.1", 8008), Handler) + httpd.serve_forever() + + thread = Thread(target=server_thread) + thread.start() + + +def init(): + _run_visualization_server() + + global _p_server + _p_server = PlanningServer(('127.0.0.1', 9999)) + + +def run_planner(planning_function, stop_on_fail=True): + global _p_server + _p_server.set_planner(planning_function) + _p_server.set_stop_on_fail(stop_on_fail) + + if _p_server.run(): + print("Congrats! Case completed successfully.") + else: + print("Case failed: " + _p_server.fail_reason) diff --git a/seminar06-planning/scenarios/static01.txt b/seminar06-planning/scenarios/static01.txt new file mode 100644 index 0000000..72ffbd9 --- /dev/null +++ b/seminar06-planning/scenarios/static01.txt @@ -0,0 +1 @@ +eyJwIjpbLTE1LjM0NDM3LDY0LjEwMjQyLC01LjcyMTk1LDQyLjg5NTkyLDIuMTQ1NzUsMjQuMjk5ODIsMTAuMDEzNjIsNC45ODgxLDE2LjY4OTUyLC0xMi40MTY2MywyMi40MTE3NiwtMjIuNjY4ODksMjguODQ5MzQsLTMyLjkyMTI2LDI5LjgwMzE4LC00Mi40NTg0NCwyOC4zNzI4LC01My42NjQ3NiwyNi40NjU0OCwtNjAuNTc5MzYsMjMuNjA0NDgsLTcxLjA3MDU5XSwicyI6W3sicCI6WzI5LjU2NTE1LC02Ny42MTMyNF0sInIiOi0wLjQxMjAxLCJ3Ijo1LjI0NTM1LCJoIjo0LjUzMDN9LHsicCI6WzI0Ljc5NjE0LC0zMy45OTQxOV0sInIiOjAsInciOjMuMzM3ODksImgiOjMuNTc2NDN9LHsicCI6WzE2LjkyNzg0LC0yLjE2NDQ5XSwiciI6LTAuNTcyMjQsInciOjEuNDMwNSwiaCI6Mi4zODQyMX0seyJwIjpbMTEuMjA1NzcsLTQuMTkxMDddLCJyIjowLCJ3IjoxLjQzMDUxLCJoIjoyLjE0NTc5fSx7InAiOlsyNS43NDk2NSwtMjAuODgwN10sInIiOi0wLjk3MjgxLCJ3Ijo0Ljc2ODM5LCJoIjo0LjA1MzIzfSx7InAiOlsxLjI3NDQ5LDIwLjExNjk1XSwiciI6MCwidyI6Mi4wMzkxOCwiaCI6Mi41NDg5NX1dLCJkIjpbXSwibCI6MTQ1Ljg3NSwiYyI6eyJzIjoiMTAiLCJzbCI6IjEwIiwibHAiOjF9LCJ2IjoxfQ== diff --git a/seminar06-planning/scenarios/static02.txt b/seminar06-planning/scenarios/static02.txt new file mode 100644 index 0000000..55493ae --- /dev/null +++ b/seminar06-planning/scenarios/static02.txt @@ -0,0 +1 @@ +eyJwIjpbLTEwMi40NjA3OCwyNi4zODUxMywtNjguNjk4MjEsMjUuNzk3NzYsLTU1Ljk0OTEzLDE5LjUwNDI3LC0yNS4zMjI4NCwxMi42MTgzLC0xNi42MDI0LDEwLjc3MzksLTYuNzA4LDExLjc4MDEzLDMxLjM2MDU0LDEyLjExNTU0LDQ3LjA0MDU3LDE0Ljc5ODgsNTYuODUwNDgsMjMuMjY3NzYsNTYuODQ5NzksMzUuMjU4MjgsNDYuOTU1MTEsNDMuODk0NjMsMjUuNDg5NzksNDMuNTU5MjQsOC4xMzMyNiw1Mi4yNzk5LC0xNS4zNDQzNyw2NC4xMDI0Ml0sInMiOlt7InAiOlstMzYuMDkyNTQsMTIuMzY5NjNdLCJyIjowLjE0NzI2LCJ3IjozLjQzNzkxLCJoIjoxLjg0NDc1fSx7InAiOlstMTMuNDE2MjUsMTQuMjUzN10sInIiOjAuMTE2NTgsInciOjQuNjk1NjgsImgiOjEuNDI1NDl9LHsicCI6WzQ0LjAwOTMxLDE4LjM4MTY2XSwiciI6MC4yNTc3MSwidyI6NC45NDcxMywiaCI6NC4yNzY0Mn0seyJwIjpbNjIuNzQ2NjksMjkuNDEzMzFdLCJyIjowLCJ3Ijo0LjEwODU1LCJoIjo1Ljg2OTUyfSx7InAiOls0Ni43MTExOSwzOC43NDQ2OV0sInIiOjEuMTQ3NDIsInciOjQuNTI3NzUsImgiOjYuNzA3OTR9LHsicCI6WzE5LjczNTEsOS40MDYyMV0sInIiOjAuNjUwNDEsInciOjEuOTcxNzcsImgiOjEuMDc1NTN9LHsicCI6WzI4Ljk5Njc5LDkuNzE3MjddLCJyIjowLjIwODYyLCJ3IjoxLjk3MTc1LCJoIjoxLjAzMDcyfSx7InAiOlsyNC4xNTIwNSw5LjkzODcyXSwiciI6LTAuMzE5MDcsInciOjEuMjU0NzYsImgiOjAuOTg1OX1dLCJkIjpbXSwibCI6MjU5LjA4OCwiYyI6eyJzIjoiMTAiLCJzbCI6IjEwIiwibHAiOjF9LCJ2IjoxfQ== diff --git a/seminar06-planning/simulator/LICENSE b/seminar06-planning/simulator/LICENSE new file mode 100644 index 0000000..07ccd93 --- /dev/null +++ b/seminar06-planning/simulator/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 Matt Bradley + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/seminar06-planning/simulator/css/dash.css b/seminar06-planning/simulator/css/dash.css new file mode 100644 index 0000000..09c8971 --- /dev/null +++ b/seminar06-planning/simulator/css/dash.css @@ -0,0 +1,353 @@ +html { overflow: hidden !important; } +body { margin: 0; } +canvas { width: 100%; height: 100% } + +.editor-grab { + cursor: pointer; + cursor: hand; + cursor: -webkit-grab; + cursor: grab; +} + +.editor-grabbing { + cursor: pointer; + cursor: hand; + cursor: -webkit-grabbing; + cursor: grabbing; +} + +.editor-pointing { + cursor: pointer; +} + +.editor-removing { + cursor: pointer; + cursor: no-drop; +} + +#container { + position: relative; + height: 100%; +} + +#dashboard { + position: absolute; + top: 0; + left: 0; +} + +#planner-error { + position: absolute; + top: 100%; + left: -8px; + width: 100%; +} + +#editor-enabler, #editor-controls { + position: absolute; + left: 0; + bottom: 0; +} + +#editor-help { + position: absolute; + bottom: 100%; + left: -8px; + margin-right: 0; +} + +#editor-help-path .flex, #editor-help-static-obstacles .flex { + position: absolute; + bottom: 100%; + left: -8px; + display: flex; + flex-direction: row; +} + +#editor-clear-options { + position: absolute; + bottom: 100%; + margin-left: -8px; + padding-bottom: 0; + padding-right: 0; +} + +#editor-clear-options .button { + width: 100%; + margin-right: 0.5rem; +} + +#editor-road-box { + position: absolute; +} + +#editor-dynamic-obstacles-box { + width: 450px; + position: absolute; +} + +#editor-scenario-info { + position: absolute; + top: 0; + right: 0; + max-width: 50%; +} + +#editor-scenario-name { + white-space: nowrap; + text-overflow: ellipsis; + overflow: hidden; +} + +#welcome-modal .hero { + margin: -1.5rem -1.5rem 1.5rem -1.5rem; +} + +#welcome-modal a, #planner-error a { + color: #6697e5 !important; +} + +#welcome-modal a:hover, #planner-error a:hover { + color: #3273dc !important; +} + +#scenarios-modal .columns { + margin-bottom: 0; +} + +#scenarios-modal-items { + flex: 1; + margin-bottom: -0.75rem; + overflow-y: scroll; + overflow-x: hidden; +} + +#scenarios-modal-tabs a { + color: #dbdbdb; +} + +#scenarios-modal-tabs a:hover { + color: #4a4a4a; +} + +#scenarios-modal-tabs .is-active a { + color: #fff; +} + +.scenarios-modal-tab { + height: calc(50vh); + display: flex; + flex-direction: column; +} + +#scenarios-modal-examples-tab .columns { + height: 25%; + margin-top: 0; + margin-bottom: 0; +} + +#scenarios-modal-examples-tab .column:hover { + cursor: pointer; + color: #fff; + text-decoration: underline; +} + +#scenarios-modal-examples-tab img { + float: left; + height: 100%; +} + +#scenarios-modal-examples-tab .name { + padding-left: 0.75rem; + padding-bottom: 1.5rem; + overflow: hidden; + height: 100%; + display: flex; + flex-direction: column; + justify-content: center; +} + +.scenario-sort-button { + cursor: pointer; +} + +.scenario-item:hover { + background: rgba(255, 255, 255, 0.2); +} + +.scenario-item-name { + font-weight: bold; + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +} + +.scenario-item-name:hover { + cursor: pointer; + color: #fff; + text-decoration: underline; +} + +.is-underlined { + text-decoration: underline; +} + +.editor-dynamic-obstacle-form:last-child { + margin-bottom: 0; +} + +.editor-field-center { + -webkit-box-pack: center !important; + -ms-flex-pack: center !important; + justify-content: center !important; +} + +#editor-stats { + position: absolute; + right: 0; + bottom: 0; +} + +#editor-stats-sl { + position: absolute; + right: 100%; + top: -8px; + white-space: nowrap; +} + +#cameras { + position: absolute; + right: 0; + bottom: 0; +} + +.gui-box { + background: #222b; + padding: 8px; + margin: 8px; + -webkit-touch-callout: none; + -webkit-user-select: none; + -moz-user-select: none; + -ms-user-select: none; + user-select: none; + border-radius: 2px; +} + +.modal-box { + background: #222; + padding: 1.5rem; + border-radius: 2px; +} + +.allow-user-select { + -webkit-touch-callout: auto !important; + -webkit-user-select: auto !important; + -moz-user-select: auto !important; + -ms-user-select: auto !important; + user-select: auto !important; +} + +#controls { + position: relative; + padding: 8px; + overflow: hidden; +} + +#stats { + padding: 8px 8px 8px 0; + width: 300px; + line-height: 1.2; +} + +#stats .units-button { + cursor: pointer; +} + +#config-box { + position: absolute; + top: 0; + right: 0; +} + +#gear { + display: none; + position: absolute; + color: #aaa; + font-weight: bold; + font-size: 13px; + top: 50%; + margin-top: -8px; + text-align: center; + width: 100%; + margin-left: -8px; +} + +#brake, #gas { + position: absolute; + border: 63px solid; + border-radius: 100%; + width: 200%; + height: 200%; + bottom: -50%; + box-sizing: border-box; + clip-path: inset(50% 50% 0 50%); +} + +#brake { + left: -50%; + border-color: red; +} + +#gas { + right: -50%; + border-color: green; +} + +#wheel-wrapper { + position: relative; + width: 100px; + height: 100px; +} + +#wheel { + width: 100px; + height: 100px; + mask-image: url('../images/wheel.png'); + mask-size: contain; + -webkit-mask-image: url('../images/wheel.png'); + -webkit-mask-size: contain; + background-color: hsl(0, 0%, 86%); +} + +#wheel-marker { + height: 4px; + width: 3px; + border-radius: 1px; + background: #804000; + position: absolute; + top: 4px; + left: 50%; + margin-left: -1.5px; +} + +#wheel-pie { + height: 100%; + width: 100%; + clip-path: inset(0 0 0 50%); + left: 0; + position: absolute; + top: 0; + box-sizing: border-box; +} + +#wheel-pie-left, #wheel-pie-right { + height: 100%; + width: 100%; + border: 2px solid #ff8000; + border-radius: 50%; + clip-path: inset(0 50% 0 0); + left: 0; + position: absolute; + top: 0; + box-sizing: border-box; +} diff --git a/seminar06-planning/simulator/dist/Dash.js b/seminar06-planning/simulator/dist/Dash.js new file mode 100644 index 0000000..5c81594 --- /dev/null +++ b/seminar06-planning/simulator/dist/Dash.js @@ -0,0 +1 @@ +(()=>{var __webpack_modules__={236:(__unused_webpack_module,__unused_webpack___webpack_exports__,__webpack_require__)=>{"use strict";eval('\n;// CONCATENATED MODULE: ./js/physics/Car.js\nclass Car_Car {\n constructor(x = 0, y = 0, rotation = 0) {\n this.setPose(x, y, rotation);\n }\n\n static getFrontAxlePosition(pos, rot) {\n return THREE.Vector2.fromAngle(rot).multiplyScalar(Car_Car.WHEEL_BASE).add(pos);\n }\n\n static getFakeAxlePosition(pos, rot) {\n return Car_Car.frontToRearAxlePosition(pos, rot);\n }\n\n static centerToRearAxlePosition(pos, rot) {\n return THREE.Vector2.fromAngle(rot).multiplyScalar(Car_Car.REAR_AXLE_POS).add(pos);\n }\n\n static frontToRearAxlePosition(pos, rot) {\n return THREE.Vector2.fromAngle(rot).multiplyScalar(-Car_Car.WHEEL_BASE).add(pos);\n }\n\n get pose() {\n return { pos: this.rearAxlePosition.clone(), rot: this.rotation, velocity: this.velocity, curv: this.curvature, dCurv: this.dCurv, ddCurv: this.ddCurv };\n }\n\n get curvature() {\n return Math.tan(this.wheelAngle) / Car_Car.WHEEL_BASE;\n }\n\n get rearAxlePosition() {\n const { x, y } = this.position;\n const rot = this.rotation;\n return new THREE.Vector2(x + Math.cos(rot) * Car_Car.REAR_AXLE_POS, y + Math.sin(rot) * Car_Car.REAR_AXLE_POS);\n }\n\n get frontAxlePosition() {\n const { x, y } = this.position;\n const rot = this.rotation;\n return new THREE.Vector2(x + Math.cos(rot) * Car_Car.FRONT_AXLE_POS, y + Math.sin(rot) * Car_Car.FRONT_AXLE_POS);\n }\n\n setPose(x, y, rotation) {\n // Translate so that x and y become the center of the vehicle (instead of the center of the rear axle)\n x -= Car_Car.REAR_AXLE_POS * Math.cos(rotation);\n y -= Car_Car.REAR_AXLE_POS * Math.sin(rotation);\n\n this.position = new THREE.Vector2(x, y);\n this.rotation = Math.wrapAngle(rotation);\n this.velocity = 0;\n this.acceleration = 0;\n this.wheelAngle = 0;\n this.wheelAngularVelocity = 0;\n this.dCurv = 0; // derivative with respect to arc length\n this.ddCurv = 0; // derivative with respect to arc length\n }\n\n step(dt) {\n const curvPrev = this.curvature;\n const dCurvPrev = this.dCurv;\n\n const drag = (0.5 * Car_Car.DRAG_COEFF * Car_Car.FRONTAL_AREA * Car_Car.DENSITY_OF_AIR * Math.abs(this.velocity) + Car_Car.ROLL_RESIST) * -this.velocity;\n this.velocity += (this.acceleration + drag / Car_Car.MASS) * dt;\n\n const velocitySq = this.velocity * this.velocity;\n const maxWheelAngle = Math.clamp(Math.atan(Car_Car.MAX_LATERAL_ACCEL * Car_Car.WHEEL_BASE / velocitySq), 0.07, Car_Car.MAX_WHEEL_ANGLE);\n this.wheelAngle = Math.clamp(Math.wrapAngle(this.wheelAngle + this.wheelAngularVelocity * dt), -maxWheelAngle, maxWheelAngle);\n\n const angularVelocity = this.velocity * this.curvature;\n this.rotation = Math.wrapAngle(this.rotation + angularVelocity * dt);\n\n const dist = this.velocity * dt;\n this.position = THREE.Vector2.fromAngle(this.rotation).multiplyScalar(dist).add(this.position);\n\n this.dCurv = dist > 0.1 ? (this.curvature - curvPrev) / dist : 0;\n this.ddCurv = dist > 0.1 ? (this.dCurv - dCurvPrev) / dist : 0;\n }\n\n update(controls, dt) {\n const gas = Math.clamp(controls.gas, -1, +1);\n const brake = Math.clamp(controls.brake, 0, 1);\n const steer = Math.clamp(controls.steer, -1, +1);\n\n if (brake > 0) {\n this.acceleration = -Math.sign(this.velocity) * Car_Car.MAX_BRAKE_DECEL * brake;\n const newVelocity = this.velocity + this.acceleration * dt;\n\n // If applying the braking deceleration at the next step would cause the velocity\n // to change directions, then just set the car as stopped.\n if (Math.sign(newVelocity) != Math.sign(this.velocity)) {\n this.velocity = 0;\n this.acceleration = 0;\n }\n } else {\n this.acceleration = Car_Car.MAX_GAS_ACCEL * gas;\n }\n\n if (steer != 0) {\n this.wheelAngularVelocity = steer * Car_Car.MAX_STEER_SPEED;\n } else {\n this.wheelAngularVelocity = Math.clamp(-this.wheelAngle / Car_Car.MAX_WHEEL_ANGLE * this.velocity * this.velocity * dt, -Car_Car.MAX_STEER_SPEED, Car_Car.MAX_STEER_SPEED);\n }\n }\n}\n\nCar_Car.HALF_CAR_LENGTH = 2.5; // meters\nCar_Car.HALF_CAR_WIDTH = 1; // meters\nCar_Car.HALF_WHEEL_LENGTH = 0.38; // meters\nCar_Car.HALF_WHEEL_WIDTH = 0.12; // meters\nCar_Car.MAX_WHEEL_ANGLE = 32 / 180 * Math.PI; // radians\nCar_Car.MASS = 1600; // kg\nCar_Car.DRAG_COEFF = 0.7;\nCar_Car.DENSITY_OF_AIR = 1.8580608; // (kg/m^3)\nCar_Car.FRONTAL_AREA = 1.85; // m^2\nCar_Car.ROLL_RESIST = 0;\nCar_Car.MAX_STEER_SPEED = 0.8;//1.2; // Radians per second\nCar_Car.MAX_GAS_ACCEL = 3.0; // m / s^2\nCar_Car.MAX_BRAKE_DECEL = 3.0; // m / s^2\nCar_Car.WHEEL_LATERAL_POS = 0.843; // meters\nCar_Car.FRONT_AXLE_POS = 1.6; // meters\nCar_Car.REAR_AXLE_POS = -1.43; // meters\nCar_Car.WHEEL_BASE = Car_Car.FRONT_AXLE_POS - Car_Car.REAR_AXLE_POS; // meters\nCar_Car.MAX_LATERAL_ACCEL = 5.81; // m / s^2\n\n;// CONCATENATED MODULE: ./js/physics/Physics.js\n\n\nclass Physics {\n constructor() {\n this.cars = [];\n }\n\n step(dt) {\n this.cars.forEach(c => c.step(dt));\n }\n\n createCar() {\n const newCar = new Car_Car();\n this.cars.push(newCar);\n\n return newCar;\n }\n};\n\n;// CONCATENATED MODULE: ./js/autonomy/Path.js\n\n\n// input pose: { pos: Vector2 [, rot: radians] }\n// pose: { pos: Vector2, frontPos: Vector2, fakePos: Vector2, rot: radians }\nclass Path {\n constructor(poses, startRotation = 0, goalRotation = 0) {\n this.poses = poses;\n\n for (let i = 0; i < poses.length; i++) {\n const pose = poses[i];\n\n if (pose.rot === undefined || pose.rot == null) {\n let rot;\n\n if (i == 0) {\n rot = startRotation;\n } else if (i == poses.length - 1) {\n rot = goalRotation;\n } else {\n const prev = poses[i - 1].pos;\n const next = poses[i + 1].pos;\n rot = Math.atan2(next.y - prev.y, next.x - prev.x);\n }\n\n pose.rot = rot;\n }\n\n if (pose.curv === undefined || pose.curv == null) {\n if (i > 0 && i < poses.length - 1) {\n const prev = poses[i - 1].pos;\n const cur = poses[i].pos;\n const next = poses[i + 1].pos;\n\n const dir1 = { x: cur.x - prev.x, y: cur.y - prev.y };\n const dir2 = { x: next.x - cur.x, y: next.y - cur.y };\n\n const angle1 = Math.atan2(dir1.y, dir1.x);\n const angle2 = Math.atan2(dir2.y, dir2.x);\n\n // Calculate the angular difference in a way that properly handles the wrap-around from -π to π\n let deltaAngle = angle2 - angle1;\n // Normalize the angle difference to be within the range [-π, π]\n deltaAngle = (deltaAngle + Math.PI) % (2 * Math.PI) - Math.PI;\n\n // Assuming uniform segment lengths, the curvature (inverse radius of curvature) can be\n // approximated as the change in angle. For non-uniform segment lengths, include arc length in calculation\n const curvature = Math.abs(deltaAngle); // Using absolute value of angle difference\n\n pose.curv = curvature;\n } else {\n // Assign zero curvature for start and end points or handle as needed\n pose.curv = 0;\n }\n }\n\n pose.frontPos = Car_Car.getFrontAxlePosition(pose.pos, pose.rot);\n pose.fakePos = Car_Car.getFakeAxlePosition(pose.pos, pose.rot);\n }\n }\n}\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/CubicPath.js\nconst SIMPSONS_INTERVALS = 8;\nconst NEWTON_ITERATIONS = 16;\nconst RELAXATION_ITERATIONS = 32;\nconst CONVERGENCE_ERROR = 0.01;\n\nconst jacobian = new THREE.Matrix3();\nconst invJacobian = new THREE.Matrix3();\n\n// Alternate reference implementation: https://github.com/ApolloAuto/apollo/blob/master/modules/planning/math/spiral_curve/cubic_spiral_curve.cc\nclass CubicPath_CubicPath {\n constructor(start, end, params = null) {\n this.start = Object.assign({}, start);\n this.end = Object.assign({}, end);\n\n if (start.pos) {\n this.start.x = start.pos.x;\n this.start.y = start.pos.y\n }\n\n if (end.pos) {\n this.end.x = end.pos.x;\n this.end.y = end.pos.y\n }\n\n const diffX = this.end.x - this.start.x;\n const diffY = this.end.y - this.start.y;\n const sinRot = Math.sin(this.start.rot);\n const cosRot = Math.cos(this.start.rot);\n\n this.goal = {\n x: cosRot * diffX + sinRot * diffY,\n y: -sinRot * diffX + cosRot * diffY,\n rot: Math.wrapAngle(this.end.rot - this.start.rot),\n curv: this.end.curv\n };\n\n if (params)\n this.params = Object.assign({}, params, { p0: this.start.curv, p3: this.end.curv });\n else\n this.guessInitialParams();\n\n this.converged = false;\n }\n\n guessInitialParams() {\n const originalGoal = this.goal;\n const dStartCurv = this.start.curv / RELAXATION_ITERATIONS;\n const dGoalY = originalGoal.y / RELAXATION_ITERATIONS;\n const dGoalRot = originalGoal.rot / RELAXATION_ITERATIONS;\n const dGoalCurv = originalGoal.curv / RELAXATION_ITERATIONS;\n\n this.goal = {\n x: originalGoal.x,\n y: 0,\n rot: 0,\n curv: 0\n };\n\n this.params = {\n p0: 0,\n p1: 0,\n p2: 0,\n p3: 0,\n sG: originalGoal.x\n };\n\n for (let i = 0; i < RELAXATION_ITERATIONS; i++) {\n this.params.p0 += dStartCurv;\n this.params.p3 += dGoalCurv;\n this.goal.y += dGoalY;\n this.goal.rot += dGoalRot;\n this.goal.curv += dGoalCurv;\n\n this.iterate();\n }\n\n this.goal = originalGoal;\n }\n\n optimize() {\n for (let i = 0; i < NEWTON_ITERATIONS; i++) {\n if (this.iterate()) {\n this.converged = true;\n return true;\n }\n }\n\n this.converged = false;\n return false;\n }\n\n iterate() {\n const { p0, p1, p2, p3, sG } = this.params;\n\n const ds = sG / SIMPSONS_INTERVALS;\n const sG_2 = sG * sG;\n const sG_3 = sG_2 * sG;\n\n let dX_p1 = 0;\n let dX_p2 = 0;\n let dX_sG = 0;\n let dY_p1 = 0;\n let dY_p2 = 0;\n let dY_sG = 0;\n let guessX = 0;\n let guessY = 0;\n\n let theta, cosTheta, sinTheta, dT_p1, dT_p2, dT_sG;\n\n for (let i = 0, s = 0; i <= SIMPSONS_INTERVALS; i++, s += ds) {\n const coeff = i == 0 || i == SIMPSONS_INTERVALS ? 1 : i % 2 == 0 ? 2 : 4;\n\n const a = p0;\n const b = (-5.5 * p0 + 9 * p1 - 4.5 * p2 + p3) / sG;\n const c = (9 * p0 - 22.5 * p1 + 18 * p2 - 4.5 * p3) / sG_2;\n const d = (-4.5 * (p0 - 3 * p1 + 3 * p2 - p3)) / sG_3;\n\n theta = (((d * s / 4 + c / 3) * s + b / 2) * s + a) * s;\n cosTheta = Math.cos(theta);\n sinTheta = Math.sin(theta);\n\n const s_sG = s / sG;\n dT_p1 = ((3.375 * s_sG - 7.5) * s_sG + 4.5) * s_sG * s;\n dT_p2 = ((-3.375 * s_sG + 6) * s_sG - 2.25) * s_sG * s;\n dT_sG = ((3.375 * (p0 - 3 * p1 + 3 * p2 - p3) * s_sG - 3 * (2 * p0 - 5 * p1 + 4 * p2 - p3)) * s_sG + 0.25 * (11 * p0 - 18 * p1 + 9 * p2 - 2 * p3)) * s_sG * s_sG;\n\n dX_p1 -= coeff * sinTheta * dT_p1;\n dX_p2 -= coeff * sinTheta * dT_p2;\n dX_sG -= coeff * sinTheta * dT_sG;\n\n dY_p1 += coeff * cosTheta * dT_p1;\n dY_p2 += coeff * cosTheta * dT_p2;\n dY_sG += coeff * cosTheta * dT_sG;\n\n guessX += coeff * cosTheta;\n guessY += coeff * sinTheta;\n }\n\n // After the Simpson\'s integration loop, `theta`, `cosTheta`, `sinTheta`,\n // `dT_p1`, `dT_p2`, and `dT_sG` hold the appropriate values for `sG`.\n\n const hOver3 = sG / SIMPSONS_INTERVALS / 3;\n\n const deltaX = this.goal.x - guessX * hOver3;\n const deltaY = this.goal.y - guessY * hOver3;\n const deltaRot = Math.wrapAngle(this.goal.rot - theta);\n\n if (Math.abs(deltaX) + Math.abs(deltaY) + Math.abs(deltaRot) < CONVERGENCE_ERROR)\n return true;\n\n jacobian.set(\n dX_p1 * hOver3, dX_p2 * hOver3, cosTheta + dX_sG * hOver3,\n dY_p1 * hOver3, dY_p2 * hOver3, sinTheta + dY_sG * hOver3,\n dT_p1, dT_p2, dT_sG\n );\n\n const [m11, m21, m31, m12, m22, m32, m13, m23, m33] = invJacobian.getInverse(jacobian).elements;\n\n this.params.p1 += m11 * deltaX + m12 * deltaY + m13 * deltaRot;\n this.params.p2 += m21 * deltaX + m22 * deltaY + m23 * deltaRot;\n this.params.sG += m31 * deltaX + m32 * deltaY + m33 * deltaRot;\n\n return false;\n }\n\n buildPath(num) {\n const { p0, p1, p2, p3, sG } = this.params;\n\n const sG_2 = sG * sG;\n const sG_3 = sG_2 * sG;\n\n const a = p0;\n const b = (-5.5 * p0 + 9 * p1 - 4.5 * p2 + p3) / sG;\n const c = (9 * p0 - 22.5 * p1 + 18 * p2 - 4.5 * p3) / sG_2;\n const d = (-4.5 * (p0 - 3 * p1 + 3 * p2 - p3)) / sG_3;\n\n const path = [{ pos: new THREE.Vector2(this.start.x, this.start.y), rot: this.start.rot, curv: this.start.curv }];\n const ds = sG / (num - 1);\n let s = ds;\n let dx = 0;\n let dy = 0;\n let prevCosRot = Math.cos(path[0].rot);\n let prevSinRot = Math.sin(path[0].rot);\n\n for (let i = 1; i < num - 1; i++) {\n const rot = (((d * s / 4 + c / 3) * s + b / 2) * s + a) * s + this.start.rot;\n const curv = ((d * s + c) * s + b) * s + a;\n const cosRot = Math.cos(rot);\n const sinRot = Math.sin(rot);\n\n dx = dx * (i - 1) / i + (cosRot + prevCosRot) / (2 * i);\n dy = dy * (i - 1) / i + (sinRot + prevSinRot) / (2 * i);\n\n path.push({ pos: new THREE.Vector2(s * dx + this.start.x, s * dy + this.start.y), rot: rot, curv: curv });\n\n s += ds;\n prevCosRot = cosRot;\n prevSinRot = sinRot;\n }\n\n path.push({ pos: new THREE.Vector2(this.end.x, this.end.y), rot: this.end.rot, curv: this.end.curv });\n\n return path;\n }\n}\n\n;// CONCATENATED MODULE: ./js/autonomy/control/AutonomousController.js\n\n\nclass AutonomousController {\n constructor(path) {\n this.path = path;\n this.nextIndex = 1;\n this.prevPhiError = 0;\n this.prevVelocity = 0;\n }\n\n reset() {\n this.prevVelocity = 0;\n }\n\n replacePath(path) {\n this.path = path;\n this.nextIndex = 1;\n }\n\n predictPoseAfterTime(currentPose, predictionTime) {\n const pathPoses = this.path.poses;\n const frontAxlePos = Car.getFrontAxlePosition(currentPose.pos, currentPose.rot);\n let [nextIndex, progress] = this.findNextIndex(frontAxlePos);\n let currentVelocity = currentPose.velocity;\n\n if (currentVelocity <= 0.01) return currentPose;\n\n while (predictionTime > 0) {\n const prevPose = pathPoses[nextIndex - 1];\n const nextPose = pathPoses[nextIndex];\n\n const segmentDist = nextPose.pos.distanceTo(prevPose.pos);\n const distLeft = segmentDist * (1 - progress);\n const sumV = currentVelocity + nextPose.velocity;\n const timeToNextIndex = 2 * distLeft / (sumV == 0 ? 0.01 : sumV);\n //const timeToNextIndex = distLeft / currentVelocity;\n\n if (timeToNextIndex >= predictionTime || nextIndex + 1 >= pathPoses.length) {\n const dist = sumV / 2 * predictionTime;\n const newProgress = progress + dist / segmentDist;\n\n return {\n pos: nextPose.pos.clone().sub(prevPose.pos).multiplyScalar(newProgress).add(nextPose.pos),\n rot: prevPose.rot + (nextPose.rot - prevPose.rot) * newProgress,\n curv: prevPose.curv + (nextPose.curv - prevPose.curv) * newProgress,\n dCurv: 0,\n ddCurv: 0,\n velocity: nextPose.velocity\n }\n }\n\n //currentVelocity = nextPose.velocity;\n predictionTime -= timeToNextIndex;\n progress = 0;\n nextIndex++;\n }\n }\n\n control(pose, wheelAngle, velocity, dt) {\n const pathPoses = this.path.poses;\n const frontAxlePos = Car.getFrontAxlePosition(pose.pos, pose.rot);\n const [nextIndex, progress] = this.findNextIndex(frontAxlePos);\n this.nextIndex = nextIndex;\n\n let gas = 0;\n let brake = 0;\n let phi = 0; // the desired wheel deflection\n\n if (nextIndex >= pathPoses.length - 1 && progress >= 1) {\n gas = 0;\n brake = 1;\n phi = 0;\n } else {\n const kp_a = 4;\n const kd_a = 0.5;\n const kff_a = 0.5;\n\n const currentAccel = (velocity - this.prevVelocity) / dt;\n const prevNextDist = pathPoses[this.nextIndex].pos.distanceTo(pathPoses[this.nextIndex - 1].pos);\n const targetVelocity = Math.sqrt(2 * pathPoses[nextIndex].acceleration * prevNextDist * Math.clamp(progress, 0, 1) + pathPoses[this.nextIndex - 1].velocity * pathPoses[this.nextIndex - 1].velocity);\n const diffVelocity = targetVelocity - velocity;\n const diffAccel = pathPoses[this.nextIndex].acceleration - currentAccel;\n const targetAccel = kp_a * diffVelocity + kd_a * diffAccel + kff_a * pathPoses[this.nextIndex].acceleration;\n\n if (targetAccel > 0)\n gas = Math.min(targetAccel / Car.MAX_GAS_ACCEL, 1);\n else\n brake = Math.min(-targetAccel / Car.MAX_BRAKE_DECEL, 1);\n\n this.prevVelocity = velocity;\n\n const closestFrontPathPos = projectPointOnSegment(frontAxlePos, pathPoses[this.nextIndex - 1].frontPos, pathPoses[this.nextIndex].frontPos)[0];\n\n // Determine the desired heading at the specific point on the front path by lerping between prevHeading and nextHeading using progress as the weight\n const prevHeading = this.nextIndex > 1 ? pathPoses[nextIndex].frontPos.clone().sub(pathPoses[nextIndex - 2].frontPos).angle() : pathPoses[0].rot;\n const nextHeading = this.nextIndex < pathPoses.length - 1 ? pathPoses[nextIndex + 1].frontPos.clone().sub(pathPoses[nextIndex - 1].frontPos).angle() : pathPoses[pathPoses.length - 1].rot;\n const desiredHeading = prevHeading + (nextHeading - prevHeading) * progress;\n\n // Determine if the front axle is to the left or right of the front path\n const pathVec = pathPoses[nextIndex].frontPos.clone().sub(pathPoses[nextIndex - 1].frontPos).normalize();\n const zero = new THREE.Vector2(0, 0);\n const left = pathVec.clone().rotateAround(zero, Math.PI / 2).add(closestFrontPathPos);\n const right = pathVec.clone().rotateAround(zero, -Math.PI / 2).add(closestFrontPathPos);\n const dir = frontAxlePos.distanceToSquared(left) < frontAxlePos.distanceToSquared(right) ? -1 : 1;\n\n const k = 4;\n const gain = 0.8;\n const crossTrackError = frontAxlePos.distanceTo(closestFrontPathPos);\n const headingError = Math.wrapAngle(pose.rot - desiredHeading);\n\n //phi = -headingError + gain * Math.atan(k * dir * crossTrackError / velocity);\n\n const curv = pathPoses[nextIndex - 1].curv + (pathPoses[nextIndex].curv - pathPoses[nextIndex - 1].curv) * progress;\n\n phi = Math.atan(curv * Car.WHEEL_BASE) + gain * Math.atan(k * dir * crossTrackError / Math.max(velocity, 0.01));\n\n const checkSteer = Math.clamp((phi - wheelAngle) / dt / Car.MAX_STEER_SPEED, -1, 1);\n }\n\n const phiError = phi - wheelAngle;\n /*\n const dPhiError = (phiError - this.prevPhiError) / dt;\n this.prevPhiError = phiError;\n \n const steer = Math.clamp(12 * phiError + 0.8 * dPhiError, -1, 1);\n */\n\n const steer = Math.clamp(phiError / dt / Car.MAX_STEER_SPEED, -1, 1);\n\n return { gas, brake, steer };\n }\n\n // Finds the next point the vehicle is approaching and the progress between the prev point and the next point\n // Returns [nextPointIndex, progress from (nextPointIndex - 1) to nextPointIndex, {0 - 1}]\n findNextIndex(frontAxlePos) {\n const pathPoses = this.path.poses;\n\n // Constrain the search to just a few points surrounding the current nextIndex\n // for performance and to avoid problems with a path that crosses itself\n const start = Math.max(0, this.nextIndex - 20);\n const end = Math.min(pathPoses.length - 1, this.nextIndex + 20);\n let closestDistSqr = frontAxlePos.distanceToSquared(pathPoses[start].frontPos);\n let closestIndex = start;\n\n for (let i = start + 1; i < end; i++) {\n const distSqr = frontAxlePos.distanceToSquared(pathPoses[i].frontPos);\n if (distSqr < closestDistSqr) {\n closestDistSqr = distSqr;\n closestIndex = i;\n }\n }\n\n if (closestIndex == pathPoses.length - 1) {\n const [_, progress] = projectPointOnSegment(frontAxlePos, pathPoses[closestIndex - 1].frontPos, pathPoses[closestIndex].frontPos);\n return [closestIndex, progress];\n } else if (closestIndex == 0) {\n const [_, progress] = projectPointOnSegment(frontAxlePos, pathPoses[closestIndex].frontPos, pathPoses[closestIndex + 1].frontPos);\n return [closestIndex + 1, progress];\n } else {\n // The nextPoint is either (closestPoint) or (closestPoint + 1). Project the frontAxlePos to both\n // of those two line segments (the segment preceding closestPoint and the segment succeeding closestPoint)\n // to determine which segment it\'s closest to.\n const [precedingProjection, precedingProgress] = projectPointOnSegment(frontAxlePos, pathPoses[closestIndex - 1].frontPos, pathPoses[closestIndex].frontPos);\n const [succeedingProjection, succeedingProgress] = projectPointOnSegment(frontAxlePos, pathPoses[closestIndex].frontPos, pathPoses[closestIndex + 1].frontPos);\n\n if (frontAxlePos.distanceToSquared(precedingProjection) < frontAxlePos.distanceToSquared(succeedingProjection)) {\n return [closestIndex, precedingProgress];\n } else {\n return [closestIndex + 1, succeedingProgress];\n }\n }\n }\n}\n\n// Returns [pointOnSegment, progressAlongSegment {0 - 1}]\nfunction projectPointOnSegment(point, start, end) {\n const distSqr = start.distanceToSquared(end);\n //const progress = Math.clamp(point.clone().sub(start).dot(end.clone().sub(start)) / distSqr, 0, 1);\n const progress = point.clone().sub(start).dot(end.clone().sub(start)) / distSqr;\n return [end.clone().sub(start).multiplyScalar(progress).add(start), progress];\n}\n\n;// CONCATENATED MODULE: ./js/autonomy/control/FollowController.js\n\n\nclass FollowController {\n constructor(path, car) {\n this.path = path;\n this.car = car;\n this.nextIndex = 1;\n this.prevVelocity = 0;\n this.prevAccel = 0;\n }\n\n reset() {\n this.prevVelocity = 0;\n this.prevAccel = 0;\n }\n\n replacePath(path) {\n this.path = path;\n this.nextIndex = 1;\n }\n\n predictPoseAfterTime(currentPose, predictionTime) {\n const pathPoses = this.path.poses;\n let [nextIndex, progress] = this.findNextIndex(currentPose.pos);\n let currentVelocity = currentPose.velocity;\n\n if (currentVelocity <= 0.01) return currentPose;\n\n while (predictionTime > 0) {\n const prevPose = pathPoses[nextIndex - 1];\n const nextPose = pathPoses[nextIndex];\n\n const segmentDist = nextPose.pos.distanceTo(prevPose.pos);\n const distLeft = segmentDist * (1 - progress);\n const sumV = (currentVelocity + nextPose.velocity) / 2;\n const timeToNextIndex = 2 * distLeft / (sumV == 0 ? 0.01 : sumV);\n\n if (timeToNextIndex >= predictionTime || nextIndex + 1 >= pathPoses.length) {\n const dist = sumV / 2 * predictionTime;\n const newProgress = progress + dist / segmentDist;\n const newRotation = Math.wrapAngle(prevPose.rot + Math.wrapAngle(nextPose.rot - prevPose.rot) * newProgress);\n\n const pprevPose = nextIndex - 2 >= 0 ? pathPoses[nextIndex - 2] : prevPose;\n const nnextPose = nextIndex + 1 < pathPoses.length ? pathPoses[nextIndex + 1] : nextPose;\n\n const dCurv = (nextPose.curv - prevPose.curv) / segmentDist;\n const dCurvPrev = ((prevPose.curv - pprevPose.curv) / pprevPose.pos.distanceTo(prevPose.pos) + dCurv) / 2;\n const dCurvNext = (dCurv + (nnextPose.curv - nextPose.curv) / nextPose.pos.distanceTo(nnextPose.pos)) / 2;\n\n const ddCurv = (dCurvNext - dCurvPrev) / segmentDist;\n\n return {\n pos: nextPose.pos.clone().sub(prevPose.pos).multiplyScalar(newProgress).add(nextPose.pos),\n rot: newRotation,\n curv: prevPose.curv + (nextPose.curv - prevPose.curv) * newProgress,\n dCurv: dCurv,\n ddCurv: ddCurv,\n velocity: nextPose.velocity\n }\n }\n\n currentVelocity = nextPose.velocity;\n predictionTime -= timeToNextIndex;\n progress = 0;\n nextIndex++;\n }\n }\n\n control(pose, wheelAngle, velocity, dt, lockPath = false) {\n const pathPoses = this.path.poses;\n const [nextIndex, progress, projection] = this.findNextIndex(pose.pos);\n this.nextIndex = nextIndex;\n\n const prevPose = pathPoses[nextIndex - 1];\n const nextPose = pathPoses[nextIndex];\n\n let gas = 0;\n let brake = 0;\n let steer = 0;\n\n if (nextIndex >= pathPoses.length - 2 && progress >= 1 - 1e-6) {\n brake = 1;\n } else {\n /*\n const kp_a = 4;\n const kd_a = 0.5;\n const kff_a = 0.5;\n\n const currentAccel = (velocity - this.prevVelocity) / dt;\n const prevNextDist = nextPose.pos.distanceTo(prevPose.pos);\n const targetVelocity = Math.sqrt(2 * nextPose.acceleration * prevNextDist * Math.clamp(progress, 0, 1) + prevPose.velocity * prevPose.velocity);\n const diffVelocity = targetVelocity - velocity;\n const diffAccel = nextPose.acceleration - currentAccel;\n const targetAccel = kp_a * diffVelocity + kd_a * diffAccel + kff_a * nextPose.acceleration;\n */\n const accelDamping = 0.1;\n const targetAccel = nextPose.acceleration;\n const dampedAccel = this.prevAccel * (1 - accelDamping) + targetAccel * accelDamping;\n\n if (dampedAccel > 0)\n gas = Math.min(dampedAccel / Car_Car.MAX_GAS_ACCEL, Car_Car.MAX_GAS_ACCEL);\n else\n brake = Math.min(-dampedAccel / Car_Car.MAX_BRAKE_DECEL, Car_Car.MAX_BRAKE_DECEL);\n\n this.prevVelocity = velocity;\n this.prevAccel = dampedAccel;\n\n const curvature = prevPose.curv + (nextPose.curv - prevPose.curv) * progress;\n const desiredWheelAngle = Math.atan(curvature * Car_Car.WHEEL_BASE);\n const wheelAngleError = desiredWheelAngle - wheelAngle;\n steer = Math.clamp(wheelAngleError / dt / Car_Car.MAX_STEER_SPEED, -1, 1);\n\n if (lockPath) {\n const damping = 0.1;\n const newRotation = Math.wrapAngle(prevPose.rot + Math.wrapAngle(nextPose.rot - prevPose.rot) * progress);\n const newPosition = new THREE.Vector2(projection.x - Car_Car.REAR_AXLE_POS * Math.cos(newRotation), projection.y - Car_Car.REAR_AXLE_POS * Math.sin(newRotation));\n\n if (Math.abs(Math.wrapAngle(newRotation - this.car.rotation)) > 0.5) {\n console.log(\'wut\');\n }\n\n this.car.rotation += damping * Math.wrapAngle(newRotation - this.car.rotation);\n this.car.position = this.car.position.clone().multiplyScalar(1 - damping).add(newPosition.multiplyScalar(damping));\n }\n }\n\n return { gas, brake, steer };\n }\n\n findNextIndex(pos) {\n const pathPoses = this.path.poses;\n\n // Constrain the search to just a few points surrounding the current nextIndex\n // for performance and to avoid problems with a path that crosses itself\n const start = Math.max(0, this.nextIndex - 20);\n const end = Math.min(pathPoses.length - 1, this.nextIndex + 20);\n let closestDistSqr = pos.distanceToSquared(pathPoses[start].pos);\n let closestIndex = start;\n\n for (let i = start + 1; i < end; i++) {\n const distSqr = pos.distanceToSquared(pathPoses[i].pos);\n if (distSqr < closestDistSqr) {\n closestDistSqr = distSqr;\n closestIndex = i;\n }\n }\n\n if (closestIndex == pathPoses.length - 1) {\n const [projection, progress] = FollowController_projectPointOnSegment(pos, pathPoses[closestIndex - 1].pos, pathPoses[closestIndex].pos);\n return [closestIndex, progress, projection];\n } else if (closestIndex == 0) {\n const [projection, progress] = FollowController_projectPointOnSegment(pos, pathPoses[closestIndex].pos, pathPoses[closestIndex + 1].pos);\n return [closestIndex + 1, progress, projection];\n } else {\n // The nextPoint is either (closestPoint) or (closestPoint + 1). Project the pos to both\n // of those two line segments (the segment preceding closestPoint and the segment succeeding closestPoint)\n // to determine which segment it\'s closest to.\n const [precedingProjection, precedingProgress] = FollowController_projectPointOnSegment(pos, pathPoses[closestIndex - 1].pos, pathPoses[closestIndex].pos);\n const [succeedingProjection, succeedingProgress] = FollowController_projectPointOnSegment(pos, pathPoses[closestIndex].pos, pathPoses[closestIndex + 1].pos);\n\n if (pos.distanceToSquared(precedingProjection) < pos.distanceToSquared(succeedingProjection)) {\n return [closestIndex, precedingProgress, precedingProjection];\n } else {\n return [closestIndex + 1, succeedingProgress, succeedingProjection];\n }\n }\n }\n}\n\n// Returns [pointOnSegment, progressAlongSegment {0 - 1}]\nfunction FollowController_projectPointOnSegment(point, start, end) {\n const distSqr = start.distanceToSquared(end);\n const progress = point.clone().sub(start).dot(end.clone().sub(start)) / distSqr;\n\n const clampedProgress = Math.max(0, Math.min(1, progress));\n return [end.clone().sub(start).multiplyScalar(clampedProgress).add(start), clampedProgress];\n}\n\n;// CONCATENATED MODULE: ./js/autonomy/control/ManualController.js\nclass ManualController {\n constructor() {\n this.carKeys = { forward: false, backward: false, left: false, right: false, brake: false };\n\n document.addEventListener(\'keydown\', event => {\n switch (event.key) {\n case \'w\': case \'W\': this.carKeys.forward = true; break;\n case \'s\': case \'S\': this.carKeys.backward = true; break;\n case \'a\': case \'A\': this.carKeys.left = true; break;\n case \'d\': case \'D\': this.carKeys.right = true; break;\n case \' \': this.carKeys.brake = true; break;\n }\n });\n\n document.addEventListener(\'keyup\', event => {\n switch (event.key) {\n case \'w\': case \'W\': this.carKeys.forward = false; break;\n case \'s\': case \'S\': this.carKeys.backward = false; break;\n case \'a\': case \'A\': this.carKeys.left = false; break;\n case \'d\': case \'D\': this.carKeys.right = false; break;\n case \' \': this.carKeys.brake = false; break;\n }\n });\n }\n\n control() {\n let gas = 0;\n let brake = 0;\n let steer = 0;\n\n if (this.carKeys.forward) gas += 1;\n if (this.carKeys.backward) gas -= 1;\n if (this.carKeys.left) steer -= 1;\n if (this.carKeys.right) steer += 1;\n if (this.carKeys.brake) brake += 1;\n\n return { gas, brake, steer };\n }\n}\n\n;// CONCATENATED MODULE: ./js/objects/MapObject.js\n// geolocation = [33.523900, -111.908756];\nclass MapObject extends THREE.Object3D {\n constructor(geolocation = null) {\n super();\n\n this.geolocation = geolocation;\n this.tilesGroup = null;\n\n const tileSize = geolocation ? this.tileSizeInMeters() : 10;\n const grid = new THREE.GridHelper(MapObject.HALF_NUM_TILES * 8 * tileSize, MapObject.HALF_NUM_TILES * 8, 0x333333, 0x333333);\n grid.renderOrder = -1;\n grid.material.depthTest = false;\n grid.position.add(new THREE.Vector3(-tileSize / 2, 0, -tileSize / 2));\n this.add(grid);\n\n if (geolocation)\n this.drawTiles();\n }\n\n // Converts lat-long geolocation to Google Maps world coodinates\n static geoToWorld(latlng) {\n const latitudeRadians = latlng[0] * Math.PI / 180;\n const x = (latlng[1] + 180) / 360 * 256;\n const y = ((1 - Math.log(Math.tan(latitudeRadians) + 1 / Math.cos(latitudeRadians)) / Math.PI) / 2) * 256;\n return [x, y];\n }\n\n // Calculates the x and y tile indices for the provided world coordinates\n static worldToTile(worldCoordinates) {\n return [Math.floor(worldCoordinates[0] * MapObject.SCALE / 256), Math.floor(worldCoordinates[1] * MapObject.SCALE / 256)];\n }\n\n drawTiles() {\n if (this.tileGroup != null) this.remove(this.tilesGroup);\n this.tileGroup = new THREE.Group();\n\n const originTile = MapObject.worldToTile(MapObject.geoToWorld(this.geolocation));\n const tileSize = this.tileSizeInMeters();\n\n for (let x = -MapObject.HALF_NUM_TILES, h = 0; x < MapObject.HALF_NUM_TILES; x++) {\n for (let y = -MapObject.HALF_NUM_TILES; y < MapObject.HALF_NUM_TILES; y++, h++) {\n const tileTexture = new THREE.TextureLoader().load(`https://khms${h % 4}.google.com/kh/v=748?x=${originTile[0] + x}&y=${originTile[1] + y}&z=${MapObject.ZOOM}`);\n tileTexture.anisotropy = 16;\n const tileGeometry = new THREE.PlaneBufferGeometry(tileSize, tileSize);\n const tileMaterial = new THREE.MeshBasicMaterial({ map: tileTexture, color: 0xffffff });\n const tile = new THREE.Mesh(tileGeometry, tileMaterial);\n tile.rotation.x = -Math.PI / 2;\n tile.position.x = x * tileSize;\n tile.position.z = y * tileSize;\n\n this.tileGroup.add(tile);\n }\n }\n\n this.add(this.tileGroup);\n }\n\n tileSizeInMeters() {\n // Because of the Mercator projection used to create the tile images, the size of a tile (in meters) depends on the latitude\n return 2 * Math.PI * MapObject.EARTH_RADIUS * Math.cos(this.geolocation[0] * Math.PI / 180) / Math.pow(2, MapObject.ZOOM);\n }\n}\n\nMapObject.EARTH_RADIUS = 6378137; // meters\nMapObject.TILE_PIXELS = 256; // pixels per tile\nMapObject.ZOOM = 20;\nMapObject.SCALE = 1 << MapObject.ZOOM;\nMapObject.HALF_NUM_TILES = 20;\n\n;// CONCATENATED MODULE: ./js/objects/TDSLoader.js\n/*\n * Autodesk 3DS threee.js file loader, based on lib3ds.\n *\n * Loads geometry with uv and materials basic properties with texture support.\n *\n * @author @tentone\n * @author @timknip\n * @class TDSLoader\n * @constructor\n */\n\n\n\nTHREE.TDSLoader = function ( manager ) {\n\n\tthis.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;\n\tthis.debug = false;\n\n\tthis.group = null;\n\tthis.position = 0;\n\n\tthis.materials = [];\n\tthis.meshes = [];\n\n};\n\nTHREE.TDSLoader.prototype = {\n\n\tconstructor: THREE.TDSLoader,\n\n\t/**\n\t * Load 3ds file from url.\n\t *\n\t * @method load\n\t * @param {[type]} url URL for the file.\n\t * @param {Function} onLoad onLoad callback, receives group Object3D as argument.\n\t * @param {Function} onProgress onProgress callback.\n\t * @param {Function} onError onError callback.\n\t */\n\tload: function ( url, onLoad, onProgress, onError ) {\n\n\t\tvar scope = this;\n\n\t\tvar path = this.path !== undefined ? this.path : THREE.LoaderUtils.extractUrlBase( url );\n\n\t\tvar loader = new THREE.FileLoader( this.manager );\n\n\t\tloader.setResponseType( \'arraybuffer\' );\n\n\t\tloader.load( url, function ( data ) {\n\n\t\t\tonLoad( scope.parse( data, path ) );\n\n\t\t}, onProgress, onError );\n\n\t},\n\n\t/**\n\t * Parse arraybuffer data and load 3ds file.\n\t *\n\t * @method parse\n\t * @param {ArrayBuffer} arraybuffer Arraybuffer data to be loaded.\n\t * @param {String} path Path for external resources.\n\t * @return {Object3D} Group loaded from 3ds file.\n\t */\n\tparse: function ( arraybuffer, path ) {\n\n\t\tthis.group = new THREE.Group();\n\t\tthis.position = 0;\n\t\tthis.materials = [];\n\t\tthis.meshes = [];\n\n\t\tthis.readFile( arraybuffer, path );\n\n\t\tfor ( var i = 0; i < this.meshes.length; i ++ ) {\n\n\t\t\tthis.group.add( this.meshes[ i ] );\n\n\t\t}\n\n\t\treturn this.group;\n\n\t},\n\n\t/**\n\t * Decode file content to read 3ds data.\n\t *\n\t * @method readFile\n\t * @param {ArrayBuffer} arraybuffer Arraybuffer data to be loaded.\n\t */\n\treadFile: function ( arraybuffer, path ) {\n\n\t\tvar data = new DataView( arraybuffer );\n\t\tvar chunk = this.readChunk( data );\n\n\t\tif ( chunk.id === MLIBMAGIC || chunk.id === CMAGIC || chunk.id === M3DMAGIC ) {\n\n\t\t\tvar next = this.nextChunk( data, chunk );\n\n\t\t\twhile ( next !== 0 ) {\n\n\t\t\t\tif ( next === M3D_VERSION ) {\n\n\t\t\t\t\tvar version = this.readDWord( data );\n\t\t\t\t\tthis.debugMessage( \'3DS file version: \' + version );\n\n\t\t\t\t} else if ( next === MDATA ) {\n\n\t\t\t\t\tthis.resetPosition( data );\n\t\t\t\t\tthis.readMeshData( data, path );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tthis.debugMessage( \'Unknown main chunk: \' + next.toString( 16 ) );\n\n\t\t\t\t}\n\n\t\t\t\tnext = this.nextChunk( data, chunk );\n\n\t\t\t}\n\n\t\t}\n\n\t\tthis.debugMessage( \'Parsed \' + this.meshes.length + \' meshes\' );\n\n\t},\n\n\t/**\n\t * Read mesh data chunk.\n\t *\n\t * @method readMeshData\n\t * @param {Dataview} data Dataview in use.\n\t */\n\treadMeshData: function ( data, path ) {\n\n\t\tvar chunk = this.readChunk( data );\n\t\tvar next = this.nextChunk( data, chunk );\n\n\t\twhile ( next !== 0 ) {\n\n\t\t\tif ( next === MESH_VERSION ) {\n\n\t\t\t\tvar version = + this.readDWord( data );\n\t\t\t\tthis.debugMessage( \'Mesh Version: \' + version );\n\n\t\t\t} else if ( next === MASTER_SCALE ) {\n\n\t\t\t\tvar scale = this.readFloat( data );\n\t\t\t\tthis.debugMessage( \'Master scale: \' + scale );\n\t\t\t\tthis.group.scale.set( scale, scale, scale );\n\n\t\t\t} else if ( next === NAMED_OBJECT ) {\n\n\t\t\t\tthis.debugMessage( \'Named Object\' );\n\t\t\t\tthis.resetPosition( data );\n\t\t\t\tthis.readNamedObject( data );\n\n\t\t\t} else if ( next === MAT_ENTRY ) {\n\n\t\t\t\tthis.debugMessage( \'Material\' );\n\t\t\t\tthis.resetPosition( data );\n\t\t\t\tthis.readMaterialEntry( data, path );\n\n\t\t\t} else {\n\n\t\t\t\tthis.debugMessage( \'Unknown MDATA chunk: \' + next.toString( 16 ) );\n\n\t\t\t}\n\n\t\t\tnext = this.nextChunk( data, chunk );\n\n\t\t}\n\n\t},\n\n\t/**\n\t * Read named object chunk.\n\t *\n\t * @method readNamedObject\n\t * @param {Dataview} data Dataview in use.\n\t */\n\treadNamedObject: function ( data ) {\n\n\t\tvar chunk = this.readChunk( data );\n\t\tvar name = this.readString( data, 64 );\n\t\tchunk.cur = this.position;\n\n\t\tvar next = this.nextChunk( data, chunk );\n\t\twhile ( next !== 0 ) {\n\n\t\t\tif ( next === N_TRI_OBJECT ) {\n\n\t\t\t\tthis.resetPosition( data );\n\t\t\t\tvar mesh = this.readMesh( data );\n\t\t\t\tmesh.name = name;\n\t\t\t\tthis.meshes.push( mesh );\n\n\t\t\t} else {\n\n\t\t\t\tthis.debugMessage( \'Unknown named object chunk: \' + next.toString( 16 ) );\n\n\t\t\t}\n\n\t\t\tnext = this.nextChunk( data, chunk );\n\n\t\t}\n\n\t\tthis.endChunk( chunk );\n\n\t},\n\n\t/**\n\t * Read material data chunk and add it to the material list.\n\t *\n\t * @method readMaterialEntry\n\t * @param {Dataview} data Dataview in use.\n\t */\n\treadMaterialEntry: function ( data, path ) {\n\n\t\tvar chunk = this.readChunk( data );\n\t\tvar next = this.nextChunk( data, chunk );\n\t\tvar material = new THREE.MeshPhongMaterial();\n\n\t\twhile ( next !== 0 ) {\n\n\t\t\tif ( next === MAT_NAME ) {\n\n\t\t\t\tmaterial.name = this.readString( data, 64 );\n\t\t\t\tthis.debugMessage( \' Name: \' + material.name );\n\n\t\t\t} else if ( next === MAT_WIRE ) {\n\n\t\t\t\tthis.debugMessage( \' Wireframe\' );\n\t\t\t\tmaterial.wireframe = true;\n\n\t\t\t} else if ( next === MAT_WIRE_SIZE ) {\n\n\t\t\t\tvar value = this.readByte( data );\n\t\t\t\tmaterial.wireframeLinewidth = value;\n\t\t\t\tthis.debugMessage( \' Wireframe Thickness: \' + value );\n\n\t\t\t} else if ( next === MAT_TWO_SIDE ) {\n\n\t\t\t\tmaterial.side = THREE.DoubleSide;\n\t\t\t\tthis.debugMessage( \' DoubleSided\' );\n\n\t\t\t} else if ( next === MAT_ADDITIVE ) {\n\n\t\t\t\tthis.debugMessage( \' Additive Blending\' );\n\t\t\t\tmaterial.blending = THREE.AdditiveBlending;\n\n\t\t\t} else if ( next === MAT_DIFFUSE ) {\n\n\t\t\t\tthis.debugMessage( \' Diffuse Color\' );\n\t\t\t\tmaterial.color = this.readColor( data );\n\n\t\t\t} else if ( next === MAT_SPECULAR ) {\n\n\t\t\t\tthis.debugMessage( \' Specular Color\' );\n\t\t\t\tmaterial.specular = this.readColor( data );\n\n\t\t\t} else if ( next === MAT_AMBIENT ) {\n\n\t\t\t\tthis.debugMessage( \' Ambient color\' );\n\t\t\t\tmaterial.color = this.readColor( data );\n\n\t\t\t} else if ( next === MAT_SHININESS ) {\n\n\t\t\t\tvar shininess = this.readWord( data );\n\t\t\t\tmaterial.shininess = shininess;\n\t\t\t\tthis.debugMessage( \' Shininess : \' + shininess );\n\n\t\t\t} else if ( next === MAT_TEXMAP ) {\n\n\t\t\t\tthis.debugMessage( \' ColorMap\' );\n\t\t\t\tthis.resetPosition( data );\n\t\t\t\tmaterial.map = this.readMap( data, path );\n\n\t\t\t} else if ( next === MAT_BUMPMAP ) {\n\n\t\t\t\tthis.debugMessage( \' BumpMap\' );\n\t\t\t\tthis.resetPosition( data );\n\t\t\t\tmaterial.bumpMap = this.readMap( data, path );\n\n\t\t\t} else if ( next === MAT_OPACMAP ) {\n\n\t\t\t\tthis.debugMessage( \' OpacityMap\' );\n\t\t\t\tthis.resetPosition( data );\n\t\t\t\tmaterial.alphaMap = this.readMap( data, path );\n\n\t\t\t} else if ( next === MAT_SPECMAP ) {\n\n\t\t\t\tthis.debugMessage( \' SpecularMap\' );\n\t\t\t\tthis.resetPosition( data );\n\t\t\t\tmaterial.specularMap = this.readMap( data, path );\n\n\t\t\t} else {\n\n\t\t\t\tthis.debugMessage( \' Unknown material chunk: \' + next.toString( 16 ) );\n\n\t\t\t}\n\n\t\t\tnext = this.nextChunk( data, chunk );\n\n\t\t}\n\n\t\tthis.endChunk( chunk );\n\n\t\tthis.materials[ material.name ] = material;\n\n\t},\n\n\t/**\n\t * Read mesh data chunk.\n\t *\n\t * @method readMesh\n\t * @param {Dataview} data Dataview in use.\n\t */\n\treadMesh: function ( data ) {\n\n\t\tvar chunk = this.readChunk( data );\n\t\tvar next = this.nextChunk( data, chunk );\n\n\t\tvar useBufferGeometry = false;\n\t\tvar geometry = null;\n\t\tvar uvs = [];\n\n\t\tif ( useBufferGeometry ) {\n\n\t\t\tgeometry = new THREE.BufferGeometry();\n\n\t\t}\telse {\n\n\t\t\tgeometry = new THREE.Geometry();\n\n\t\t}\n\n\t\tvar material = new THREE.MeshPhongMaterial();\n\t\tvar mesh = new THREE.Mesh( geometry, material );\n\t\tmesh.name = \'mesh\';\n\n\t\twhile ( next !== 0 ) {\n\n\t\t\tif ( next === POINT_ARRAY ) {\n\n\t\t\t\tvar points = this.readWord( data );\n\n\t\t\t\tthis.debugMessage( \' Vertex: \' + points );\n\n\t\t\t\t//BufferGeometry\n\n\t\t\t\tif ( useBufferGeometry )\t{\n\n\t\t\t\t\tvar vertices = [];\n\t\t\t\t\tfor ( var i = 0; i < points; i ++ )\t\t{\n\n\t\t\t\t\t\tvertices.push( this.readFloat( data ) );\n\t\t\t\t\t\tvertices.push( this.readFloat( data ) );\n\t\t\t\t\t\tvertices.push( this.readFloat( data ) );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tgeometry.addAttribute( \'position\', new THREE.BufferAttribute( new Float32Array( vertices ), 3 ) );\n\n\t\t\t\t} else\t{ //Geometry\n\n\t\t\t\t\tfor ( var i = 0; i < points; i ++ )\t\t{\n\n\t\t\t\t\t\tgeometry.vertices.push( new THREE.Vector3( this.readFloat( data ), this.readFloat( data ), this.readFloat( data ) ) );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} else if ( next === FACE_ARRAY ) {\n\n\t\t\t\tthis.resetPosition( data );\n\t\t\t\tthis.readFaceArray( data, mesh );\n\n\t\t\t} else if ( next === TEX_VERTS ) {\n\n\t\t\t\tvar texels = this.readWord( data );\n\n\t\t\t\tthis.debugMessage( \' UV: \' + texels );\n\n\t\t\t\t//BufferGeometry\n\n\t\t\t\tif ( useBufferGeometry )\t{\n\n\t\t\t\t\tvar uvs = [];\n\t\t\t\t\tfor ( var i = 0; i < texels; i ++ )\t\t{\n\n\t\t\t\t\t\tuvs.push( this.readFloat( data ) );\n\t\t\t\t\t\tuvs.push( this.readFloat( data ) );\n\n\t\t\t\t\t}\n\t\t\t\t\tgeometry.addAttribute( \'uv\', new THREE.BufferAttribute( new Float32Array( uvs ), 2 ) );\n\n\t\t\t\t} else { //Geometry\n\n\t\t\t\t\tuvs = [];\n\t\t\t\t\tfor ( var i = 0; i < texels; i ++ )\t\t{\n\n\t\t\t\t\t\tuvs.push( new THREE.Vector2( this.readFloat( data ), this.readFloat( data ) ) );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} else if ( next === MESH_MATRIX ) {\n\n\t\t\t\tthis.debugMessage( \' Tranformation Matrix (TODO)\' );\n\n\t\t\t\tvar values = [];\n\t\t\t\tfor ( var i = 0; i < 12; i ++ ) {\n\n\t\t\t\t\tvalues[ i ] = this.readFloat( data );\n\n\t\t\t\t}\n\n\t\t\t\tvar matrix = new THREE.Matrix4();\n\n\t\t\t\t//X Line\n\t\t\t\tmatrix.elements[ 0 ] = values[ 0 ];\n\t\t\t\tmatrix.elements[ 1 ] = values[ 6 ];\n\t\t\t\tmatrix.elements[ 2 ] = values[ 3 ];\n\t\t\t\tmatrix.elements[ 3 ] = values[ 9 ];\n\n\t\t\t\t//Y Line\n\t\t\t\tmatrix.elements[ 4 ] = values[ 2 ];\n\t\t\t\tmatrix.elements[ 5 ] = values[ 8 ];\n\t\t\t\tmatrix.elements[ 6 ] = values[ 5 ];\n\t\t\t\tmatrix.elements[ 7 ] = values[ 11 ];\n\n\t\t\t\t//Z Line\n\t\t\t\tmatrix.elements[ 8 ] = values[ 1 ];\n\t\t\t\tmatrix.elements[ 9 ] = values[ 7 ];\n\t\t\t\tmatrix.elements[ 10 ] = values[ 4 ];\n\t\t\t\tmatrix.elements[ 11 ] = values[ 10 ];\n\n\t\t\t\t//W Line\n\t\t\t\tmatrix.elements[ 12 ] = 0;\n\t\t\t\tmatrix.elements[ 13 ] = 0;\n\t\t\t\tmatrix.elements[ 14 ] = 0;\n\t\t\t\tmatrix.elements[ 15 ] = 1;\n\n\t\t\t\tmatrix.transpose();\n\n\t\t\t\tvar inverse = new THREE.Matrix4();\n\t\t\t\tinverse.getInverse( matrix, true );\n\t\t\t\tgeometry.applyMatrix( inverse );\n\n\t\t\t\tmatrix.decompose( mesh.position, mesh.quaternion, mesh.scale );\n\n\t\t\t} else {\n\n\t\t\t\tthis.debugMessage( \' Unknown mesh chunk: \' + next.toString( 16 ) );\n\n\t\t\t}\n\n\t\t\tnext = this.nextChunk( data, chunk );\n\n\t\t}\n\n\t\tthis.endChunk( chunk );\n\n\t\tif ( ! useBufferGeometry ) {\n\n\t\t\t//geometry.faceVertexUvs[0][faceIndex][vertexIndex]\n\n\t\t\tif ( uvs.length > 0 ) {\n\n\t\t\t\tvar faceUV = [];\n\n\t\t\t\tfor ( var i = 0; i < geometry.faces.length; i ++ ) {\n\n\t\t\t\t\tfaceUV.push( [ uvs[ geometry.faces[ i ].a ], uvs[ geometry.faces[ i ].b ], uvs[ geometry.faces[ i ].c ] ] );\n\n\t\t\t\t}\n\n\t\t\t\tgeometry.faceVertexUvs[ 0 ] = faceUV;\n\n\t\t\t}\n\n\t\t\tgeometry.computeVertexNormals();\n\n\t\t}\n\n\t\treturn mesh;\n\n\t},\n\n\t/**\n\t * Read face array data chunk.\n\t *\n\t * @method readFaceArray\n\t * @param {Dataview} data Dataview in use.\n\t * @param {Mesh} mesh Mesh to be filled with the data read.\n\t */\n\treadFaceArray: function ( data, mesh ) {\n\n\t\tvar chunk = this.readChunk( data );\n\t\tvar faces = this.readWord( data );\n\n\t\tthis.debugMessage( \' Faces: \' + faces );\n\n\t\tfor ( var i = 0; i < faces; ++ i ) {\n\n\t\t\tmesh.geometry.faces.push( new THREE.Face3( this.readWord( data ), this.readWord( data ), this.readWord( data ) ) );\n\n\t\t\tvar visibility = this.readWord( data );\n\n\t\t}\n\n\t\t//The rest of the FACE_ARRAY chunk is subchunks\n\n\t\twhile ( this.position < chunk.end ) {\n\n\t\t\tvar chunk = this.readChunk( data );\n\n\t\t\tif ( chunk.id === MSH_MAT_GROUP ) {\n\n\t\t\t\tthis.debugMessage( \' Material Group\' );\n\n\t\t\t\tthis.resetPosition( data );\n\n\t\t\t\tvar group = this.readMaterialGroup( data );\n\n\t\t\t\tvar material = this.materials[ group.name ];\n\n\t\t\t\tif ( material !== undefined )\t{\n\n\t\t\t\t\tmesh.material = material;\n\n\t\t\t\t\tif ( material.name === \'\' )\t\t{\n\n\t\t\t\t\t\tmaterial.name = mesh.name;\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\tthis.debugMessage( \' Unknown face array chunk: \' + chunk.toString( 16 ) );\n\n\t\t\t}\n\n\t\t\tthis.endChunk( chunk );\n\n\t\t}\n\n\t\tthis.endChunk( chunk );\n\n\t},\n\n\t/**\n\t * Read texture map data chunk.\n\t *\n\t * @method readMap\n\t * @param {Dataview} data Dataview in use.\n\t * @return {Texture} Texture read from this data chunk.\n\t */\n\treadMap: function ( data, path ) {\n if (this.skipMaps) return null;\n\n\t\tvar chunk = this.readChunk( data );\n\t\tvar next = this.nextChunk( data, chunk );\n\t\tvar texture = {};\n\n\t\tvar loader = new THREE.TextureLoader( this.manager );\n\t\tloader.setPath( path );\n\n\t\twhile ( next !== 0 ) {\n\n\t\t\tif ( next === MAT_MAPNAME ) {\n\n\t\t\t\tvar name = this.readString( data, 128 );\n\t\t\t\ttexture = loader.load( name );\n\n\t\t\t\tthis.debugMessage( \' File: \' + path + name );\n\n\t\t\t} else if ( next === MAT_MAP_UOFFSET ) {\n\n\t\t\t\ttexture.offset.x = this.readFloat( data );\n\t\t\t\tthis.debugMessage( \' OffsetX: \' + texture.offset.x );\n\n\t\t\t} else if ( next === MAT_MAP_VOFFSET ) {\n\n\t\t\t\ttexture.offset.y = this.readFloat( data );\n\t\t\t\tthis.debugMessage( \' OffsetY: \' + texture.offset.y );\n\n\t\t\t} else if ( next === MAT_MAP_USCALE ) {\n\n\t\t\t\ttexture.repeat.x = this.readFloat( data );\n\t\t\t\tthis.debugMessage( \' RepeatX: \' + texture.repeat.x );\n\n\t\t\t} else if ( next === MAT_MAP_VSCALE ) {\n\n\t\t\t\ttexture.repeat.y = this.readFloat( data );\n\t\t\t\tthis.debugMessage( \' RepeatY: \' + texture.repeat.y );\n\n\t\t\t} else {\n\n\t\t\t\tthis.debugMessage( \' Unknown map chunk: \' + next.toString( 16 ) );\n\n\t\t\t}\n\n\t\t\tnext = this.nextChunk( data, chunk );\n\n\t\t}\n\n\t\tthis.endChunk( chunk );\n\n\t\treturn texture;\n\n\t},\n\n\t/**\n\t * Read material group data chunk.\n\t *\n\t * @method readMaterialGroup\n\t * @param {Dataview} data Dataview in use.\n\t * @return {Object} Object with name and index of the object.\n\t */\n\treadMaterialGroup: function ( data ) {\n\n\t\tvar chunk = this.readChunk( data );\n\t\tvar name = this.readString( data, 64 );\n\t\tvar numFaces = this.readWord( data );\n\n\t\tthis.debugMessage( \' Name: \' + name );\n\t\tthis.debugMessage( \' Faces: \' + numFaces );\n\n\t\tvar index = [];\n\t\tfor ( var i = 0; i < numFaces; ++ i ) {\n\n\t\t\tindex.push( this.readWord( data ) );\n\n\t\t}\n\n\t\treturn { name: name, index: index };\n\n\t},\n\n\t/**\n\t * Read a color value.\n\t *\n\t * @method readColor\n\t * @param {DataView} data Dataview.\n\t * @return {Color} Color value read..\n\t */\n\treadColor: function ( data ) {\n\n\t\tvar chunk = this.readChunk( data );\n\t\tvar color = new THREE.Color();\n\n\t\tif ( chunk.id === COLOR_24 || chunk.id === LIN_COLOR_24 ) {\n\n\t\t\tvar r = this.readByte( data );\n\t\t\tvar g = this.readByte( data );\n\t\t\tvar b = this.readByte( data );\n\n\t\t\tcolor.setRGB( r / 255, g / 255, b / 255 );\n\n\t\t\tthis.debugMessage( \' Color: \' + color.r + \', \' + color.g + \', \' + color.b );\n\n\t\t}\telse if ( chunk.id === COLOR_F || chunk.id === LIN_COLOR_F ) {\n\n\t\t\tvar r = this.readFloat( data );\n\t\t\tvar g = this.readFloat( data );\n\t\t\tvar b = this.readFloat( data );\n\n\t\t\tcolor.setRGB( r, g, b );\n\n\t\t\tthis.debugMessage( \' Color: \' + color.r + \', \' + color.g + \', \' + color.b );\n\n\t\t}\telse {\n\n\t\t\tthis.debugMessage( \' Unknown color chunk: \' + chunk.toString( 16 ) );\n\n\t\t}\n\n\t\tthis.endChunk( chunk );\n\t\treturn color;\n\n\t},\n\n\t/**\n\t * Read next chunk of data.\n\t *\n\t * @method readChunk\n\t * @param {DataView} data Dataview.\n\t * @return {Object} Chunk of data read.\n\t */\n\treadChunk: function ( data ) {\n\n\t\tvar chunk = {};\n\n\t\tchunk.cur = this.position;\n\t\tchunk.id = this.readWord( data );\n\t\tchunk.size = this.readDWord( data );\n\t\tchunk.end = chunk.cur + chunk.size;\n\t\tchunk.cur += 6;\n\n\t\treturn chunk;\n\n\t},\n\n\t/**\n\t * Set position to the end of the current chunk of data.\n\t *\n\t * @method endChunk\n\t * @param {Object} chunk Data chunk.\n\t */\n\tendChunk: function ( chunk ) {\n\n\t\tthis.position = chunk.end;\n\n\t},\n\n\t/**\n\t * Move to the next data chunk.\n\t *\n\t * @method nextChunk\n\t * @param {DataView} data Dataview.\n\t * @param {Object} chunk Data chunk.\n\t */\n\tnextChunk: function ( data, chunk ) {\n\n\t\tif ( chunk.cur >= chunk.end ) {\n\n\t\t\treturn 0;\n\n\t\t}\n\n\t\tthis.position = chunk.cur;\n\n\t\ttry {\n\n\t\t\tvar next = this.readChunk( data );\n\t\t\tchunk.cur += next.size;\n\t\t\treturn next.id;\n\n\t\t}\tcatch ( e ) {\n\n\t\t\tthis.debugMessage( \'Unable to read chunk at \' + this.position );\n\t\t\treturn 0;\n\n\t\t}\n\n\t},\n\n\t/**\n\t * Reset dataview position.\n\t *\n\t * @method resetPosition\n\t * @param {DataView} data Dataview.\n\t */\n\tresetPosition: function () {\n\n\t\tthis.position -= 6;\n\n\t},\n\n\t/**\n\t * Read byte value.\n\t *\n\t * @method readByte\n\t * @param {DataView} data Dataview to read data from.\n\t * @return {Number} Data read from the dataview.\n\t */\n\treadByte: function ( data ) {\n\n\t\tvar v = data.getUint8( this.position, true );\n\t\tthis.position += 1;\n\t\treturn v;\n\n\t},\n\n\t/**\n\t * Read 32 bit float value.\n\t *\n\t * @method readFloat\n\t * @param {DataView} data Dataview to read data from.\n\t * @return {Number} Data read from the dataview.\n\t */\n\treadFloat: function ( data ) {\n\n\t\ttry {\n\n\t\t\tvar v = data.getFloat32( this.position, true );\n\t\t\tthis.position += 4;\n\t\t\treturn v;\n\n\t\t}\tcatch ( e ) {\n\n\t\t\tthis.debugMessage( e + \' \' + this.position + \' \' + data.byteLength );\n\n\t\t}\n\n\t},\n\n\t/**\n\t * Read 32 bit signed integer value.\n\t *\n\t * @method readInt\n\t * @param {DataView} data Dataview to read data from.\n\t * @return {Number} Data read from the dataview.\n\t */\n\treadInt: function ( data ) {\n\n\t\tvar v = data.getInt32( this.position, true );\n\t\tthis.position += 4;\n\t\treturn v;\n\n\t},\n\n\t/**\n\t * Read 16 bit signed integer value.\n\t *\n\t * @method readShort\n\t * @param {DataView} data Dataview to read data from.\n\t * @return {Number} Data read from the dataview.\n\t */\n\treadShort: function ( data ) {\n\n\t\tvar v = data.getInt16( this.position, true );\n\t\tthis.position += 2;\n\t\treturn v;\n\n\t},\n\n\t/**\n\t * Read 64 bit unsigned integer value.\n\t *\n\t * @method readDWord\n\t * @param {DataView} data Dataview to read data from.\n\t * @return {Number} Data read from the dataview.\n\t */\n\treadDWord: function ( data ) {\n\n\t\tvar v = data.getUint32( this.position, true );\n\t\tthis.position += 4;\n\t\treturn v;\n\n\t},\n\n\t/**\n\t * Read 32 bit unsigned integer value.\n\t *\n\t * @method readWord\n\t * @param {DataView} data Dataview to read data from.\n\t * @return {Number} Data read from the dataview.\n\t */\n\treadWord: function ( data ) {\n\n\t\tvar v = data.getUint16( this.position, true );\n\t\tthis.position += 2;\n\t\treturn v;\n\n\t},\n\n\t/**\n\t * Read string value.\n\t *\n\t * @method readString\n\t * @param {DataView} data Dataview to read data from.\n\t * @param {Number} maxLength Max size of the string to be read.\n\t * @return {String} Data read from the dataview.\n\t */\n\treadString: function ( data, maxLength ) {\n\n\t\tvar s = \'\';\n\n\t\tfor ( var i = 0; i < maxLength; i ++ ) {\n\n\t\t\tvar c = this.readByte( data );\n\t\t\tif ( ! c ) {\n\n\t\t\t\tbreak;\n\n\t\t\t}\n\n\t\t\ts += String.fromCharCode( c );\n\n\t\t}\n\n\t\treturn s;\n\n\t},\n\n\t/**\n\t * Set resource path used to determine the file path to attached resources.\n\t *\n\t * @method setPath\n\t * @param {String} path Path to resources.\n\t * @return Self for chaining.\n\t */\n\tsetPath: function ( path ) {\n\n\t\tthis.path = path;\n\n\t\treturn this;\n\n\t},\n\n\t/**\n\t * Print debug message to the console.\n\t *\n\t * Is controlled by a flag to show or hide debug messages.\n\t *\n\t * @method debugMessage\n\t * @param {Object} message Debug message to print to the console.\n\t */\n\tdebugMessage: function ( message ) {\n\n\t\tif ( this.debug ) {\n\n\t\t\tconsole.log( message );\n\n\t\t}\n\n\t}\n};\n\nvar NULL_CHUNK = 0x0000;\nvar M3DMAGIC = 0x4D4D;\nvar SMAGIC = 0x2D2D;\nvar LMAGIC = 0x2D3D;\nvar MLIBMAGIC = 0x3DAA;\nvar MATMAGIC = 0x3DFF;\nvar CMAGIC = 0xC23D;\nvar M3D_VERSION = 0x0002;\nvar M3D_KFVERSION = 0x0005;\nvar COLOR_F = 0x0010;\nvar COLOR_24 = 0x0011;\nvar LIN_COLOR_24 = 0x0012;\nvar LIN_COLOR_F = 0x0013;\nvar INT_PERCENTAGE = 0x0030;\nvar FLOAT_PERCENTAGE = 0x0031;\nvar MDATA = 0x3D3D;\nvar MESH_VERSION = 0x3D3E;\nvar MASTER_SCALE = 0x0100;\nvar LO_SHADOW_BIAS = 0x1400;\nvar HI_SHADOW_BIAS = 0x1410;\nvar SHADOW_MAP_SIZE = 0x1420;\nvar SHADOW_SAMPLES = 0x1430;\nvar SHADOW_RANGE = 0x1440;\nvar SHADOW_FILTER = 0x1450;\nvar RAY_BIAS = 0x1460;\nvar O_CONSTS = 0x1500;\nvar AMBIENT_LIGHT = 0x2100;\nvar BIT_MAP = 0x1100;\nvar SOLID_BGND = 0x1200;\nvar V_GRADIENT = 0x1300;\nvar USE_BIT_MAP = 0x1101;\nvar USE_SOLID_BGND = 0x1201;\nvar USE_V_GRADIENT = 0x1301;\nvar FOG = 0x2200;\nvar FOG_BGND = 0x2210;\nvar LAYER_FOG = 0x2302;\nvar DISTANCE_CUE = 0x2300;\nvar DCUE_BGND = 0x2310;\nvar USE_FOG = 0x2201;\nvar USE_LAYER_FOG = 0x2303;\nvar USE_DISTANCE_CUE = 0x2301;\nvar MAT_ENTRY = 0xAFFF;\nvar MAT_NAME = 0xA000;\nvar MAT_AMBIENT = 0xA010;\nvar MAT_DIFFUSE = 0xA020;\nvar MAT_SPECULAR = 0xA030;\nvar MAT_SHININESS = 0xA040;\nvar MAT_SHIN2PCT = 0xA041;\nvar MAT_TRANSPARENCY = 0xA050;\nvar MAT_XPFALL = 0xA052;\nvar MAT_USE_XPFALL = 0xA240;\nvar MAT_REFBLUR = 0xA053;\nvar MAT_SHADING = 0xA100;\nvar MAT_USE_REFBLUR = 0xA250;\nvar MAT_SELF_ILLUM = 0xA084;\nvar MAT_TWO_SIDE = 0xA081;\nvar MAT_DECAL = 0xA082;\nvar MAT_ADDITIVE = 0xA083;\nvar MAT_WIRE = 0xA085;\nvar MAT_FACEMAP = 0xA088;\nvar MAT_TRANSFALLOFF_IN = 0xA08A;\nvar MAT_PHONGSOFT = 0xA08C;\nvar MAT_WIREABS = 0xA08E;\nvar MAT_WIRE_SIZE = 0xA087;\nvar MAT_TEXMAP = 0xA200;\nvar MAT_SXP_TEXT_DATA = 0xA320;\nvar MAT_TEXMASK = 0xA33E;\nvar MAT_SXP_TEXTMASK_DATA = 0xA32A;\nvar MAT_TEX2MAP = 0xA33A;\nvar MAT_SXP_TEXT2_DATA = 0xA321;\nvar MAT_TEX2MASK = 0xA340;\nvar MAT_SXP_TEXT2MASK_DATA = 0xA32C;\nvar MAT_OPACMAP = 0xA210;\nvar MAT_SXP_OPAC_DATA = 0xA322;\nvar MAT_OPACMASK = 0xA342;\nvar MAT_SXP_OPACMASK_DATA = 0xA32E;\nvar MAT_BUMPMAP = 0xA230;\nvar MAT_SXP_BUMP_DATA = 0xA324;\nvar MAT_BUMPMASK = 0xA344;\nvar MAT_SXP_BUMPMASK_DATA = 0xA330;\nvar MAT_SPECMAP = 0xA204;\nvar MAT_SXP_SPEC_DATA = 0xA325;\nvar MAT_SPECMASK = 0xA348;\nvar MAT_SXP_SPECMASK_DATA = 0xA332;\nvar MAT_SHINMAP = 0xA33C;\nvar MAT_SXP_SHIN_DATA = 0xA326;\nvar MAT_SHINMASK = 0xA346;\nvar MAT_SXP_SHINMASK_DATA = 0xA334;\nvar MAT_SELFIMAP = 0xA33D;\nvar MAT_SXP_SELFI_DATA = 0xA328;\nvar MAT_SELFIMASK = 0xA34A;\nvar MAT_SXP_SELFIMASK_DATA = 0xA336;\nvar MAT_REFLMAP = 0xA220;\nvar MAT_REFLMASK = 0xA34C;\nvar MAT_SXP_REFLMASK_DATA = 0xA338;\nvar MAT_ACUBIC = 0xA310;\nvar MAT_MAPNAME = 0xA300;\nvar MAT_MAP_TILING = 0xA351;\nvar MAT_MAP_TEXBLUR = 0xA353;\nvar MAT_MAP_USCALE = 0xA354;\nvar MAT_MAP_VSCALE = 0xA356;\nvar MAT_MAP_UOFFSET = 0xA358;\nvar MAT_MAP_VOFFSET = 0xA35A;\nvar MAT_MAP_ANG = 0xA35C;\nvar MAT_MAP_COL1 = 0xA360;\nvar MAT_MAP_COL2 = 0xA362;\nvar MAT_MAP_RCOL = 0xA364;\nvar MAT_MAP_GCOL = 0xA366;\nvar MAT_MAP_BCOL = 0xA368;\nvar NAMED_OBJECT = 0x4000;\nvar N_DIRECT_LIGHT = 0x4600;\nvar DL_OFF = 0x4620;\nvar DL_OUTER_RANGE = 0x465A;\nvar DL_INNER_RANGE = 0x4659;\nvar DL_MULTIPLIER = 0x465B;\nvar DL_EXCLUDE = 0x4654;\nvar DL_ATTENUATE = 0x4625;\nvar DL_SPOTLIGHT = 0x4610;\nvar DL_SPOT_ROLL = 0x4656;\nvar DL_SHADOWED = 0x4630;\nvar DL_LOCAL_SHADOW2 = 0x4641;\nvar DL_SEE_CONE = 0x4650;\nvar DL_SPOT_RECTANGULAR = 0x4651;\nvar DL_SPOT_ASPECT = 0x4657;\nvar DL_SPOT_PROJECTOR = 0x4653;\nvar DL_SPOT_OVERSHOOT = 0x4652;\nvar DL_RAY_BIAS = 0x4658;\nvar DL_RAYSHAD = 0x4627;\nvar N_CAMERA = 0x4700;\nvar CAM_SEE_CONE = 0x4710;\nvar CAM_RANGES = 0x4720;\nvar OBJ_HIDDEN = 0x4010;\nvar OBJ_VIS_LOFTER = 0x4011;\nvar OBJ_DOESNT_CAST = 0x4012;\nvar OBJ_DONT_RECVSHADOW = 0x4017;\nvar OBJ_MATTE = 0x4013;\nvar OBJ_FAST = 0x4014;\nvar OBJ_PROCEDURAL = 0x4015;\nvar OBJ_FROZEN = 0x4016;\nvar N_TRI_OBJECT = 0x4100;\nvar POINT_ARRAY = 0x4110;\nvar POINT_FLAG_ARRAY = 0x4111;\nvar FACE_ARRAY = 0x4120;\nvar MSH_MAT_GROUP = 0x4130;\nvar SMOOTH_GROUP = 0x4150;\nvar MSH_BOXMAP = 0x4190;\nvar TEX_VERTS = 0x4140;\nvar MESH_MATRIX = 0x4160;\nvar MESH_COLOR = 0x4165;\nvar MESH_TEXTURE_INFO = 0x4170;\nvar KFDATA = 0xB000;\nvar KFHDR = 0xB00A;\nvar KFSEG = 0xB008;\nvar KFCURTIME = 0xB009;\nvar AMBIENT_NODE_TAG = 0xB001;\nvar OBJECT_NODE_TAG = 0xB002;\nvar CAMERA_NODE_TAG = 0xB003;\nvar TARGET_NODE_TAG = 0xB004;\nvar LIGHT_NODE_TAG = 0xB005;\nvar L_TARGET_NODE_TAG = 0xB006;\nvar SPOTLIGHT_NODE_TAG = 0xB007;\nvar NODE_ID = 0xB030;\nvar NODE_HDR = 0xB010;\nvar PIVOT = 0xB013;\nvar INSTANCE_NAME = 0xB011;\nvar MORPH_SMOOTH = 0xB015;\nvar BOUNDBOX = 0xB014;\nvar POS_TRACK_TAG = 0xB020;\nvar COL_TRACK_TAG = 0xB025;\nvar ROT_TRACK_TAG = 0xB021;\nvar SCL_TRACK_TAG = 0xB022;\nvar MORPH_TRACK_TAG = 0xB026;\nvar FOV_TRACK_TAG = 0xB023;\nvar ROLL_TRACK_TAG = 0xB024;\nvar HOT_TRACK_TAG = 0xB027;\nvar FALL_TRACK_TAG = 0xB028;\nvar HIDE_TRACK_TAG = 0xB029;\nvar POLY_2D = 0x5000;\nvar SHAPE_OK = 0x5010;\nvar SHAPE_NOT_OK = 0x5011;\nvar SHAPE_HOOK = 0x5020;\nvar PATH_3D = 0x6000;\nvar PATH_MATRIX = 0x6005;\nvar SHAPE_2D = 0x6010;\nvar M_SCALE = 0x6020;\nvar M_TWIST = 0x6030;\nvar M_TEETER = 0x6040;\nvar M_FIT = 0x6050;\nvar M_BEVEL = 0x6060;\nvar XZ_CURVE = 0x6070;\nvar YZ_CURVE = 0x6080;\nvar INTERPCT = 0x6090;\nvar DEFORM_LIMIT = 0x60A0;\nvar USE_CONTOUR = 0x6100;\nvar USE_TWEEN = 0x6110;\nvar USE_SCALE = 0x6120;\nvar USE_TWIST = 0x6130;\nvar USE_TEETER = 0x6140;\nvar USE_FIT = 0x6150;\nvar USE_BEVEL = 0x6160;\nvar DEFAULT_VIEW = 0x3000;\nvar VIEW_TOP = 0x3010;\nvar VIEW_BOTTOM = 0x3020;\nvar VIEW_LEFT = 0x3030;\nvar VIEW_RIGHT = 0x3040;\nvar VIEW_FRONT = 0x3050;\nvar VIEW_BACK = 0x3060;\nvar VIEW_USER = 0x3070;\nvar VIEW_CAMERA = 0x3080;\nvar VIEW_WINDOW = 0x3090;\nvar VIEWPORT_LAYOUT_OLD = 0x7000;\nvar VIEWPORT_DATA_OLD = 0x7010;\nvar VIEWPORT_LAYOUT = 0x7001;\nvar VIEWPORT_DATA = 0x7011;\nvar VIEWPORT_DATA_3 = 0x7012;\nvar VIEWPORT_SIZE = 0x7020;\nvar NETWORK_VIEW = 0x7030;\n\n/* harmony default export */ const TDSLoader = (THREE.TDSLoader);\n\n;// CONCATENATED MODULE: ./models/suv.js\n/* harmony default export */ const suv = (\'data:text/plain;base64,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\');\n\n;// CONCATENATED MODULE: ./js/objects/CarObject.js\n\n\n\n\nconst CAR_COLOR = 0x0088ff;\nconst WHEEL_COLOR = 0xff8800;\n\nclass CarObject extends THREE.Object3D {\n constructor(car) {\n super();\n\n this.car = car;\n\n this.buildCar2D();\n this.buildCar3D();\n }\n\n buildCar2D() {\n const carMesh = new THREE.Mesh(\n new THREE.PlaneGeometry(Car_Car.HALF_CAR_LENGTH * 2, Car_Car.HALF_CAR_WIDTH * 2),\n new THREE.MeshBasicMaterial({ color: CAR_COLOR, depthTest: false, transparent: true, opacity: 0.7 })\n );\n carMesh.rotation.x = -Math.PI / 2;\n carMesh.layers.set(2);\n this.add(carMesh);\n\n const wheelGeometry = new THREE.PlaneGeometry(Car_Car.HALF_WHEEL_LENGTH * 2, Car_Car.HALF_WHEEL_WIDTH * 2);\n const wheelMaterial = new THREE.MeshBasicMaterial({ color: WHEEL_COLOR, depthTest: false, transparent: true, opacity: 0.7 })\n\n this.lfWheel2D = new THREE.Mesh(wheelGeometry, wheelMaterial);\n this.lfWheel2D.renderOrder = 1;\n this.lfWheel2D.position.set(Car_Car.FRONT_AXLE_POS, 0, Car_Car.WHEEL_LATERAL_POS);\n this.lfWheel2D.rotation.x = -Math.PI / 2;\n this.lfWheel2D.layers.set(2);\n this.add(this.lfWheel2D);\n\n this.rfWheel2D = new THREE.Mesh(wheelGeometry, wheelMaterial);\n this.rfWheel2D.renderOrder = 1;\n this.rfWheel2D.position.set(Car_Car.FRONT_AXLE_POS, 0, -Car_Car.WHEEL_LATERAL_POS);\n this.rfWheel2D.rotation.x = -Math.PI / 2;\n this.rfWheel2D.layers.set(2);\n this.add(this.rfWheel2D);\n\n const lrWheel = new THREE.Mesh(wheelGeometry, wheelMaterial);\n lrWheel.renderOrder = 1;\n lrWheel.position.set(Car_Car.REAR_AXLE_POS, 0, Car_Car.WHEEL_LATERAL_POS);\n lrWheel.rotation.x = -Math.PI / 2;\n lrWheel.layers.set(2);\n this.add(lrWheel);\n\n const rrWheel = new THREE.Mesh(wheelGeometry, wheelMaterial);\n rrWheel.renderOrder = 1;\n rrWheel.position.set(Car_Car.REAR_AXLE_POS, 0, -Car_Car.WHEEL_LATERAL_POS);\n rrWheel.rotation.x = -Math.PI / 2;\n rrWheel.layers.set(2);\n this.add(rrWheel);\n }\n\n buildCar3D() {\n const loader = new TDSLoader();\n loader.skipMaps = true;\n\n loader.load(suv, object => {\n object.layers.set(3);\n object.rotation.z = Math.PI / 2;\n object.rotation.x = -Math.PI / 2;\n\n const box = (new THREE.Box3()).setFromObject(object);\n const scaleLength = Car_Car.HALF_CAR_LENGTH * 2 / (box.max.x - box.min.x);\n const scaleWidth = Car_Car.HALF_CAR_WIDTH * 2 / (box.max.z - box.min.z);\n object.scale.set(scaleWidth, scaleLength, (scaleWidth + scaleLength) / 2);\n\n box.setFromObject(object);\n object.position.setX(-(box.max.x + box.min.x) / 2);\n object.position.setY(-box.min.y);\n\n this.add(object);\n\n const carMaterial = new THREE.MeshToonMaterial({ color: 0x0088ff });\n const wheelMaterial = new THREE.MeshToonMaterial({ color: 0xff8800 });\n\n object.traverse(child => {\n if (child instanceof THREE.Mesh) {\n child.layers.set(3);\n child.material = [\'Toyota_RA7\', \'Toyota_RA8\', \'Toyota_RA9\', \'Toyota_R10\'].includes(child.name) ? wheelMaterial : carMaterial;\n\n if (child.name == \'Toyota_RA7\')\n this.lfWheel3D = child;\n else if (child.name == \'Toyota_RA8\')\n this.rfWheel3D = child;\n }\n });\n\n [this.lfWheel3D, this.rfWheel3D].forEach(wheel => {\n wheel.geometry.computeBoundingBox();\n wheel.geometry.center();\n wheel.position.setY(wheel.position.y - 36);\n wheel.position.setZ(wheel.position.z + 36);\n });\n });\n }\n\n updateMatrix() {\n this.updateCar();\n super.updateMatrix();\n }\n\n updateCar() {\n const carPosition = this.car.position;\n this.position.set(carPosition.x, 0, carPosition.y);\n this.rotation.y = -this.car.rotation;\n\n const wheelAngle = this.car.wheelAngle;\n\n // Adding the wheels to the car object can trigger this function in some browsers\n // before the other wheels are added, so check them first.\n if (this.lfWheel2D) this.lfWheel2D.rotation.z = -wheelAngle;\n if (this.rfWheel2D) this.rfWheel2D.rotation.z = -wheelAngle;\n if (this.lfWheel3D) this.lfWheel3D.rotation.y = wheelAngle;\n if (this.rfWheel3D) this.rfWheel3D.rotation.y = wheelAngle;\n }\n}\n\n;// CONCATENATED MODULE: ./js/objects/StaticObstacleObject.js\nconst COLOR = 0xdd0000;\nconst HEIGHT = 5;\n\nclass StaticObstacleObject extends THREE.Object3D {\n constructor(staticObstacle) {\n super();\n\n const mesh2D = new THREE.Mesh(\n new THREE.PlaneGeometry(staticObstacle.width, staticObstacle.height),\n new THREE.MeshBasicMaterial({ color: COLOR, depthTest: false, transparent: true, opacity: 0.5 })\n );\n mesh2D.rotation.x = -Math.PI / 2;\n mesh2D.layers.set(2);\n this.add(mesh2D);\n\n const stoneTexture = new THREE.TextureLoader().load(\'http://127.0.0.1:8008/images/stone.jpg\');\n stoneTexture.wrapS = THREE.RepeatWrapping\n stoneTexture.wrapT = THREE.RepeatWrapping\n stoneTexture.magFilter = THREE.NearestFilter\n\n const mesh3D = new THREE.Mesh(\n new THREE.BoxBufferGeometry(staticObstacle.width, HEIGHT, staticObstacle.height),\n new THREE.MeshToonMaterial({ map: stoneTexture, transparent: true, opacity: 0.9 })\n );\n mesh3D.position.setY(HEIGHT / 2);\n mesh3D.layers.set(3);\n this.add(mesh3D);\n\n this.rotation.y = -staticObstacle.rot;\n this.position.set(staticObstacle.pos.x, 0, staticObstacle.pos.y);\n }\n}\n\n;// CONCATENATED MODULE: ./js/objects/DynamicObstacleObject.js\nclass DynamicObstacleObject extends THREE.Object3D {\n constructor(dynamicObstacle, lanePath) {\n super();\n\n this.dynamicObstacle = dynamicObstacle;\n this.lanePath = lanePath;\n this.size = dynamicObstacle.size;\n\n const colors = {\n vehicle: 0xff8800,\n cyclist: 0x00ccff,\n pedestrian: 0xffdd00\n };\n\n const heights = {\n vehicle: 2.0,\n cyclist: 1.8,\n pedestrian: 1.8\n };\n\n const mesh2D = new THREE.Mesh(\n new THREE.PlaneGeometry(dynamicObstacle.size.w * 2, dynamicObstacle.size.h * 2),\n new THREE.MeshBasicMaterial({ color: colors[dynamicObstacle.type] || 0xff8800, depthTest: false, transparent: true, opacity: 0.7 })\n );\n mesh2D.rotation.x = -Math.PI / 2;\n mesh2D.layers.set(2);\n this.add(mesh2D);\n\n const mesh3D = new THREE.Mesh(\n new THREE.BoxBufferGeometry(dynamicObstacle.size.w * 2, heights[dynamicObstacle.type] || 1.5, dynamicObstacle.size.h * 2),\n new THREE.MeshToonMaterial({ color: colors[dynamicObstacle.type] || 0xff8800, transparent: true, opacity: 0.7 })\n );\n mesh3D.position.setY((heights[dynamicObstacle.type] || 1.5) / 2);\n mesh3D.layers.set(3);\n this.add(mesh3D);\n }\n\n update(time) {\n const slPos = this.dynamicObstacle.positionAtTime(time);\n\n // Sample just the station this dynamic obstacle is at\n const [sample] = this.lanePath.sampleStations(slPos.x, 1, 0);\n\n if (sample === undefined) {\n this.visible = false;\n return;\n }\n\n const rot = sample.rot;\n const pos = THREE.Vector2.fromAngle(rot + Math.PI / 2).multiplyScalar(slPos.y).add(sample.pos);\n\n this.position.set(pos.x, 0, pos.y);\n this.rotation.y = -rot;\n\n super.updateMatrix();\n\n this.visible = slPos.x >= 0;\n }\n}\n\n;// CONCATENATED MODULE: ./js/autonomy/LanePath.js\nconst halfLaneWidth = 3.7;\n\nconst centerlineGeometry = new THREE.Geometry();\nconst leftBoundaryGeometry = new THREE.Geometry();\nconst rightBoundaryGeometry = new THREE.Geometry();\n\nclass LanePath {\n static hydrate(obj) {\n Object.setPrototypeOf(obj, LanePath.prototype);\n }\n\n constructor() {\n this.anchors = [];\n this.centerlines = [];\n this.sampleLengths = [];\n this.arcLengths = [];\n this.leftBoundaries = [];\n this.rightBoundaries = [];\n }\n\n get centerline() {\n return [].concat(...this.centerlines);\n }\n\n get leftBoundary() {\n return [].concat(...this.leftBoundaries);\n }\n\n get rightBoundary() {\n return [].concat(...this.rightBoundaries);\n }\n\n get arcLength() {\n return this.arcLengths.reduce((sum, l) => sum + l, 0);\n }\n\n sampleStations(startStation, num, interval) {\n const samples = [];\n let anchorIndex = 0;\n let sampleIndex = 0;\n let totalLength = 0;\n let nextStation = startStation;\n\n while (totalLength + this.arcLengths[anchorIndex] < nextStation) {\n totalLength += this.arcLengths[anchorIndex];\n\n if (++anchorIndex >= this.arcLengths.length)\n return samples;\n }\n\n for (let i = 0; i < num; i++) {\n let length = this.sampleLengths[anchorIndex][sampleIndex];\n while (totalLength + length < nextStation) {\n totalLength += length;\n\n if (++sampleIndex >= this.sampleLengths[anchorIndex].length) {\n sampleIndex = 0;\n\n if (++anchorIndex >= this.sampleLengths.length)\n return samples;\n }\n\n length = this.sampleLengths[anchorIndex][sampleIndex];\n }\n\n const [p0, p1, p2, p3] = this.anchorsForSplineIndex(anchorIndex);\n const weight = (sampleIndex + (nextStation - totalLength) / length) / this.sampleLengths[anchorIndex].length;\n const pos = catmullRomVec(weight, p0, p1, p2, p3);\n const tangent = tangentAt(weight, p0, p1, p2, p3);\n const rot = Math.atan2(tangent.y, tangent.x);\n const curv = curvatureAt(weight, p0, p1, p2, p3);\n\n samples.push({ pos, rot, curv });\n nextStation += interval;\n }\n\n return samples;\n }\n\n stationLatitudeFromPosition(position, aroundAnchorIndex = null) {\n const [anchorIndex, sampleIndex, sampleStation, prevSampleStation] = this._findClosestSample(position, aroundAnchorIndex);\n\n if (anchorIndex === undefined) return [0, 0, 0];\n\n let prevPoint;\n let nextPoint;\n let prevStation;\n let nextStation;\n\n if (anchorIndex == 0 && sampleIndex == 0) {\n prevPoint = this.centerlines[anchorIndex][sampleIndex];\n nextPoint = this.centerlines[anchorIndex][sampleIndex + 1];\n prevStation = 0;\n nextStation = this.sampleLengths[anchorIndex][sampleIndex];\n } else if (anchorIndex == this.centerlines.length - 1 && sampleIndex == this.centerlines[anchorIndex].length - 1) {\n prevPoint = this.centerlines[anchorIndex][sampleIndex - 1];\n nextPoint = this.centerlines[anchorIndex][sampleIndex];\n prevStation = prevSampleStation;\n nextStation = sampleStation;\n } else {\n prevPoint = sampleIndex == 0 ? this.centerlines[anchorIndex - 1][this.centerlines[anchorIndex - 1].length - 1] : this.centerlines[anchorIndex][sampleIndex - 1];\n nextPoint = sampleIndex == this.centerlines[anchorIndex].length - 1 ? this.centerlines[anchorIndex + 1][0] : this.centerlines[anchorIndex][sampleIndex + 1];\n\n const possibleNext = this.centerlines[anchorIndex][sampleIndex];\n const possibleProgress = position.clone().sub(prevPoint).dot(possibleNext.clone().sub(prevPoint)) / prevPoint.distanceToSquared(possibleNext);\n\n if (possibleProgress < 1) {\n nextPoint = possibleNext;\n prevStation = prevSampleStation;\n nextStation = sampleStation;\n } else {\n prevPoint = possibleNext;\n prevStation = sampleStation;\n nextStation = sampleStation + this.sampleLengths[anchorIndex][sampleIndex];\n }\n }\n\n const progress = Math.clamp(position.clone().sub(prevPoint).dot(nextPoint.clone().sub(prevPoint)) / prevPoint.distanceToSquared(nextPoint), 0, 1);\n const projectedPosition = nextPoint.clone().sub(prevPoint).multiplyScalar(progress).add(prevPoint);\n\n const station = prevStation + (nextStation - prevStation) * progress;\n const latitude = Math.sign((nextPoint.x - prevPoint.x) * (position.y - prevPoint.y) - (nextPoint.y - prevPoint.y) * (position.x - prevPoint.x)) * position.distanceTo(projectedPosition);\n\n return [station, latitude, anchorIndex];\n }\n\n _findClosestSample(position, aroundAnchorIndex = null) {\n let closest = Number.POSITIVE_INFINITY;\n let bestAnchorIndex;\n let bestSampleIndex;\n let bestStation;\n let bestPrevStation;\n\n let currStation = 0;\n let prevStation = 0;\n\n let startAnchorIndex = 0;\n let endAnchorIndex = this.centerlines.length - 1;\n\n if (aroundAnchorIndex !== null) {\n startAnchorIndex = Math.max(0, aroundAnchorIndex - 2);\n endAnchorIndex = Math.min(this.centerlines.length - 1, aroundAnchorIndex + 2);\n }\n\n if (startAnchorIndex > 0) {\n for (let anchorIndex = 0; anchorIndex < startAnchorIndex; anchorIndex++) {\n currStation += this.arcLengths[anchorIndex];\n }\n\n prevStation = currStation - this.sampleLengths[startAnchorIndex - 1][this.sampleLengths[startAnchorIndex - 1].length - 1];\n }\n\n for (let anchorIndex = startAnchorIndex; anchorIndex <= endAnchorIndex; anchorIndex++) {\n const centerline = this.centerlines[anchorIndex];\n for (let sampleIndex = 0; sampleIndex < centerline.length; sampleIndex++) {\n const distSq = position.distanceToSquared(centerline[sampleIndex]);\n if (distSq < closest) {\n closest = distSq;\n bestAnchorIndex = anchorIndex;\n bestSampleIndex = sampleIndex;\n bestStation = currStation;\n bestPrevStation = prevStation;\n }\n\n prevStation = currStation;\n currStation += this.sampleLengths[anchorIndex][sampleIndex];\n }\n }\n\n return [bestAnchorIndex, bestSampleIndex, bestStation, bestPrevStation];\n }\n\n addAnchor(position, resample = true) {\n const index = this.anchors.push(position) - 1;\n\n if (resample) {\n for (let i = index - 2; i < index; i++)\n this.resample(i);\n }\n }\n\n updateAnchor(index, position) {\n this.anchors[index] = position;\n\n for (let i = index - 2; i <= index + 1; i++)\n this.resample(i);\n }\n\n removeAnchor(index) {\n if (index < 0 || index >= this.anchors.length) return;\n\n this.anchors.splice(index, 1);\n\n const segmentIndex = index < this.anchors.length ? index : index - 1;\n this.centerlines.splice(segmentIndex, 1);\n this.sampleLengths.splice(segmentIndex, 1);\n this.leftBoundaries.splice(segmentIndex, 1);\n this.rightBoundaries.splice(segmentIndex, 1);\n this.arcLengths.splice(segmentIndex, 1);\n\n for (let i = segmentIndex - 2; i <= segmentIndex; i++)\n this.resample(i);\n }\n\n resample(index) {\n if (index < 0 || index > this.anchors.length - 2) return;\n\n const [p0, p1, p2, p3] = this.anchorsForSplineIndex(index);\n const points = [];\n const lengths = [];\n const leftBoundary = [];\n const rightBoundary = [];\n let prevPoint = null;\n\n const pointsPerSegment = Math.max(10, Math.ceil(p1.distanceTo(p2) / 1));\n const numPoints = index == this.anchors.length - 2 ? pointsPerSegment + 1 : pointsPerSegment;\n\n for (let i = 0; i < numPoints; i++) {\n const t = i / pointsPerSegment;\n const point = catmullRomVec(t, p0, p1, p2, p3);\n points.push(point);\n\n if (prevPoint != null)\n lengths.push(prevPoint.distanceTo(point));\n prevPoint = point;\n\n const tangent = tangentAt(t, p0, p1, p2, p3);\n const normal = new THREE.Vector2(-tangent.y, tangent.x);\n\n leftBoundary.push(normal.clone().multiplyScalar(-halfLaneWidth).add(point));\n rightBoundary.push(normal.clone().multiplyScalar(halfLaneWidth).add(point));\n }\n\n lengths.push(prevPoint.distanceTo(p2));\n\n this.centerlines[index] = points;\n this.sampleLengths[index] = lengths;\n this.leftBoundaries[index] = leftBoundary;\n this.rightBoundaries[index] = rightBoundary;\n this.arcLengths[index] = lengths.reduce((sum, l) => sum + l, 0);\n }\n\n resampleAll() {\n for (let i = 0; i < this.anchors.length; i++)\n this.resample(i);\n }\n\n anchorsForSplineIndex(index) {\n let p;\n if (index == 0)\n p = [this.anchors[0]].concat(this.anchors.slice(0, 3));\n else\n p = this.anchors.slice(index - 1, index + 3);\n\n if (p[3] === undefined)\n p[3] = p[2];\n\n return p;\n }\n}\n\nfunction catmullRom(t, p0, p1, p2, p3) {\n const v0 = (p2 - p0) * 0.5;\n const v1 = (p3 - p1) * 0.5;\n const t2 = t * t;\n const t3 = t * t2;\n return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;\n}\n\nfunction catmullRomVec(t, p0, p1, p2, p3) {\n return new THREE.Vector2(catmullRom(t, p0.x, p1.x, p2.x, p3.x), catmullRom(t, p0.y, p1.y, p2.y, p3.y));\n}\n\nfunction tangentAt(t, p0, p1, p2, p3) {\n const delta = 0.0001;\n let t1 = t - delta;\n let t2 = t + delta;\n\n if (t1 < 0) t1 = 0;\n if (t2 > 1) t2 = 1;\n\n const prev = catmullRomVec(t1, p0, p1, p2, p3);\n const next = catmullRomVec(t2, p0, p1, p2, p3);\n\n return next.sub(prev).normalize();\n}\n\nfunction curvatureAt(t2, p0, p1, p2, p3) {\n const delta = 0.0001;\n\n // If we\'re estimating curvature at one of the endpoints of the spline,\n // slightly shift it inwards to avoid infinite curvature.\n if (t2 == 0) t2 = delta;\n if (t2 == 1) t2 = 1 - delta;\n\n let t1 = t2 - delta;\n let t3 = t2 + delta;\n\n if (t1 < 0) t1 = 0;\n if (t3 > 1) t3 = 1;\n\n const pt1 = catmullRomVec(t1, p0, p1, p2, p3);\n const pt2 = catmullRomVec(t2, p0, p1, p2, p3);\n const pt3 = catmullRomVec(t3, p0, p1, p2, p3);\n\n return (Math.atan2(pt3.y - pt2.y, pt3.x - pt2.x) - Math.atan2(pt2.y - pt1.y, pt2.x - pt1.x)) / pt2.distanceTo(pt1);\n}\n\n;// CONCATENATED MODULE: ./js/autonomy/StaticObstacle.js\nclass StaticObstacle {\n static hydrate(obj) {\n Object.setPrototypeOf(obj, StaticObstacle.prototype);\n Object.setPrototypeOf(obj.pos, THREE.Vector2.prototype);\n }\n\n static fromJSON(json) {\n return new StaticObstacle(new THREE.Vector2(json.p[0], json.p[1]), json.r, json.w, json.h);\n }\n\n constructor(pos, rot, width, height) {\n this.pos = pos;\n this.rot = rot;\n this.width = width;\n this.height = height;\n\n this.updateVertices();\n }\n\n toJSON() {\n const trunc = n => +n.toFixed(5);\n\n return {\n p: [trunc(this.pos.x), trunc(this.pos.y)],\n r: trunc(this.rot),\n w: trunc(this.width),\n h: trunc(this.height)\n };\n }\n\n updateVertices() {\n this.vertices = [];\n\n const cosRot = Math.cos(this.rot);\n const sinRot = Math.sin(this.rot);\n const halfWidth = this.width / 2;\n const halfHeight = this.height / 2;\n\n const hWcR = halfWidth * cosRot;\n const hWsR = halfWidth * sinRot;\n const hHcR = halfHeight * cosRot;\n const hHsR = halfHeight * sinRot;\n\n const v1 = [-hWcR - hHsR + this.pos.x, -hWsR + hHcR + this.pos.y];\n const v2 = [-hWcR + hHsR + this.pos.x, -hWsR - hHcR + this.pos.y];\n const v3 = [hWcR + hHsR + this.pos.x, hWsR - hHcR + this.pos.y];\n const v4 = [hWcR - hHsR + this.pos.x, hWsR + hHcR + this.pos.y];\n\n this.vertices = [\n v1[0], v1[1],\n v2[0], v2[1],\n v3[0], v3[1],\n v3[0], v3[1],\n v4[0], v4[1],\n v1[0], v1[1]\n ];\n }\n}\n\n;// CONCATENATED MODULE: ./js/autonomy/DynamicObstacle.js\n// Half width and half height\nconst VEHICLE_SIZE = { w: 2.5, h: 1 };\nconst CYCLIST_SIZE = { w: 1.2, h: 0.6 };\nconst PEDESTRIAN_SIZE = { w: 0.6, h: 0.6 };\n\nclass DynamicObstacle {\n static hydrate(obj) {\n Object.setPrototypeOf(obj, DynamicObstacle.prototype);\n Object.setPrototypeOf(obj.startPos, THREE.Vector2.prototype);\n Object.setPrototypeOf(obj.velocity, THREE.Vector2.prototype);\n }\n\n constructor(type, startPos, velocity, parallel) {\n this.type = type;\n this.startPos = startPos;\n this.velocity = velocity;\n this.parallel = parallel;\n\n switch (type) {\n case \'cyclist\':\n this.size = Object.assign({}, CYCLIST_SIZE);\n break;\n\n case \'pedestrian\':\n this.size = Object.assign({}, PEDESTRIAN_SIZE);\n break;\n\n default:\n this.size = Object.assign({}, VEHICLE_SIZE);\n }\n\n if (!parallel)\n [this.size.w, this.size.h] = [this.size.h, this.size.w];\n }\n\n positionAtTime(time) {\n return this.velocity.clone().multiplyScalar(time).add(this.startPos);\n }\n\n positionsInTimeRange(startTime, endTime, numFrames) {\n const dt = (endTime - startTime) / numFrames;\n const positions = [];\n let time = startTime;\n\n for (let i = 0; i <= numFrames; i++) {\n positions.push(this.positionAtTime(time));\n time += dt;\n }\n\n return positions;\n }\n\n verticesInTimeRange(startTime, endTime, config) {\n const positions = this.positionsInTimeRange(startTime, endTime, config.numDynamicSubframes);\n const vertices = [];\n\n // Hazard dilation (drawn behind, z = 0.75)\n const hazardHalfWidth = this.size.w + config.dynamicHazardDilationS + config.collisionDilationS;\n const hazardHalfHeight = this.size.h + config.dynamicHazardDilationL + config.collisionDilationL;\n\n positions.forEach(p => {\n const v1 = [-hazardHalfWidth + p.x, hazardHalfHeight + p.y];\n const v2 = [hazardHalfWidth + p.x, hazardHalfHeight + p.y];\n const v3 = [hazardHalfWidth + p.x, -hazardHalfHeight + p.y];\n const v4 = [-hazardHalfWidth + p.x, -hazardHalfHeight + p.y];\n\n vertices.push(\n v1[0], v1[1], 0.75,\n v2[0], v2[1], 0.75,\n v3[0], v3[1], 0.75,\n v3[0], v3[1], 0.75,\n v4[0], v4[1], 0.75,\n v1[0], v1[1], 0.75\n );\n });\n\n // Collision dilation (drawn in front, z = 0.25)\n const collisionHalfWidth = this.size.w + config.collisionDilationS;\n const collisionHalfHeight = this.size.h + config.collisionDilationL;\n\n positions.forEach(p => {\n const v1 = [-collisionHalfWidth + p.x, collisionHalfHeight + p.y];\n const v2 = [collisionHalfWidth + p.x, collisionHalfHeight + p.y];\n const v3 = [collisionHalfWidth + p.x, -collisionHalfHeight + p.y];\n const v4 = [-collisionHalfWidth + p.x, -collisionHalfHeight + p.y];\n\n vertices.push(\n v1[0], v1[1], 0.25,\n v2[0], v2[1], 0.25,\n v3[0], v3[1], 0.25,\n v3[0], v3[1], 0.25,\n v4[0], v4[1], 0.25,\n v1[0], v1[1], 0.25\n );\n });\n\n return vertices;\n }\n}\n\n;// CONCATENATED MODULE: ./js/simulator/PathPlannerConfigEditor.js\n\n\nconst LOCAL_STORAGE_KEY = \'dash_PathPlannerConfig\';\n\nconst internalConfig = {\n lattice: {\n numStations: 8,\n numLatitudes: 17,\n stationConnectivity: 3,\n latitudeConnectivity: 7\n },\n\n roadWidth: 3.7 * 2, // meters\n\n numDynamicFrames: 20,\n numDynamicSubframes: 4,\n\n dCurvatureMax: Car_Car.MAX_STEER_SPEED / Car_Car.WHEEL_BASE,\n rearAxleToCenter: -Car_Car.REAR_AXLE_POS\n};\n\nconst defaultConfig = {\n spatialHorizon: 120, // meters\n centerlineStationInterval: 0.5, // meters\n\n xyGridCellSize: 0.3, // meters\n slGridCellSize: 0.15, // meters\n gridMargin: 20, // meters\n pathSamplingStep: 1, // meters\n\n cubicPathPenalty: 0,\n\n collisionDilationS: Car_Car.HALF_CAR_LENGTH + 2, // meters\n hazardDilationS: 8, // meters\n collisionDilationL: Car_Car.HALF_CAR_WIDTH + 0.5, //meters\n hazardDilationL: 0.5, // meters\n\n dynamicHazardDilationS: 16,\n dynamicHazardDilationL: 0.5,\n\n obstacleHazardCost: 200,\n\n laneCenterLatitude: internalConfig.roadWidth / 4,\n laneShoulderLatitude: internalConfig.roadWidth / 2 * 1.1 - Car_Car.HALF_CAR_WIDTH,\n laneCostSlope: 20, // cost / meter\n lanePreferenceDiscount: 55,\n\n stationReachDiscount: 400,\n extraTimePenalty: 1000,\n\n hysteresisDiscount: 50,\n\n speedLimitPenalty: 200,\n\n hardAccelerationPenalty: 70,\n hardDecelerationPenalty: 50,\n\n softLateralAccelerationLimit: 4, // m/s^2\n softLateralAccelerationPenalty: 100,\n linearLateralAccelerationPenalty: 10,\n\n accelerationChangePenalty: 10\n};\n\nclass PathPlannerConfigEditor {\n constructor() {\n this._config = Object.assign({}, defaultConfig);\n\n this.showConfigBox = document.getElementById(\'show-config-box\');\n this.configBox = document.getElementById(\'config-box-content\');\n this.configForm = document.getElementById(\'config-form\');\n\n this._setUpButtons();\n\n let storedConfig = {};\n try {\n storedConfig = JSON.parse(window.localStorage.getItem(LOCAL_STORAGE_KEY)) || {};\n } catch (e) {}\n\n for (const key of Object.keys(this._config).sort()) {\n if (storedConfig[key] !== undefined) this._config[key] = storedConfig[key];\n this.configForm.appendChild(this._createConfigField(key, this._config[key]));\n }\n }\n\n get config() {\n return Object.assign({}, this._config, internalConfig);\n }\n\n _setUpButtons() {\n document.getElementById(\'show-config-button\').addEventListener(\'click\', e => {\n this.showConfigBox.classList.add(\'is-hidden\');\n this.configBox.classList.remove(\'is-hidden\');\n });\n\n document.getElementById(\'hide-config-button\').addEventListener(\'click\', e => {\n this.showConfigBox.classList.remove(\'is-hidden\');\n this.configBox.classList.add(\'is-hidden\');\n });\n\n document.getElementById(\'save-config-button\').addEventListener(\'click\', this._saveConfigFields.bind(this));\n document.getElementById(\'restore-defaults-config-button\').addEventListener(\'click\', this._restoreDefaults.bind(this));\n }\n\n _createConfigField(key, value) {\n const html =\n `
\n
\n \n
\n
\n
\n
\n \n
\n
\n
\n
`;\n\n const template = document.createElement(\'template\');\n template.innerHTML = html;\n return template.content.firstChild;\n }\n\n _saveConfigFields() {\n const formData = new FormData(this.configForm);\n\n for (const [k, v] of formData.entries()) {\n const parsedValue = Number.parseFloat(v);\n this._config[k] = parsedValue\n\n const fieldDom = document.getElementById(`config-field-${k}`);\n if (parsedValue === defaultConfig[k])\n fieldDom.classList.remove(\'is-danger\');\n else\n fieldDom.classList.add(\'is-danger\');\n }\n\n try {\n window.localStorage.setItem(LOCAL_STORAGE_KEY, JSON.stringify(this._config));\n } catch (e) {}\n }\n\n _restoreDefaults() {\n this._config = Object.assign({}, defaultConfig);\n\n try {\n window.localStorage.removeItem(LOCAL_STORAGE_KEY);\n } catch (e) {}\n\n while (this.configForm.firstChild)\n this.configForm.removeChild(this.configForm.firstChild);\n\n for (const key of Object.keys(this._config).sort())\n this.configForm.appendChild(this._createConfigField(key, this._config[key]));\n }\n}\n\nPathPlannerConfigEditor.internalConfig = internalConfig;\n\n;// CONCATENATED MODULE: ./js/simulator/DynamicObstacleEditor.js\n\n\n\nclass DynamicObstacleEditor {\n constructor() {\n this.editorDom = document.getElementById(\'editor-dynamic-obstacles-box\');\n this.formsContainer = document.getElementById(\'editor-dynamic-obstacle-forms\');\n this.statsDynamicObstacles = document.getElementById(\'editor-stats-dynamic-obstacles\');\n\n document.getElementById(\'editor-add-dynamic-obstacle\').addEventListener(\'click\', this.addDynamicObstacle.bind(this));\n }\n\n enable() {\n this.editorDom.classList.remove(\'is-hidden\');\n }\n\n disable() {\n this.editorDom.classList.add(\'is-hidden\');\n }\n\n toJSON() {\n const forms = this.formsContainer.getElementsByTagName(\'form\');\n const obstacles = [];\n\n for (let i = 0; i < forms.length; i++) {\n const formData = new FormData(forms[i]);\n const params = { parallel: false };\n\n for (const [k, v] of formData.entries())\n params[k] = v;\n\n let type = 0;\n if (params.type == \'cyclist\')\n type = 1;\n else if (params.type == \'pedestrian\')\n type = 2;\n\n obstacles.push({\n p: [params.sPos, params.lPos],\n v: [params.sVel, params.lVel],\n l: !!params.parallel ? 1 : 0,\n t: type\n });\n }\n\n return obstacles;\n }\n\n loadJSON(json) {\n this.clearDynamicObstacles();\n\n json.forEach(o => {\n const form = this.addDynamicObstacle();\n\n form[\'sPos\'].value = o.p[0];\n form[\'lPos\'].value = o.p[1];\n form[\'sVel\'].value = o.v[0];\n form[\'lVel\'].value = o.v[1];\n form[\'parallel\'].checked = !!o.l;\n form[\'type\'].selectedIndex = o.t;\n });\n }\n\n collectDynamicObstacles() {\n const forms = this.formsContainer.getElementsByTagName(\'form\');\n const obstacles = [];\n\n for (let i = 0; i < forms.length; i++) {\n const formData = new FormData(forms[i]);\n const params = { parallel: false };\n\n for (const [k, v] of formData.entries())\n params[k] = v;\n\n const pos = new THREE.Vector2(Number(params.sPos) || 0, (Number(params.lPos) || 0) * PathPlannerConfigEditor.internalConfig.roadWidth / 2);\n const vel = new THREE.Vector2(Number(params.sVel) || 0, Number(params.lVel) || 0);\n const parallel = !!params.parallel;\n\n obstacles.push(new DynamicObstacle(params.type, pos, vel, parallel));\n }\n\n return obstacles;\n }\n\n addDynamicObstacle() {\n const index = this.formsContainer.getElementsByTagName(\'form\').length + 1;\n const form = this.buildForm(index);\n\n this.formsContainer.appendChild(form);\n this.statsDynamicObstacles.textContent = this.formsContainer.getElementsByTagName(\'form\').length;\n\n return form;\n }\n\n removeDynamicObstacle(form) {\n this.formsContainer.removeChild(form);\n this.reindexForms();\n this.statsDynamicObstacles.textContent = this.formsContainer.getElementsByTagName(\'form\').length;\n }\n\n clearDynamicObstacles() {\n this.formsContainer.innerHTML = \'\';\n this.statsDynamicObstacles.textContent = 0;\n }\n\n reindexForms() {\n const forms = this.formsContainer.getElementsByTagName(\'form\');\n\n for (let i = 0; i < forms.length; i++) {\n forms[i].getElementsByClassName(\'dynamic-obstacle-index\')[0].textContent = i + 1;\n }\n }\n\n buildForm(index) {\n const html =\n `
\n
\n
\n
\n
${index}
\n
\n
\n
\n
\n
\n
\n \n
\n
\n
\n
\n
\n
\n
\n \n
\n
\n
\n
\n
\n
\n \n
\n
\n \n
\n
\n
\n
\n
\n
\n \n
\n
\n \n
\n
\n
\n
\n
\n
\n \n \n \n
\n
\n
\n
\n
`;\n\n const template = document.createElement(\'template\');\n template.innerHTML = html;\n const form = template.content.firstChild;\n\n form.getElementsByClassName(\'editor-remove-dynamic-obstacle\')[0].addEventListener(\'click\', e => this.removeDynamicObstacle(form));\n\n return form;\n }\n}\n\n;// CONCATENATED MODULE: ./js/Helpers.js\nfunction formatDate(date) {\n return date && date.toLocaleDateString(undefined, {month: \'short\', day: \'numeric\', year: \'numeric\', hour: \'numeric\', minute: \'numeric\', hour12: true});\n}\n\n\n\n;// CONCATENATED MODULE: ./js/simulator/examples.js\n/* harmony default export */ const examples = ([\n { name: "One-car overtake", data: {"p":[-298.12979,357.51057,7.55497,136.89255,255.45446,-186.65063,586.66288,-494.5808],"s":[],"d":[{"p":["150","0.5"],"v":["15","0"],"l":1,"t":0}],"l":1238.129,"c":{"s":"25","sl":"25","lp":1},"v":1} },\n\n { name: "Two-car overtake", data: {"p":[-276.4674,303.00865,44.88593,120.86712,305.10729,-435.99728],"s":[],"d":[{"p":["100","0.5"],"v":["5","0"],"l":1,"t":0},{"p":["100","-0.5"],"v":["6","0"],"l":1,"t":0}],"l":990.576,"c":{"s":"20","sl":"20","lp":1},"v":1} },\n\n { name: "Rough road", data: {"p":[-102.46078,26.38513,-68.69821,25.79776,-55.94913,19.50427,-25.32284,12.6183,-16.6024,10.7739,-6.708,11.78013,31.36054,12.11554,47.04057,14.7988,56.85048,23.26776,56.84979,35.25828,46.95511,43.89463,25.48979,43.55924,8.13326,52.2799,-15.34437,64.10242],"s":[{"p":[-54.96429,21.2553],"r":-0.27612,"w":2.7671,"h":1.67703},{"p":[-36.09254,12.36963],"r":0.14726,"w":3.43791,"h":1.84475},{"p":[-13.41625,14.2537],"r":0.11658,"w":4.69568,"h":1.42549},{"p":[44.00931,18.38166],"r":0.25771,"w":4.94713,"h":4.27642},{"p":[62.74669,29.41331],"r":0,"w":4.10855,"h":5.86952},{"p":[46.71119,38.74469],"r":1.14742,"w":4.52775,"h":6.70794},{"p":[-14.26275,63.60006],"r":2.67526,"w":10.14584,"h":12.24173},{"p":[19.7351,9.40621],"r":0.65041,"w":1.97177,"h":1.07553},{"p":[28.99679,9.71727],"r":0.20862,"w":1.97175,"h":1.03072},{"p":[24.15205,9.93872],"r":-0.31907,"w":1.25476,"h":0.9859}],"d":[],"l":259.088,"c":{"s":"10","sl":"10","lp":1},"v":1} },\n\n { name: "Dodging a speeder", data: {"p":[-226.14066,275.34941,21.32194,-6.2654,266.99958,-174.39559,466.42449,-427.95124],"s":[],"d":[{"p":["-250","-0.5"],"v":["40","0"],"l":1,"t":0}],"l":996.572,"c":{"s":"25","sl":"25","lp":-1},"v":1} },\n\n { name: "Lane blockage with oncoming traffic", data: {"p":[-84.96318,-14.94973,374.91044,-14.7168],"s":[{"p":[-34.91024,-12.51359],"r":0,"w":2.76711,"h":2.68324}],"d":[{"p":["40","-0.5"],"v":["-10","0"],"l":1,"t":0},{"p":["150","-0.5"],"v":["-10","0"],"l":1,"t":0}],"l":459.874,"c":{"s":"20","sl":"20","lp":1},"v":1} },\n\n { name: "Merging into slower traffic", data: {"p":[-629.09464,16.31589,281.97162,14.81565],"s":[{"p":[-440.00152,11.62602],"r":0,"w":3.1379,"h":3.13801},{"p":[-259.74036,11.98013],"r":0,"w":2.51556,"h":4.4441},{"p":[93.71013,11.27032],"r":0,"w":4.07947,"h":7.84501},{"p":[-94.72208,11.28172],"r":0,"w":3.76609,"h":7.53122}],"d":[{"p":["320","0.5"],"v":["12","0"],"l":1,"t":0},{"p":["280","0.5"],"v":["12","0"],"l":1,"t":0},{"p":["240","0.5"],"v":["12","0"],"l":1,"t":0},{"p":["200","0.5"],"v":["12","0"],"l":1,"t":0},{"p":["160","0.5"],"v":["12","0"],"l":1,"t":0},{"p":["120","0.5"],"v":["12","0"],"l":1,"t":0},{"p":["80","0.5"],"v":["12","0"],"l":1,"t":0},{"p":["40","0.5"],"v":["12","0"],"l":1,"t":0},{"p":["0","0.5"],"v":["12","0"],"l":1,"t":0},{"p":["-40","0.5"],"v":["12","0"],"l":1,"t":0},{"p":["-80","0.5"],"v":["12","0"],"l":1,"t":0},{"p":["-120","0.5"],"v":["12","0"],"l":1,"t":0},{"p":["-160","0.5"],"v":["12","0"],"l":1,"t":0},{"p":["-200","0.5"],"v":["12","0"],"l":1,"t":0}],"l":911.067,"c":{"s":"25","sl":"25","lp":-1},"v":1} },\n\n { name: "Negotiating crosswalks", data: {"p":[-144.73574,55.4495,-104.89441,31.62755,-33.87479,61.57811,54.60631,46.34858,152.3728,-41.4335,219.90258,-113.95225],"s":[],"d":[{"p":["51","-2"],"v":["0","1.5"],"l":1,"t":2},{"p":["52","+2"],"v":["0","-1.6"],"l":1,"t":2},{"p":["53","-2"],"v":["0","1.5"],"l":1,"t":2},{"p":["54","+2"],"v":["0","-1.4"],"l":1,"t":2},{"p":["55","-2"],"v":["0","1.5"],"l":1,"t":2},{"p":["50","+3"],"v":["0","-1.5"],"l":1,"t":2},{"p":["51","-3"],"v":["0","1.7"],"l":1,"t":2},{"p":["52","+3"],"v":["0","-1.5"],"l":1,"t":2},{"p":["53","-3"],"v":["0","1.3"],"l":1,"t":2},{"p":["50","-4"],"v":["0","1.6"],"l":1,"t":2},{"p":["51","-4"],"v":["0","1.2"],"l":1,"t":2},{"p":["52","-5"],"v":["0","1.5"],"l":1,"t":2},{"p":["53","-5"],"v":["0","1.4"],"l":1,"t":2},{"p":["50","4.5"],"v":["0","-1.6"],"l":1,"t":2},{"p":["51","5"],"v":["0","-1.4"],"l":1,"t":2},{"p":["52","4"],"v":["0","-1.5"],"l":1,"t":2},{"p":["53","4.5"],"v":["0","-1.4"],"l":1,"t":2},{"p":["49","5.5"],"v":["0","-1.2"],"l":1,"t":2},{"p":["50","6"],"v":["0","-1.6"],"l":1,"t":2},{"p":["51","5.75"],"v":["0","-1.5"],"l":1,"t":2},{"p":["52","5"],"v":["0","-1.5"],"l":1,"t":2},{"p":["49","-6"],"v":["0","1.5"],"l":1,"t":2},{"p":["50","-5.5"],"v":["0","1.7"],"l":1,"t":2},{"p":["51","-5"],"v":["0","0.9"],"l":1,"t":2},{"p":["52","-5.75"],"v":["0","1.2"],"l":1,"t":2},{"p":["150","-75"],"v":["0","9"],"l":0,"t":1},{"p":["152","-80"],"v":["0","10"],"l":0,"t":1},{"p":["154","-85"],"v":["0","9.5"],"l":0,"t":1},{"p":["150","75"],"v":["0","-10"],"l":0,"t":1},{"p":["152","80"],"v":["0","-9"],"l":0,"t":1},{"p":["154","85"],"v":["0","-9.5"],"l":0,"t":1}],"l":447.535,"c":{"s":"5","sl":"20","lp":1},"v":1} },\n\n { name: "Chasing the peloton", data: {"p":[-708.1093,561.67222,-657.73649,701.46772,-531.30212,736.41613,-332.91517,708.663,-201.34176,611.01215,-80.04523,477.38232,22.75082,341.69385,147.66174,176.73622,253.02371,-15.01574,448.31828,-335.71836,495.60932,-544.40048],"s":[],"d":[{"p":["50","0.4"],"v":["15.5","-0.1"],"l":1,"t":1},{"p":["52","0.6"],"v":["15.7","-0.15"],"l":1,"t":1},{"p":["54","0.3"],"v":["15.3","-0.13"],"l":1,"t":1},{"p":["56","0.7"],"v":["15.2","-0.1"],"l":1,"t":1},{"p":["58","0.3"],"v":["15.8","-0.12"],"l":1,"t":1},{"p":["60","0.7"],"v":["15.6","-0.17"],"l":1,"t":1},{"p":["62","0.1"],"v":["15.4","-0.14"],"l":1,"t":1},{"p":["64","-0.1"],"v":["15.5","0.13"],"l":1,"t":1},{"p":["66","0.3"],"v":["15.3","-0.13"],"l":1,"t":1},{"p":["68","0"],"v":["15.6","0.15"],"l":1,"t":1},{"p":["70","-0.3"],"v":["15.8","0.17"],"l":1,"t":1},{"p":["72","-0.7"],"v":["15.7","0.12"],"l":1,"t":1},{"p":["74","-0.5"],"v":["15.1","0.15"],"l":1,"t":1},{"p":["76","-0.7"],"v":["15.9","0.11"],"l":1,"t":1},{"p":["78","-0.3"],"v":["15.5","0.16"],"l":1,"t":1},{"p":["80","-0.5"],"v":["15.6","0.13"],"l":1,"t":1}],"l":2018.213,"c":{"s":"15","sl":"25","lp":1},"v":1} }\n]);\n\n;// CONCATENATED MODULE: ./js/simulator/ScenarioManager.js\n\n\n\nconst ScenarioManager_LOCAL_STORAGE_KEY = \'dash_Scenarios\';\n\nclass ScenarioManager {\n constructor(editor) {\n this.editor = editor;\n this.modal = document.getElementById(\'scenarios-modal\');\n\n document.getElementById(\'scenarios-modal-background\').addEventListener(\'click\', this._closeModal.bind(this));\n document.getElementById(\'scenarios-modal-close\').addEventListener(\'click\', this._closeModal.bind(this));\n\n this.examplesTab = document.getElementById(\'scenarios-modal-examples-tab\');\n this.savedTab = document.getElementById(\'scenarios-modal-saved-tab\');\n this.importTab = document.getElementById(\'scenarios-modal-import-tab\');\n\n this.examplesTabButton = document.getElementById(\'scenarios-modal-examples-tab-button\');\n this.savedTabButton = document.getElementById(\'scenarios-modal-saved-tab-button\');\n this.importTabButton = document.getElementById(\'scenarios-modal-import-tab-button\');\n this.examplesTabButton.addEventListener(\'click\', e => this.switchTab(this.examplesTab));\n this.savedTabButton.addEventListener(\'click\', e => this.switchTab(this.savedTab));\n this.importTabButton.addEventListener(\'click\', e => this.switchTab(this.importTab));\n\n this.itemsContainer = document.getElementById(\'scenarios-modal-items\');\n\n this.sortName = document.getElementById(\'scenarios-sort-name\');\n this.sortName.addEventListener(\'click\', e => this._buildScenarioItems(\'name\'));\n this.sortSavedAt = document.getElementById(\'scenarios-sort-saved-at\');\n this.sortSavedAt.addEventListener(\'click\', e => this._buildScenarioItems(\'savedAt\'));\n\n this.importBox = document.getElementById(\'scenario-import-box\');\n this.importInfo = document.getElementById(\'scenario-import-info\');\n\n this.importBox.addEventListener(\'input\', this._importBoxChanged.bind(this));\n\n for (let i = 0; i < examples.length; i++)\n document.getElementById(`example-${i}`).addEventListener(\'click\', e => this._loadScenario(examples[i]));\n }\n\n switchTab(tab) {\n this.examplesTab.classList.add(\'is-hidden\')\n this.savedTab.classList.add(\'is-hidden\')\n this.importTab.classList.add(\'is-hidden\')\n this.examplesTabButton.classList.remove(\'is-active\');\n this.savedTabButton.classList.remove(\'is-active\');\n this.importTabButton.classList.remove(\'is-active\');\n\n let button = this.savedTabButton;\n if (tab == this.examplesTab)\n button = this.examplesTabButton;\n else if (tab == this.importTab)\n button = this.importTabButton;\n\n tab.classList.remove(\'is-hidden\');\n button.classList.add(\'is-active\');\n\n if (tab == this.importTab)\n this.importBox.focus();\n }\n\n saveScenario(name, data, force = false) {\n const scenarios = this.fetchScenarios();\n let scenario = scenarios[name];\n const now = new Date();\n\n if (scenario) {\n if (!force) return [false, scenario.savedAt];\n\n scenario.data = data;\n scenario.savedAt = now;\n } else {\n scenario = {\n name: name,\n data: data,\n savedAt: now\n };\n \n scenarios[name] = scenario;\n }\n\n const json = JSON.stringify(scenarios);\n window.localStorage.setItem(ScenarioManager_LOCAL_STORAGE_KEY, json);\n\n return [true, scenario.savedAt];\n }\n\n fetchScenarios() {\n const scenarios = JSON.parse(window.localStorage.getItem(ScenarioManager_LOCAL_STORAGE_KEY)) || {};\n\n for (const k in scenarios)\n scenarios[k].savedAt = new Date(scenarios[k].savedAt);\n\n return scenarios;\n }\n\n showModal(onLoadScenario = null) {\n this.onLoadScenario = onLoadScenario;\n\n this.modal.classList.add(\'is-active\');\n this.switchTab(this.savedTab);\n\n this._buildScenarioItems();\n this.itemsContainer.scrollTop = 0;\n \n this.importBox.value = \'\';\n this.importBox.dispatchEvent(new Event(\'input\'));\n }\n\n _closeModal() {\n this.onLoadScenario = null;\n this.modal.classList.remove(\'is-active\');\n }\n\n _buildScenarioItems(sort = \'savedAt\') {\n this.itemsContainer.innerHTML = \'\';\n\n this.sortName.classList.remove(\'is-underlined\');\n this.sortSavedAt.classList.remove(\'is-underlined\');\n if (sort == \'name\')\n this.sortName.classList.add(\'is-underlined\');\n else if (sort == \'savedAt\')\n this.sortSavedAt.classList.add(\'is-underlined\');\n\n const scenarios = Object.values(this.fetchScenarios());\n\n if (scenarios.length == 0) {\n this._showEmptyMessage();\n } else {\n scenarios.sort((a, b) => {\n if (sort == \'savedAt\') {\n if (a.savedAt < b.savedAt) return +1;\n else if (b.savedAt < a.savedAt) return -1;\n }\n\n const nameA = a.name.toLowerCase();\n const nameB = b.name.toLowerCase();\n\n if (nameA < nameB) return -1;\n if (nameB < nameA) return +1;\n return 0;\n });\n\n scenarios.forEach(s => this._addScenarioItem(s));\n }\n }\n\n _showEmptyMessage() {\n this.itemsContainer.innerHTML = "You don\'t have any saved scenarios.";\n }\n\n _addScenarioItem(scenario) {\n const html =\n `
\n
\n
\n
\n
\n

\n \n \n \n \n \n

\n
\n
\n
`;\n\n const template = document.createElement(\'template\');\n template.innerHTML = html;\n const item = template.content.firstChild;\n\n const nameDom = item.getElementsByClassName(\'scenario-item-name\')[0];\n nameDom.textContent = scenario.name;\n nameDom.title = scenario.name;\n\n item.getElementsByClassName(\'scenario-item-saved-at\')[0].textContent = formatDate(scenario.savedAt);\n\n item.getElementsByClassName(\'scenario-item-load\')[0].addEventListener(\'click\', e => this._loadScenario(scenario));\n\n item.getElementsByClassName(\'scenario-item-delete\')[0].addEventListener(\'click\', e => {\n if (window.confirm(`Are you sure you want to delete the scenario "${scenario.name}"?`)) {\n this._deleteScenario(scenario);\n this.itemsContainer.removeChild(item);\n\n if (this.itemsContainer.children.length == 0)\n this._showEmptyMessage();\n }\n });\n\n this.itemsContainer.appendChild(item);\n }\n\n _loadScenario(scenario) {\n this.editor.loadJSON(scenario.data);\n this.editor.updateSavedInfo(scenario.name, formatDate(scenario.savedAt));\n\n if (this.onLoadScenario) this.onLoadScenario();\n\n this._closeModal();\n }\n\n _deleteScenario(scenario) {\n const scenarios = this.fetchScenarios();\n delete scenarios[scenario.name];\n\n const json = JSON.stringify(scenarios);\n window.localStorage.setItem(ScenarioManager_LOCAL_STORAGE_KEY, json);\n }\n\n _importBoxChanged() {\n this.importBox.classList.remove(\'is-danger\');\n this.importInfo.classList.add(\'is-hidden\');\n\n const encoded = this.importBox.value;\n\n if (encoded != \'\') {\n try {\n const json = JSON.parse(atob(this.importBox.value));\n\n if (json.s === undefined || json.d === undefined || json.p === undefined || json.p.length % 2 != 0)\n throw new Error();\n\n this.importInfo.innerHTML = `\n
\n Road Length: ${json.l.toLocaleString(undefined, { minimumFractionDigits: 1, maximumFractionDigits: 1 })}m\n
\n  \n
\n Static Obstacles: ${json.s.length}\n
\n  \n
\n Dynamic Obstacles: ${json.d.length}\n
\n
\n \n \n \n Import\n
\n `;\n\n this.importInfo.getElementsByClassName(\'scenario-import-button\')[0].addEventListener(\'click\', e => this._loadScenario({ data: json }));\n this.importInfo.classList.remove(\'is-hidden\');\n } catch (e) {\n this.importBox.classList.add(\'is-danger\');\n }\n }\n }\n}\n\n;// CONCATENATED MODULE: ./js/simulator/ShareManager.js\nclass ShareManager {\n constructor() {\n this.modal = document.getElementById(\'scenario-share-modal\');\n this.linkDom = document.getElementById(\'scenario-share-link\');\n this.boxDom = document.getElementById(\'scenario-share-box\');\n this.clipboardButton = document.getElementById(\'scenario-share-clipboard\');\n this.clipboardIcon = document.getElementById(\'scenario-share-clipboard-icon\');\n this.clipboardSuccessIcon = document.getElementById(\'scenario-share-clipboard-success-icon\');\n\n document.getElementById(\'scenario-share-modal-background\').addEventListener(\'click\', this._closeModal.bind(this));\n document.getElementById(\'scenario-share-modal-close\').addEventListener(\'click\', this._closeModal.bind(this));\n this.clipboardButton.addEventListener(\'click\', this._copyLinkToClipboard.bind(this));\n\n this.linkDom.addEventListener(\'focus\', e => this.linkDom.select());\n this.boxDom.addEventListener(\'focus\', e => this.boxDom.select());\n }\n\n showModal(scenario) {\n this.modal.classList.add(\'is-active\');\n\n this.clipboardIcon.classList.remove(\'is-hidden\');\n this.clipboardSuccessIcon.classList.add(\'is-hidden\');\n this.clipboardButton.classList.remove(\'is-success\');\n\n const code = btoa(JSON.stringify(scenario));\n\n const url = new URL(window.location);\n url.search = \'\';\n url.hash = \'/s/\' + encodeURIComponent(code);\n\n this.linkDom.value = url.href;\n this.boxDom.value = code;\n }\n\n _closeModal() {\n this.modal.classList.remove(\'is-active\');\n }\n\n _copyLinkToClipboard() {\n this.linkDom.focus();\n this.linkDom.select();\n\n if (document.execCommand(\'copy\', false, null)) {\n this.clipboardIcon.classList.add(\'is-hidden\');\n this.clipboardSuccessIcon.classList.remove(\'is-hidden\');\n this.clipboardButton.classList.add(\'is-success\');\n }\n }\n}\n\n;// CONCATENATED MODULE: ./js/simulator/Editor.js\n\n\n\n\n\n\n\nconst GROUND_PLANE = new THREE.Plane(new THREE.Vector3(0, 1, 0));\n\nconst NORMAL_OPACITY = 0.7;\nconst HOVER_OPACITY = 1;\nconst NORMAL_POINT_COLOR = 0x0088ff;\nconst HOVER_POINT_COLOR = 0x33ccff;\nconst NORMAL_STATIC_OBSTACLE_COLOR = 0xdd0000;\nconst HOVER_STATIC_OBSTACLE_COLOR = 0xdd3333;\nconst NORMAL_DYNAMIC_OBSTACLE_COLOR = 0xff8800;\nconst HOVER_DYNAMIC_OBSTACLE_COLOR = 0xffcc33;\n\nconst INITIAL_SPEED_FALLBACK = 20;\nconst SPEED_LIMIT_FALLBACK = 20;\nconst LANE_PREFERENCE_FALLBACK = +1;\n\nclass Editor {\n constructor(canvas, camera, scene) {\n this.canvas = canvas;\n this.camera = camera;\n\n this.isEnabled = false;\n this.raycaster = new THREE.Raycaster();\n this.mouse = new THREE.Vector2();\n this.dragOffset = new THREE.Vector3();\n this.draggingPoint = null;\n this.pointIndex = 0;\n this.obstacleIndex = 0;\n this.previousSavedName = null;\n this.scenarioManager = new ScenarioManager(this);\n this.shareManager = new ShareManager();\n\n this.centerlineGeometry = new THREE.Geometry();\n this.leftBoundaryGeometry = new THREE.Geometry();\n this.rightBoundaryGeometry = new THREE.Geometry();\n this.draggingObstaclePreview = null;\n\n this.group = new THREE.Group();\n this.group.renderOrder = 1;\n this.pointGroup = new THREE.Group();\n this.pointGroup.renderOrder = 2;\n this.obstacleGroup = new THREE.Group();\n this.obstacleGroup.renderOrder = 1;\n this.group.add(this.obstacleGroup);\n this.group.add(this.pointGroup);\n scene.add(this.group);\n\n this.lanePath = new LanePath();\n this.dynamicObstacleEditor = new DynamicObstacleEditor();\n\n this.editorPathButton = document.getElementById(\'editor-path\');\n this.editorPathButton.addEventListener(\'click\', e => this.changeEditMode(\'path\'));\n this.editorObstaclesButton = document.getElementById(\'editor-obstacles\');\n this.editorObstaclesButton.addEventListener(\'click\', e => this.changeEditMode(\'staticObstacles\'));\n this.editorDynamicObstaclesButton = document.getElementById(\'editor-dynamic-obstacles\');\n this.editorDynamicObstaclesButton.addEventListener(\'click\', e => this.changeEditMode(\'dynamicObstacles\'));\n\n this.editorRoadBox = document.getElementById(\'editor-road-box\');\n this.initialSpeedDom = document.getElementById(\'editor-initial-speed\');\n this.speedLimitDom = document.getElementById(\'editor-speed-limit\');\n this.laneLeftDom = document.getElementById(\'editor-lane-left\');\n this.laneRightDom = document.getElementById(\'editor-lane-right\');\n\n this.laneLeftDom.addEventListener(\'click\', e => this._changeLanePreference(-1));\n this.laneRightDom.addEventListener(\'click\', e => this._changeLanePreference(+1));\n\n this.initialSpeedDom.value = INITIAL_SPEED_FALLBACK;\n this.speedLimitDom.value = SPEED_LIMIT_FALLBACK;\n this._changeLanePreference(LANE_PREFERENCE_FALLBACK);\n\n this.statsRoadLength = document.getElementById(\'editor-stats-road-length\');\n this.statsStaticObstacles = document.getElementById(\'editor-stats-static-obstacles\');\n this.statsStation = document.getElementById(\'editor-stats-station\');\n this.statsLatitude = document.getElementById(\'editor-stats-latitude\');\n this.scenarioNameDom = document.getElementById(\'editor-scenario-name\');\n this.scenarioSavedAtDom = document.getElementById(\'editor-scenario-saved-at\');\n\n this.helpPath = document.getElementById(\'editor-help-path\');\n this.helpStaticObstacles = document.getElementById(\'editor-help-static-obstacles\');\n this.helpDynamicObstacles = document.getElementById(\'editor-help-dynamic-obstacles\');\n\n this.changeEditMode(\'path\');\n this.removeMode = false;\n\n canvas.addEventListener(\'mousedown\', this.mouseDown.bind(this));\n canvas.addEventListener(\'mousemove\', this.mouseMove.bind(this));\n canvas.addEventListener(\'mouseup\', this.mouseUp.bind(this));\n canvas.addEventListener(\'contextmenu\', e => this.isEnabled && e.preventDefault());\n\n const editorClearOptions = document.getElementById(\'editor-clear-options\');\n document.getElementById(\'editor-clear\').addEventListener(\'click\', event => {\n event.stopPropagation();\n editorClearOptions.classList.toggle(\'is-hidden\');\n });\n document.addEventListener(\'click\', () => editorClearOptions.classList.add(\'is-hidden\'));\n\n document.getElementById(\'editor-clear-obstacles\').addEventListener(\'click\', this.clearStaticObstacles.bind(this));\n document.getElementById(\'editor-clear-dynamic-obstacles\').addEventListener(\'click\', this.dynamicObstacleEditor.clearDynamicObstacles.bind(this.dynamicObstacleEditor));\n document.getElementById(\'editor-clear-path\').addEventListener(\'click\', this.clearPath.bind(this));\n document.getElementById(\'editor-clear-all\').addEventListener(\'click\', this.clearAll.bind(this));\n\n document.getElementById(\'editor-save\').addEventListener(\'click\', this.saveClicked.bind(this));\n document.getElementById(\'editor-load\').addEventListener(\'click\', this.loadClicked.bind(this));\n document.getElementById(\'editor-share\').addEventListener(\'click\', this.shareClicked.bind(this));\n\n document.addEventListener(\'keydown\', this.keyDown.bind(this));\n document.addEventListener(\'keyup\', this.keyUp.bind(this));\n\n const resolution = new THREE.Vector2(this.canvas.clientWidth, this.canvas.clientHeight);\n this.centerlineObject = new THREE.Mesh(\n new THREE.Geometry(),\n new MeshLineMaterial({\n color: new THREE.Color(0x004488),\n lineWidth: 8,\n resolution: resolution,\n sizeAttenuation: false,\n near: camera.near,\n far: camera.far,\n depthWrite: false\n })\n );\n this.centerlineObject.rotation.x = Math.PI / 2;\n this.centerlineObject.renderOrder = 1;\n this.group.add(this.centerlineObject);\n\n this.leftBoundaryObject = new THREE.Mesh(\n new THREE.Geometry(),\n new MeshLineMaterial({\n color: new THREE.Color(0xff40ff),\n lineWidth: 0.15,\n resolution: resolution,\n transparent: true,\n opacity: 0.7\n })\n );\n this.leftBoundaryObject.rotation.x = Math.PI / 2;\n this.leftBoundaryObject.renderOrder = 1;\n this.group.add(this.leftBoundaryObject);\n\n this.rightBoundaryObject = new THREE.Mesh(\n new THREE.Geometry(),\n new MeshLineMaterial({\n color: new THREE.Color(0xff40ff),\n lineWidth: 0.15,\n resolution: resolution,\n transparent: true,\n opacity: 0.7\n })\n );\n this.rightBoundaryObject.rotation.x = Math.PI / 2;\n this.rightBoundaryObject.renderOrder = 1;\n this.group.add(this.rightBoundaryObject);\n\n window.addEventListener(\'resize\', () => {\n // Use setTimeout to queue the resolution update after the canvas is reflowed.\n // This gets around some weirdness noticed when opening and closing Chrome Developer Tools.\n setTimeout(() => {\n const resolution = new THREE.Vector2(this.canvas.clientWidth, this.canvas.clientHeight);\n this.centerlineObject.material.uniforms.resolution.value = resolution;\n this.leftBoundaryObject.material.uniforms.resolution.value = resolution;\n this.rightBoundaryObject.material.uniforms.resolution.value = resolution;\n }, 0);\n });\n }\n\n get enabled() {\n return this.isEnabled;\n }\n\n set enabled(e) {\n this.isEnabled = e;\n this.pointGroup.visible = this.obstacleGroup.visible = !!this.isEnabled\n }\n\n get staticObstacles() {\n return this.obstacleGroup.children.map(o => new StaticObstacle(new THREE.Vector2(o.position.x, o.position.z), -o.rotation.z, o.userData.width, o.userData.height));\n }\n\n get dynamicObstacles() {\n return this.dynamicObstacleEditor.collectDynamicObstacles();\n }\n\n get initialSpeed() {\n let speed = parseFloat(this.initialSpeedDom.value);\n if (Number.isNaN(speed) || speed < 0)\n speed = 0;\n\n return Number.isNaN(speed) || speed < 0 ? INITIAL_SPEED_FALLBACK : speed;\n }\n\n get speedLimit() {\n let limit = parseFloat(this.speedLimitDom.value);\n if (Number.isNaN(limit) || limit < 0)\n limit = 0;\n\n return Number.isNaN(limit) || limit < 0 ? SPEED_LIMIT_FALLBACK : limit;\n }\n\n scenarioToJSON() {\n const trunc = n => +n.toFixed(5);\n\n const json = {\n p: Array.prototype.concat.apply([], this.lanePath.anchors.map(a => [trunc(a.x), trunc(a.y)])),\n s: this.staticObstacles.map(o => o.toJSON()),\n d: this.dynamicObstacleEditor.toJSON(),\n l: Number(this.lanePath.arcLength.toFixed(3)),\n c: {\n s: this.initialSpeedDom.value,\n sl: this.speedLimitDom.value,\n lp: this.lanePreference\n },\n v: 1\n };\n\n return json;\n }\n\n loadJSON(json) {\n if (json.p === undefined || json.p.length % 2 != 0) {\n throw new Error(\'Incomplete lane path.\');\n }\n\n this.clearAll();\n\n this.lanePath = new LanePath();\n for (let i = 0; i < json.p.length; i += 2) {\n this.addPoint(new THREE.Vector2(json.p[i], json.p[i + 1]), false);\n }\n this.lanePath.resampleAll();\n this.rebuildPathGeometry();\n\n json.s.forEach(o => {\n const staticObstacle = StaticObstacle.fromJSON(o);\n this.addStaticObstacle(new THREE.Vector3(staticObstacle.pos.x, 0, staticObstacle.pos.y), staticObstacle.width, staticObstacle.height, staticObstacle.rot)\n });\n\n this.dynamicObstacleEditor.loadJSON(json.d);\n\n let initialSpeed = INITIAL_SPEED_FALLBACK;\n let speedLimit = SPEED_LIMIT_FALLBACK;\n try { initialSpeed = json.c.s; } catch (e) { }\n try { speedLimit = json.c.sl; } catch (e) { }\n\n this.initialSpeedDom.value = initialSpeed;\n this.speedLimitDom.value = speedLimit;\n\n let lanePreference = LANE_PREFERENCE_FALLBACK;\n try {\n if (typeof(json.c.lp) === \'number\')\n lanePreference = Math.sign(json.c.lp) || LANE_PREFERENCE_FALLBACK;\n } catch (e) { }\n\n this._changeLanePreference(lanePreference);\n }\n\n update() {\n if (!this.isEnabled) return;\n\n this.raycaster.setFromCamera(this.mouse, this.camera);\n const intersection = this.raycaster.ray.intersectPlane(GROUND_PLANE);\n\n const [station, latitude, _around] = this.lanePath.stationLatitudeFromPosition(new THREE.Vector2(intersection.x, intersection.z));\n this.statsStation.textContent = (station || 0).toFixed(1);\n this.statsLatitude.textContent = (latitude || 0).toFixed(1);\n\n if (this.draggingPoint) {\n if (intersection != null) {\n this.updatePoint(this.draggingPoint, intersection.clone().add(this.dragOffset));\n this.rebuildPathGeometry();\n }\n } else if (this.draggingObstacle) {\n if (intersection !== null) {\n if (this.draggingObstacle === true) {\n if (this.draggingObstaclePreview) this.group.remove(this.draggingObstaclePreview);\n\n const [center, width, height] = this._dimensionsFromRect(this.dragOffset, intersection);\n\n this.draggingObstaclePreview = new THREE.Mesh(\n new THREE.PlaneGeometry(width, height),\n new THREE.MeshBasicMaterial({ color: NORMAL_STATIC_OBSTACLE_COLOR, depthTest: false, transparent: true, opacity: 0.4 })\n );\n this.draggingObstaclePreview.rotation.x = -Math.PI / 2;\n this.draggingObstaclePreview.position.copy(center);\n this.group.add(this.draggingObstaclePreview);\n } else {\n this.draggingObstacle.position.copy(intersection.clone().add(this.dragOffset));\n }\n }\n } else if (this.rotatingObstacle) {\n const rotation = (this.dragOffset.x - this.mouse.x) * 2 * Math.PI;\n this.rotatingObstacle.rotation.z = Math.wrapAngle(rotation + this.initialObstacleRotation);\n } else {\n this.pointGroup.children.forEach(p => {\n p.material.color.set(NORMAL_POINT_COLOR)\n p.material.opacity = NORMAL_OPACITY;\n });\n\n this.obstacleGroup.children.forEach(o => {\n o.material.color.set(NORMAL_STATIC_OBSTACLE_COLOR)\n o.material.opacity = NORMAL_OPACITY;\n });\n\n this.canvas.classList.remove(\'editor-grab\', \'editor-grabbing\', \'editor-removing\');\n\n if (this.editMode == \'path\' && this.pointGroup.children.length > 0) {\n let picked = null;\n this.raycaster.intersectObjects(this.pointGroup.children).forEach(p => {\n if (picked === null || p.object.userData.index > picked.object.userData.index) picked = p;\n });\n\n if (picked) {\n picked.object.material.color.set(HOVER_POINT_COLOR);\n picked.object.material.opacity = HOVER_OPACITY;\n\n if (this.removeMode)\n this.canvas.classList.add(\'editor-removing\');\n else\n this.canvas.classList.add(\'editor-grab\');\n }\n } else if (this.editMode == \'staticObstacles\' && this.obstacleGroup.children.length > 0) {\n let picked = null;\n this.raycaster.intersectObjects(this.obstacleGroup.children).forEach(o => {\n if (picked === null || o.object.userData.index > picked.object.userData.index) picked = o;\n });\n\n if (picked) {\n picked.object.material.color.set(HOVER_STATIC_OBSTACLE_COLOR);\n picked.object.material.opacity = HOVER_OPACITY;\n\n if (this.removeMode)\n this.canvas.classList.add(\'editor-removing\');\n else\n this.canvas.classList.add(\'editor-grab\');\n }\n }\n }\n }\n\n changeEditMode(mode) {\n this.editorPathButton.classList.add(\'is-outlined\');\n this.editorObstaclesButton.classList.add(\'is-outlined\');\n this.editorDynamicObstaclesButton.classList.add(\'is-outlined\');\n this.editorPathButton.classList.remove(\'is-selected\');\n this.editorObstaclesButton.classList.remove(\'is-selected\');\n this.editorDynamicObstaclesButton.classList.remove(\'is-selected\');\n this.editorRoadBox.classList.add(\'is-hidden\');\n this.helpPath.classList.add(\'is-hidden\');\n this.helpStaticObstacles.classList.add(\'is-hidden\');\n this.helpDynamicObstacles.classList.add(\'is-hidden\');\n\n if (mode == \'path\') {\n this.editMode = \'path\';\n this.editorPathButton.classList.remove(\'is-outlined\');\n this.editorPathButton.classList.add(\'is-selected\');\n this.editorRoadBox.classList.remove(\'is-hidden\');\n this.helpPath.classList.remove(\'is-hidden\');\n this.dynamicObstacleEditor.disable();\n } else if (mode == \'staticObstacles\') {\n this.editMode = \'staticObstacles\';\n this.editorObstaclesButton.classList.remove(\'is-outlined\');\n this.editorObstaclesButton.classList.add(\'is-selected\');\n this.helpStaticObstacles.classList.remove(\'is-hidden\');\n this.dynamicObstacleEditor.disable();\n } else {\n this.editMode = \'dynamicObstacles\';\n this.editorDynamicObstaclesButton.classList.remove(\'is-outlined\');\n this.editorDynamicObstaclesButton.classList.add(\'is-selected\');\n this.helpDynamicObstacles.classList.remove(\'is-hidden\');\n this.dynamicObstacleEditor.enable();\n }\n }\n\n addStaticObstacle(center, width, height, rotation = 0) {\n const obstacle = new THREE.Mesh(\n new THREE.PlaneGeometry(width, height),\n new THREE.MeshBasicMaterial({ color: NORMAL_STATIC_OBSTACLE_COLOR, depthTest: false, transparent: true, opacity: NORMAL_OPACITY })\n );\n obstacle.rotation.x = -Math.PI / 2;\n obstacle.rotation.z = -Math.wrapAngle(rotation);\n obstacle.position.copy(center);\n obstacle.userData = { index: this.obstacleIndex++, width: width, height: height };\n\n this.obstacleGroup.add(obstacle);\n this.statsStaticObstacles.textContent = this.obstacleGroup.children.length;\n }\n\n removeStaticObstacle(obstacle) {\n this.obstacleGroup.remove(obstacle);\n this.statsStaticObstacles.textContent = this.obstacleGroup.children.length;\n }\n\n clearStaticObstacles() {\n this.group.remove(this.obstacleGroup);\n this.obstacleGroup = new THREE.Group();\n this.obstacleGroup.renderOrder = 1;\n this.group.add(this.obstacleGroup);\n this.obstacleIndex = 0;\n this.statsStaticObstacles.textContent = 0;\n }\n\n clearAll() {\n this.clearPath();\n this.clearStaticObstacles();\n this.dynamicObstacleEditor.clearDynamicObstacles();\n }\n\n rebuildPathGeometry() {\n if (this.lanePath.anchors.length > 1) {\n this.centerlineGeometry.setFromPoints(this.lanePath.centerline);\n const centerline = new MeshLine();\n centerline.setGeometry(this.centerlineGeometry);\n this.centerlineObject.geometry = centerline.geometry;\n\n this.leftBoundaryGeometry.setFromPoints(this.lanePath.leftBoundary);\n const leftBoundary = new MeshLine();\n leftBoundary.setGeometry(this.leftBoundaryGeometry);\n this.leftBoundaryObject.geometry = leftBoundary.geometry;\n\n this.rightBoundaryGeometry.setFromPoints(this.lanePath.rightBoundary);\n const rightBoundary = new MeshLine();\n rightBoundary.setGeometry(this.rightBoundaryGeometry);\n this.rightBoundaryObject.geometry = rightBoundary.geometry;\n } else {\n this.centerlineObject.geometry.dispose();\n this.centerlineObject.geometry = new THREE.Geometry();\n\n this.leftBoundaryObject.geometry.dispose();\n this.leftBoundaryObject.geometry = new THREE.Geometry();\n\n this.rightBoundaryObject.geometry.dispose();\n this.rightBoundaryObject.geometry = new THREE.Geometry();\n }\n\n this.statsRoadLength.textContent = this.lanePath.arcLength.toLocaleString(undefined, { minimumFractionDigits: 1, maximumFractionDigits: 1 });\n }\n\n addPoint(pos, resample = true) {\n const point = new THREE.Mesh(\n new THREE.CircleGeometry(1, 32),\n new THREE.MeshBasicMaterial({\n color: NORMAL_POINT_COLOR,\n depthTest: false,\n transparent: true,\n opacity: NORMAL_OPACITY\n })\n );\n point.rotation.x = -Math.PI / 2;\n point.position.set(pos.x, 0, pos.y);\n point.userData = { index: this.pointIndex++ };\n\n this.lanePath.addAnchor(pos, resample);\n this.pointGroup.add(point);\n\n return point;\n }\n\n updatePoint(object, pos) {\n object.position.copy(pos);\n this.lanePath.updateAnchor(object.userData.index, new THREE.Vector2(pos.x, pos.z));\n }\n\n removePoint(object) {\n const index = object.userData.index;\n\n this.pointGroup.remove(object);\n this.pointGroup.children.forEach(p => {\n if (p.userData.index > index) p.userData.index--;\n });\n this.pointIndex--;\n\n this.lanePath.removeAnchor(index);\n }\n\n clearPath() {\n this.group.remove(this.pointGroup);\n this.pointGroup = new THREE.Group();\n this.pointGroup.renderOrder = 2;\n this.group.add(this.pointGroup);\n this.pointIndex = 0;\n\n this.lanePath = new LanePath();\n this.rebuildPathGeometry();\n\n this.initialSpeedDom.value = INITIAL_SPEED_FALLBACK;\n this.speedLimitDom.value = SPEED_LIMIT_FALLBACK;\n }\n\n keyDown(event) {\n if (event.repeat || this.editMode != \'path\' && this.editMode != \'staticObstacles\') return;\n\n if (event.key == \'Shift\') {\n this.removeMode = true;\n this.canvas.classList.add(\'editor-pointing\');\n event.preventDefault();\n } else if (event.key == \'Control\' && this.editMode == \'staticObstacles\') {\n this.rotateMode = true;\n this.canvas.classList.add(\'editor-pointing\');\n event.preventDefault();\n }\n }\n\n keyUp(event) {\n if (event.key == \'Shift\') {\n this.removeMode = false;\n this.canvas.classList.remove(\'editor-pointing\', \'editor-removing\');\n } else if (event.key == \'Control\') {\n this.rotateMode = false;\n this.canvas.classList.remove(\'editor-pointing\', \'editor-grabbing\');\n }\n }\n\n mouseDown(event) {\n if (!this.isEnabled || event.button != 0) return;\n\n this.mouse.x = (event.offsetX / this.canvas.clientWidth) * 2 - 1;\n this.mouse.y = -(event.offsetY / this.canvas.clientHeight) * 2 + 1;\n\n this.raycaster.setFromCamera(this.mouse, this.camera);\n\n if (this.editMode == \'path\') {\n let picked = null;\n this.raycaster.intersectObjects(this.pointGroup.children).forEach(p => {\n if (picked === null || p.object.userData.index > picked.object.userData.index) picked = p;\n });\n\n if (picked) {\n if (this.removeMode) {\n this.removePoint(picked.object);\n this.rebuildPathGeometry();\n } else {\n this.canvas.classList.remove(\'editor-grab\');\n this.canvas.classList.add(\'editor-grabbing\');\n\n this.draggingPoint = picked.object;\n this.dragOffset.copy(picked.object.position).sub(picked.point);\n }\n } else if (!this.removeMode) {\n const intersection = this.raycaster.ray.intersectPlane(GROUND_PLANE);\n if (intersection != null) {\n this.addPoint(new THREE.Vector2(intersection.x, intersection.z));\n this.rebuildPathGeometry();\n }\n }\n } else if (this.editMode == \'staticObstacles\') {\n let picked = null;\n this.raycaster.intersectObjects(this.obstacleGroup.children).forEach(o => {\n if (picked === null || o.object.userData.index > picked.object.userData.index) picked = o;\n });\n\n if (picked) {\n if (this.removeMode) {\n this.removeStaticObstacle(picked.object);\n } else {\n this.canvas.classList.remove(\'editor-grab\');\n this.canvas.classList.add(\'editor-grabbing\');\n\n if (this.rotateMode) {\n this.rotatingObstacle = picked.object;\n this.initialObstacleRotation = picked.object.rotation.z;\n this.dragOffset.set(this.mouse.x, this.mouse.y, 0);\n } else {\n this.draggingObstacle = picked.object;\n this.dragOffset.copy(picked.object.position).sub(picked.point);\n }\n }\n } else if (!this.removeMode && !this.rotateMode) {\n const intersection = this.raycaster.ray.intersectPlane(GROUND_PLANE);\n if (intersection != null) {\n this.draggingObstacle = true;\n this.dragOffset.copy(intersection);\n }\n }\n }\n }\n\n mouseMove(event) {\n this.mouse.x = (event.offsetX / this.canvas.clientWidth) * 2 - 1;\n this.mouse.y = -(event.offsetY / this.canvas.clientHeight) * 2 + 1;\n }\n\n mouseUp(event) {\n if (!this.isEnabled || event.button != 0) return;\n\n if (this.draggingObstacle === true) {\n this.group.remove(this.draggingObstaclePreview);\n this.draggingObstaclePreview = null;\n\n this.mouse.x = (event.offsetX / this.canvas.clientWidth) * 2 - 1;\n this.mouse.y = -(event.offsetY / this.canvas.clientHeight) * 2 + 1;\n\n this.raycaster.setFromCamera(this.mouse, this.camera);\n\n const intersection = this.raycaster.ray.intersectPlane(GROUND_PLANE);\n if (intersection != null) {\n const [center, width, height] = this._dimensionsFromRect(this.dragOffset, intersection);\n this.addStaticObstacle(center, width, height);\n }\n }\n\n this.draggingPoint = null;\n this.draggingObstacle = null;\n this.rotatingObstacle = null;\n this.canvas.classList.remove(\'editor-grab\', \'editor-grabbing\');\n }\n\n updateSavedInfo(name, savedAt) {\n this.previousSavedName = name || null;\n\n name = name || \'Untitled\';\n savedAt = savedAt || \'Unsaved\';\n\n this.scenarioNameDom.textContent = name;\n this.scenarioNameDom.title = name;\n this.scenarioSavedAtDom.textContent = savedAt;\n }\n\n _changeLanePreference(pref) {\n this.lanePreference = pref;\n\n if (pref > 0) {\n this.laneLeftDom.classList.add(\'is-outlined\');\n this.laneLeftDom.classList.remove(\'is-selected\');\n this.laneRightDom.classList.remove(\'is-outlined\');\n this.laneRightDom.classList.add(\'is-selected\');\n } else {\n this.laneRightDom.classList.add(\'is-outlined\');\n this.laneRightDom.classList.remove(\'is-selected\');\n this.laneLeftDom.classList.remove(\'is-outlined\');\n this.laneLeftDom.classList.add(\'is-selected\');\n }\n }\n\n saveClicked() {\n const name = window.prompt(\'Name your scenario:\', this.previousSavedName || \'\');\n if (name === null) return;\n if (name === \'\') {\n window.alert(\'The scenario name cannot be blank.\');\n return;\n }\n\n let [success, savedAt] = this.scenarioManager.saveScenario(name, this.scenarioToJSON(), name === this.previousSavedName);\n const formattedSavedAt = formatDate(savedAt);\n\n if (success) {\n this.updateSavedInfo(name, formattedSavedAt);\n } else if (confirm(`A scenario named "${name}" already exists, last saved ${formattedSavedAt}. Do you want to overwrite it?`)) {\n [success, savedAt] = this.scenarioManager.saveScenario(name, this.scenarioToJSON(), true);\n this.updateSavedInfo(name, formatDate(savedAt));\n }\n }\n\n loadClicked() {\n this.scenarioManager.showModal();\n }\n\n shareClicked() {\n this.shareManager.showModal(this.scenarioToJSON());\n }\n\n _dimensionsFromRect(from, to) {\n const center = from.clone().add(to).divideScalar(2);\n const width = Math.max(0.5, Math.abs(from.x - to.x));\n const height = Math.max(0.5, Math.abs(from.z - to.z));\n return [center, width, height];\n }\n}\n\n;// CONCATENATED MODULE: ./js/simulator/OrbitControls.js\n/**\n * @author qiao / https://github.com/qiao\n * @author mrdoob / http://mrdoob.com\n * @author alteredq / http://alteredqualia.com/\n * @author WestLangley / http://github.com/WestLangley\n * @author erich666 / http://erichaines.com\n */\n\n// This set of controls performs orbiting, dollying (zooming), and panning.\n// Unlike TrackballControls, it maintains the "up" direction object.up (+Y by default).\n//\n// Orbit - left mouse / touch: one finger move\n// Zoom - middle mouse, or mousewheel / touch: two finger spread or squish\n// Pan - right mouse, or arrow keys / touch: three finger swipe\n\nconst OrbitControls = function ( object, domElement ) {\n\n\tthis.object = object;\n\n\tthis.domElement = ( domElement !== undefined ) ? domElement : document;\n\n\t// Set to false to disable this control\n\tthis.enabled = true;\n\n\t// "target" sets the location of focus, where the object orbits around\n\tthis.target = new THREE.Vector3();\n\n\t// How far you can dolly in and out ( PerspectiveCamera only )\n\tthis.minDistance = 0;\n\tthis.maxDistance = Infinity;\n\n\t// How far you can zoom in and out ( OrthographicCamera only )\n\tthis.minZoom = 0;\n\tthis.maxZoom = Infinity;\n\n\t// How far you can orbit vertically, upper and lower limits.\n\t// Range is 0 to Math.PI radians.\n\tthis.minPolarAngle = 0; // radians\n\tthis.maxPolarAngle = Math.PI; // radians\n\n\t// How far you can orbit horizontally, upper and lower limits.\n\t// If set, must be a sub-interval of the interval [ - Math.PI, Math.PI ].\n\tthis.minAzimuthAngle = - Infinity; // radians\n\tthis.maxAzimuthAngle = Infinity; // radians\n\n\t// Set to true to enable damping (inertia)\n\t// If damping is enabled, you must call controls.update() in your animation loop\n\tthis.enableDamping = false;\n\tthis.dampingFactor = 0.25;\n\n\t// This option actually enables dollying in and out; left as "zoom" for backwards compatibility.\n\t// Set to false to disable zooming\n\tthis.enableZoom = true;\n\tthis.zoomSpeed = 1.0;\n\n\t// Set to false to disable rotating\n\tthis.enableRotate = true;\n\tthis.rotateSpeed = 1.0;\n\n\t// Set to false to disable panning\n\tthis.enablePan = true;\n\tthis.keyPanSpeed = 7.0;\t// pixels moved per arrow key push\n\n\t// Set to true to automatically rotate around the target\n\t// If auto-rotate is enabled, you must call controls.update() in your animation loop\n\tthis.autoRotate = false;\n\tthis.autoRotateSpeed = 2.0; // 30 seconds per round when fps is 60\n\n\t// Set to false to disable use of the keys\n\tthis.enableKeys = true;\n\n\t// The four arrow keys\n\tthis.keys = { LEFT: 37, UP: 38, RIGHT: 39, BOTTOM: 40 };\n\n\t// Mouse buttons\n\tthis.mouseButtons = { ORBIT: THREE.MOUSE.LEFT, ZOOM: THREE.MOUSE.MIDDLE, PAN: THREE.MOUSE.RIGHT };\n\n\t// for reset\n\tthis.target0 = this.target.clone();\n\tthis.position0 = this.object.position.clone();\n\tthis.zoom0 = this.object.zoom;\n\n\t//\n\t// public methods\n\t//\n\n\tthis.getPolarAngle = function () {\n\n\t\treturn spherical.phi;\n\n\t};\n\n\tthis.getAzimuthalAngle = function () {\n\n\t\treturn spherical.theta;\n\n\t};\n\n\tthis.saveState = function () {\n\n\t\tscope.target0.copy( scope.target );\n\t\tscope.position0.copy( scope.object.position );\n\t\tscope.zoom0 = scope.object.zoom;\n\n\t};\n\n\tthis.reset = function () {\n\n\t\tscope.target.copy( scope.target0 );\n\t\tscope.object.position.copy( scope.position0 );\n\t\tscope.object.zoom = scope.zoom0;\n\n\t\tscope.object.updateProjectionMatrix();\n\t\tscope.dispatchEvent( changeEvent );\n\n\t\tscope.update();\n\n\t\tstate = STATE.NONE;\n\n\t};\n\n this.rotateLeft = function(angle) {\n rotateLeft(angle);\n }\n\n\t// this method is exposed, but perhaps it would be better if we can make it private...\n\tthis.update = function () {\n\n\t\tvar offset = new THREE.Vector3();\n\n\t\t// so camera.up is the orbit axis\n\t\tvar quat = new THREE.Quaternion().setFromUnitVectors( object.up, new THREE.Vector3( 0, 1, 0 ) );\n\t\tvar quatInverse = quat.clone().inverse();\n\n\t\tvar lastPosition = new THREE.Vector3();\n\t\tvar lastQuaternion = new THREE.Quaternion();\n\n\t\treturn function update() {\n\n\t\t\tvar position = scope.object.position;\n\n\t\t\toffset.copy( position ).sub( scope.target );\n\n\t\t\t// rotate offset to "y-axis-is-up" space\n\t\t\toffset.applyQuaternion( quat );\n\n\t\t\t// angle from z-axis around y-axis\n\t\t\tspherical.setFromVector3( offset );\n\n\t\t\tif ( scope.autoRotate && state === STATE.NONE ) {\n\n\t\t\t\trotateLeft( getAutoRotationAngle() );\n\n\t\t\t}\n\n\t\t\tspherical.theta += sphericalDelta.theta;\n\t\t\tspherical.phi += sphericalDelta.phi;\n\n\t\t\t// restrict theta to be between desired limits\n\t\t\tspherical.theta = Math.max( scope.minAzimuthAngle, Math.min( scope.maxAzimuthAngle, spherical.theta ) );\n\n\t\t\t// restrict phi to be between desired limits\n\t\t\tspherical.phi = Math.max( scope.minPolarAngle, Math.min( scope.maxPolarAngle, spherical.phi ) );\n\n\t\t\tspherical.makeSafe();\n\n\n\t\t\tspherical.radius *= scale;\n\n\t\t\t// restrict radius to be between desired limits\n\t\t\tspherical.radius = Math.max( scope.minDistance, Math.min( scope.maxDistance, spherical.radius ) );\n\n\t\t\t// move target to panned location\n\t\t\tscope.target.add( panOffset );\n\n\t\t\toffset.setFromSpherical( spherical );\n\n\t\t\t// rotate offset back to "camera-up-vector-is-up" space\n\t\t\toffset.applyQuaternion( quatInverse );\n\n\t\t\tposition.copy( scope.target ).add( offset );\n\n\t\t\tscope.object.lookAt( scope.target );\n\n\t\t\tif ( scope.enableDamping === true ) {\n\n\t\t\t\tsphericalDelta.theta *= ( 1 - scope.dampingFactor );\n\t\t\t\tsphericalDelta.phi *= ( 1 - scope.dampingFactor );\n\n\t\t\t} else {\n\n\t\t\t\tsphericalDelta.set( 0, 0, 0 );\n\n\t\t\t}\n\n\t\t\tscale = 1;\n\t\t\tpanOffset.set( 0, 0, 0 );\n\n\t\t\t// update condition is:\n\t\t\t// min(camera displacement, camera rotation in radians)^2 > EPS\n\t\t\t// using small-angle approximation cos(x/2) = 1 - x^2 / 8\n\n\t\t\tif ( zoomChanged ||\n\t\t\t\tlastPosition.distanceToSquared( scope.object.position ) > EPS ||\n\t\t\t\t8 * ( 1 - lastQuaternion.dot( scope.object.quaternion ) ) > EPS ) {\n\n\t\t\t\tscope.dispatchEvent( changeEvent );\n\n\t\t\t\tlastPosition.copy( scope.object.position );\n\t\t\t\tlastQuaternion.copy( scope.object.quaternion );\n\t\t\t\tzoomChanged = false;\n\n\t\t\t\treturn true;\n\n\t\t\t}\n\n\t\t\treturn false;\n\n\t\t};\n\n\t}();\n\n\tthis.dispose = function () {\n\n\t\tscope.domElement.removeEventListener( \'contextmenu\', onContextMenu, false );\n\t\tscope.domElement.removeEventListener( \'mousedown\', onMouseDown, false );\n\t\tscope.domElement.removeEventListener( \'wheel\', onMouseWheel, false );\n\n\t\tscope.domElement.removeEventListener( \'touchstart\', onTouchStart, false );\n\t\tscope.domElement.removeEventListener( \'touchend\', onTouchEnd, false );\n\t\tscope.domElement.removeEventListener( \'touchmove\', onTouchMove, false );\n\n\t\tdocument.removeEventListener( \'mousemove\', onMouseMove, false );\n\t\tdocument.removeEventListener( \'mouseup\', onMouseUp, false );\n\n\t\twindow.removeEventListener( \'keydown\', onKeyDown, false );\n\n\t\t//scope.dispatchEvent( { type: \'dispose\' } ); // should this be added here?\n\n\t};\n\n\t//\n\t// internals\n\t//\n\n\tvar scope = this;\n\n\tvar changeEvent = { type: \'change\' };\n\tvar startEvent = { type: \'start\' };\n\tvar endEvent = { type: \'end\' };\n\n\tvar STATE = { NONE: - 1, ROTATE: 0, DOLLY: 1, PAN: 2, TOUCH_ROTATE: 3, TOUCH_DOLLY: 4, TOUCH_PAN: 5 };\n\n\tvar state = STATE.NONE;\n\n\tvar EPS = 0.000001;\n\n\t// current position in spherical coordinates\n\tvar spherical = new THREE.Spherical();\n\tvar sphericalDelta = new THREE.Spherical();\n\n\tvar scale = 1;\n\tvar panOffset = new THREE.Vector3();\n\tvar zoomChanged = false;\n\n\tvar rotateStart = new THREE.Vector2();\n\tvar rotateEnd = new THREE.Vector2();\n\tvar rotateDelta = new THREE.Vector2();\n\n\tvar panStart = new THREE.Vector2();\n\tvar panEnd = new THREE.Vector2();\n\tvar panDelta = new THREE.Vector2();\n\n\tvar dollyStart = new THREE.Vector2();\n\tvar dollyEnd = new THREE.Vector2();\n\tvar dollyDelta = new THREE.Vector2();\n\n\tfunction getAutoRotationAngle() {\n\n\t\treturn 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;\n\n\t}\n\n\tfunction getZoomScale() {\n\n\t\treturn Math.pow( 0.95, scope.zoomSpeed );\n\n\t}\n\n\tfunction rotateLeft( angle ) {\n\n\t\tsphericalDelta.theta -= angle;\n\n\t}\n\n\tfunction rotateUp( angle ) {\n\n\t\tsphericalDelta.phi -= angle;\n\n\t}\n\n\tvar panLeft = function () {\n\n\t\tvar v = new THREE.Vector3();\n\n\t\treturn function panLeft( distance, objectMatrix ) {\n\n\t\t\tv.setFromMatrixColumn( objectMatrix, 0 ); // get X column of objectMatrix\n\t\t\tv.multiplyScalar( - distance );\n\n\t\t\tpanOffset.add( v );\n\n\t\t};\n\n\t}();\n\n\tvar panUp = function () {\n\n\t\tvar v = new THREE.Vector3();\n\n\t\treturn function panUp( distance, objectMatrix ) {\n\n\t\t\tv.setFromMatrixColumn( objectMatrix, 1 ); // get Y column of objectMatrix\n\t\t\tv.multiplyScalar( distance );\n\n\t\t\tpanOffset.add( v );\n\n\t\t};\n\n\t}();\n\n\t// deltaX and deltaY are in pixels; right and down are positive\n\tvar pan = function () {\n\n\t\tvar offset = new THREE.Vector3();\n\n\t\treturn function pan( deltaX, deltaY ) {\n\n\t\t\tvar element = scope.domElement === document ? scope.domElement.body : scope.domElement;\n\n\t\t\tif ( scope.object.isPerspectiveCamera ) {\n\n\t\t\t\t// perspective\n\t\t\t\tvar position = scope.object.position;\n\t\t\t\toffset.copy( position ).sub( scope.target );\n\t\t\t\tvar targetDistance = offset.length();\n\n\t\t\t\t// half of the fov is center to top of screen\n\t\t\t\ttargetDistance *= Math.tan( ( scope.object.fov / 2 ) * Math.PI / 180.0 );\n\n\t\t\t\t// we actually don\'t use screenWidth, since perspective camera is fixed to screen height\n\t\t\t\tpanLeft( 2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix );\n\t\t\t\tpanUp( 2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix );\n\n\t\t\t} else if ( scope.object.isOrthographicCamera ) {\n\n\t\t\t\t// orthographic\n\t\t\t\tpanLeft( deltaX * ( scope.object.right - scope.object.left ) / scope.object.zoom / element.clientWidth, scope.object.matrix );\n\t\t\t\tpanUp( deltaY * ( scope.object.top - scope.object.bottom ) / scope.object.zoom / element.clientHeight, scope.object.matrix );\n\n\t\t\t} else {\n\n\t\t\t\t// camera neither orthographic nor perspective\n\t\t\t\tconsole.warn( \'WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.\' );\n\t\t\t\tscope.enablePan = false;\n\n\t\t\t}\n\n\t\t};\n\n\t}();\n\n\tfunction dollyIn( dollyScale ) {\n\n\t\tif ( scope.object.isPerspectiveCamera ) {\n\n\t\t\tscale /= dollyScale;\n\n\t\t} else if ( scope.object.isOrthographicCamera ) {\n\n\t\t\tscope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom * dollyScale ) );\n\t\t\tscope.object.updateProjectionMatrix();\n\t\t\tzoomChanged = true;\n\n\t\t} else {\n\n\t\t\tconsole.warn( \'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.\' );\n\t\t\tscope.enableZoom = false;\n\n\t\t}\n\n\t}\n\n\tfunction dollyOut( dollyScale ) {\n\n\t\tif ( scope.object.isPerspectiveCamera ) {\n\n\t\t\tscale *= dollyScale;\n\n\t\t} else if ( scope.object.isOrthographicCamera ) {\n\n\t\t\tscope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom / dollyScale ) );\n\t\t\tscope.object.updateProjectionMatrix();\n\t\t\tzoomChanged = true;\n\n\t\t} else {\n\n\t\t\tconsole.warn( \'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.\' );\n\t\t\tscope.enableZoom = false;\n\n\t\t}\n\n\t}\n\n\t//\n\t// event callbacks - update the object state\n\t//\n\n\tfunction handleMouseDownRotate( event ) {\n\n\t\t//console.log( \'handleMouseDownRotate\' );\n\n\t\trotateStart.set( event.clientX, event.clientY );\n\n\t}\n\n\tfunction handleMouseDownDolly( event ) {\n\n\t\t//console.log( \'handleMouseDownDolly\' );\n\n\t\tdollyStart.set( event.clientX, event.clientY );\n\n\t}\n\n\tfunction handleMouseDownPan( event ) {\n\n\t\t//console.log( \'handleMouseDownPan\' );\n\n\t\tpanStart.set( event.clientX, event.clientY );\n\n\t}\n\n\tfunction handleMouseMoveRotate( event ) {\n\n\t\t//console.log( \'handleMouseMoveRotate\' );\n\n\t\trotateEnd.set( event.clientX, event.clientY );\n\t\trotateDelta.subVectors( rotateEnd, rotateStart );\n\n\t\tvar element = scope.domElement === document ? scope.domElement.body : scope.domElement;\n\n\t\t// rotating across whole screen goes 360 degrees around\n\t\trotateLeft( 2 * Math.PI * rotateDelta.x / element.clientWidth * scope.rotateSpeed );\n\n\t\t// rotating up and down along whole screen attempts to go 360, but limited to 180\n\t\trotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight * scope.rotateSpeed );\n\n\t\trotateStart.copy( rotateEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleMouseMoveDolly( event ) {\n\n\t\t//console.log( \'handleMouseMoveDolly\' );\n\n\t\tdollyEnd.set( event.clientX, event.clientY );\n\n\t\tdollyDelta.subVectors( dollyEnd, dollyStart );\n\n\t\tif ( dollyDelta.y > 0 ) {\n\n\t\t\tdollyIn( getZoomScale() );\n\n\t\t} else if ( dollyDelta.y < 0 ) {\n\n\t\t\tdollyOut( getZoomScale() );\n\n\t\t}\n\n\t\tdollyStart.copy( dollyEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleMouseMovePan( event ) {\n\n\t\t//console.log( \'handleMouseMovePan\' );\n\n\t\tpanEnd.set( event.clientX, event.clientY );\n\n\t\tpanDelta.subVectors( panEnd, panStart );\n\n\t\tpan( panDelta.x, panDelta.y );\n\n\t\tpanStart.copy( panEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleMouseUp( event ) {\n\n\t\t// console.log( \'handleMouseUp\' );\n\n\t}\n\n\tfunction handleMouseWheel( event ) {\n\n\t\t// console.log( \'handleMouseWheel\' );\n\n\t\tif ( event.deltaY < 0 ) {\n\n\t\t\tdollyOut( getZoomScale() );\n\n\t\t} else if ( event.deltaY > 0 ) {\n\n\t\t\tdollyIn( getZoomScale() );\n\n\t\t}\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleKeyDown( event ) {\n\n\t\t//console.log( \'handleKeyDown\' );\n\n\t\tswitch ( event.keyCode ) {\n\n\t\t\tcase scope.keys.UP:\n\t\t\t\tpan( 0, scope.keyPanSpeed );\n\t\t\t\tscope.update();\n\t\t\t\tbreak;\n\n\t\t\tcase scope.keys.BOTTOM:\n\t\t\t\tpan( 0, - scope.keyPanSpeed );\n\t\t\t\tscope.update();\n\t\t\t\tbreak;\n\n\t\t\tcase scope.keys.LEFT:\n\t\t\t\tpan( scope.keyPanSpeed, 0 );\n\t\t\t\tscope.update();\n\t\t\t\tbreak;\n\n\t\t\tcase scope.keys.RIGHT:\n\t\t\t\tpan( - scope.keyPanSpeed, 0 );\n\t\t\t\tscope.update();\n\t\t\t\tbreak;\n\n\t\t}\n\n\t}\n\n\tfunction handleTouchStartRotate( event ) {\n\n\t\t//console.log( \'handleTouchStartRotate\' );\n\n\t\trotateStart.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );\n\n\t}\n\n\tfunction handleTouchStartDolly( event ) {\n\n\t\t//console.log( \'handleTouchStartDolly\' );\n\n\t\tvar dx = event.touches[ 0 ].pageX - event.touches[ 1 ].pageX;\n\t\tvar dy = event.touches[ 0 ].pageY - event.touches[ 1 ].pageY;\n\n\t\tvar distance = Math.sqrt( dx * dx + dy * dy );\n\n\t\tdollyStart.set( 0, distance );\n\n\t}\n\n\tfunction handleTouchStartPan( event ) {\n\n\t\t//console.log( \'handleTouchStartPan\' );\n\n\t\tpanStart.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );\n\n\t}\n\n\tfunction handleTouchMoveRotate( event ) {\n\n\t\t//console.log( \'handleTouchMoveRotate\' );\n\n\t\trotateEnd.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );\n\t\trotateDelta.subVectors( rotateEnd, rotateStart );\n\n\t\tvar element = scope.domElement === document ? scope.domElement.body : scope.domElement;\n\n\t\t// rotating across whole screen goes 360 degrees around\n\t\trotateLeft( 2 * Math.PI * rotateDelta.x / element.clientWidth * scope.rotateSpeed );\n\n\t\t// rotating up and down along whole screen attempts to go 360, but limited to 180\n\t\trotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight * scope.rotateSpeed );\n\n\t\trotateStart.copy( rotateEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleTouchMoveDolly( event ) {\n\n\t\t//console.log( \'handleTouchMoveDolly\' );\n\n\t\tvar dx = event.touches[ 0 ].pageX - event.touches[ 1 ].pageX;\n\t\tvar dy = event.touches[ 0 ].pageY - event.touches[ 1 ].pageY;\n\n\t\tvar distance = Math.sqrt( dx * dx + dy * dy );\n\n\t\tdollyEnd.set( 0, distance );\n\n\t\tdollyDelta.subVectors( dollyEnd, dollyStart );\n\n\t\tif ( dollyDelta.y > 0 ) {\n\n\t\t\tdollyOut( getZoomScale() );\n\n\t\t} else if ( dollyDelta.y < 0 ) {\n\n\t\t\tdollyIn( getZoomScale() );\n\n\t\t}\n\n\t\tdollyStart.copy( dollyEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleTouchMovePan( event ) {\n\n\t\t//console.log( \'handleTouchMovePan\' );\n\n\t\tpanEnd.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );\n\n\t\tpanDelta.subVectors( panEnd, panStart );\n\n\t\tpan( panDelta.x, panDelta.y );\n\n\t\tpanStart.copy( panEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleTouchEnd( event ) {\n\n\t\t//console.log( \'handleTouchEnd\' );\n\n\t}\n\n\t//\n\t// event handlers - FSM: listen for events and reset state\n\t//\n\n\tfunction onMouseDown( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\tevent.preventDefault();\n\n\t\tswitch ( event.button ) {\n\n\t\t\tcase scope.mouseButtons.ORBIT:\n\n\t\t\t\tif ( scope.enableRotate === false ) return;\n\n\t\t\t\thandleMouseDownRotate( event );\n\n\t\t\t\tstate = STATE.ROTATE;\n\n\t\t\t\tbreak;\n\n\t\t\tcase scope.mouseButtons.ZOOM:\n\n\t\t\t\tif ( scope.enableZoom === false ) return;\n\n\t\t\t\thandleMouseDownDolly( event );\n\n\t\t\t\tstate = STATE.DOLLY;\n\n\t\t\t\tbreak;\n\n\t\t\tcase scope.mouseButtons.PAN:\n\n\t\t\t\tif ( scope.enablePan === false ) return;\n\n\t\t\t\thandleMouseDownPan( event );\n\n\t\t\t\tstate = STATE.PAN;\n\n\t\t\t\tbreak;\n\n\t\t}\n\n\t\tif ( state !== STATE.NONE ) {\n\n\t\t\tdocument.addEventListener( \'mousemove\', onMouseMove, false );\n\t\t\tdocument.addEventListener( \'mouseup\', onMouseUp, false );\n\n\t\t\tscope.dispatchEvent( startEvent );\n\n\t\t}\n\n\t}\n\n\tfunction onMouseMove( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\tevent.preventDefault();\n\n\t\tswitch ( state ) {\n\n\t\t\tcase STATE.ROTATE:\n\n\t\t\t\tif ( scope.enableRotate === false ) return;\n\n\t\t\t\thandleMouseMoveRotate( event );\n\n\t\t\t\tbreak;\n\n\t\t\tcase STATE.DOLLY:\n\n\t\t\t\tif ( scope.enableZoom === false ) return;\n\n\t\t\t\thandleMouseMoveDolly( event );\n\n\t\t\t\tbreak;\n\n\t\t\tcase STATE.PAN:\n\n\t\t\t\tif ( scope.enablePan === false ) return;\n\n\t\t\t\thandleMouseMovePan( event );\n\n\t\t\t\tbreak;\n\n\t\t}\n\n\t}\n\n\tfunction onMouseUp( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\thandleMouseUp( event );\n\n\t\tdocument.removeEventListener( \'mousemove\', onMouseMove, false );\n\t\tdocument.removeEventListener( \'mouseup\', onMouseUp, false );\n\n\t\tscope.dispatchEvent( endEvent );\n\n\t\tstate = STATE.NONE;\n\n\t}\n\n\tfunction onMouseWheel( event ) {\n\n\t\tif ( scope.enabled === false || scope.enableZoom === false || ( state !== STATE.NONE && state !== STATE.ROTATE ) ) return;\n\n\t\tevent.preventDefault();\n\t\tevent.stopPropagation();\n\n\t\thandleMouseWheel( event );\n\n\t\tscope.dispatchEvent( startEvent ); // not sure why these are here...\n\t\tscope.dispatchEvent( endEvent );\n\n\t}\n\n\tfunction onKeyDown( event ) {\n\n\t\tif ( scope.enabled === false || scope.enableKeys === false || scope.enablePan === false ) return;\n\n\t\thandleKeyDown( event );\n\n\t}\n\n\tfunction onTouchStart( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\tswitch ( event.touches.length ) {\n\n\t\t\tcase 1:\t// one-fingered touch: rotate\n\n\t\t\t\tif ( scope.enableRotate === false ) return;\n\n\t\t\t\thandleTouchStartRotate( event );\n\n\t\t\t\tstate = STATE.TOUCH_ROTATE;\n\n\t\t\t\tbreak;\n\n\t\t\tcase 2:\t// two-fingered touch: dolly\n\n\t\t\t\tif ( scope.enableZoom === false ) return;\n\n\t\t\t\thandleTouchStartDolly( event );\n\n\t\t\t\tstate = STATE.TOUCH_DOLLY;\n\n\t\t\t\tbreak;\n\n\t\t\tcase 3: // three-fingered touch: pan\n\n\t\t\t\tif ( scope.enablePan === false ) return;\n\n\t\t\t\thandleTouchStartPan( event );\n\n\t\t\t\tstate = STATE.TOUCH_PAN;\n\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\n\t\t\t\tstate = STATE.NONE;\n\n\t\t}\n\n\t\tif ( state !== STATE.NONE ) {\n\n\t\t\tscope.dispatchEvent( startEvent );\n\n\t\t}\n\n\t}\n\n\tfunction onTouchMove( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\tevent.preventDefault();\n\t\tevent.stopPropagation();\n\n\t\tswitch ( event.touches.length ) {\n\n\t\t\tcase 1: // one-fingered touch: rotate\n\n\t\t\t\tif ( scope.enableRotate === false ) return;\n\t\t\t\tif ( state !== STATE.TOUCH_ROTATE ) return; // is this needed?...\n\n\t\t\t\thandleTouchMoveRotate( event );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 2: // two-fingered touch: dolly\n\n\t\t\t\tif ( scope.enableZoom === false ) return;\n\t\t\t\tif ( state !== STATE.TOUCH_DOLLY ) return; // is this needed?...\n\n\t\t\t\thandleTouchMoveDolly( event );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 3: // three-fingered touch: pan\n\n\t\t\t\tif ( scope.enablePan === false ) return;\n\t\t\t\tif ( state !== STATE.TOUCH_PAN ) return; // is this needed?...\n\n\t\t\t\thandleTouchMovePan( event );\n\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\n\t\t\t\tstate = STATE.NONE;\n\n\t\t}\n\n\t}\n\n\tfunction onTouchEnd( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\thandleTouchEnd( event );\n\n\t\tscope.dispatchEvent( endEvent );\n\n\t\tstate = STATE.NONE;\n\n\t}\n\n\tfunction onContextMenu( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\tevent.preventDefault();\n\n\t}\n\n\t//\n\n\tscope.domElement.addEventListener( \'contextmenu\', onContextMenu, false );\n\n\tscope.domElement.addEventListener( \'mousedown\', onMouseDown, false );\n\tscope.domElement.addEventListener( \'wheel\', onMouseWheel, false );\n\n\tscope.domElement.addEventListener( \'touchstart\', onTouchStart, false );\n\tscope.domElement.addEventListener( \'touchend\', onTouchEnd, false );\n\tscope.domElement.addEventListener( \'touchmove\', onTouchMove, false );\n\n\twindow.addEventListener( \'keydown\', onKeyDown, false );\n\n\t// force an update at start\n\n\tthis.update();\n\n};\n\nOrbitControls.prototype = Object.create( THREE.EventDispatcher.prototype );\nOrbitControls.prototype.constructor = OrbitControls;\n\nObject.defineProperties( OrbitControls.prototype, {\n\n\tcenter: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( \'OrbitControls: .center has been renamed to .target\' );\n\t\t\treturn this.target;\n\n\t\t}\n\n\t},\n\n\t// backward compatibility\n\n\tnoZoom: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( \'OrbitControls: .noZoom has been deprecated. Use .enableZoom instead.\' );\n\t\t\treturn ! this.enableZoom;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( \'OrbitControls: .noZoom has been deprecated. Use .enableZoom instead.\' );\n\t\t\tthis.enableZoom = ! value;\n\n\t\t}\n\n\t},\n\n\tnoRotate: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( \'OrbitControls: .noRotate has been deprecated. Use .enableRotate instead.\' );\n\t\t\treturn ! this.enableRotate;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( \'OrbitControls: .noRotate has been deprecated. Use .enableRotate instead.\' );\n\t\t\tthis.enableRotate = ! value;\n\n\t\t}\n\n\t},\n\n\tnoPan: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( \'OrbitControls: .noPan has been deprecated. Use .enablePan instead.\' );\n\t\t\treturn ! this.enablePan;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( \'OrbitControls: .noPan has been deprecated. Use .enablePan instead.\' );\n\t\t\tthis.enablePan = ! value;\n\n\t\t}\n\n\t},\n\n\tnoKeys: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( \'OrbitControls: .noKeys has been deprecated. Use .enableKeys instead.\' );\n\t\t\treturn ! this.enableKeys;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( \'OrbitControls: .noKeys has been deprecated. Use .enableKeys instead.\' );\n\t\t\tthis.enableKeys = ! value;\n\n\t\t}\n\n\t},\n\n\tstaticMoving: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( \'OrbitControls: .staticMoving has been deprecated. Use .enableDamping instead.\' );\n\t\t\treturn ! this.enableDamping;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( \'OrbitControls: .staticMoving has been deprecated. Use .enableDamping instead.\' );\n\t\t\tthis.enableDamping = ! value;\n\n\t\t}\n\n\t},\n\n\tdynamicDampingFactor: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( \'OrbitControls: .dynamicDampingFactor has been renamed. Use .dampingFactor instead.\' );\n\t\t\treturn this.dampingFactor;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( \'OrbitControls: .dynamicDampingFactor has been renamed. Use .dampingFactor instead.\' );\n\t\t\tthis.dampingFactor = value;\n\n\t\t}\n\n\t}\n\n} );\n\n/* harmony default export */ const simulator_OrbitControls = (OrbitControls);\n\n;// CONCATENATED MODULE: ./js/simulator/TopDownCameraControls.js\nconst groundPlane = new THREE.Plane(new THREE.Vector3(0, 1, 0));\nlet panning = false;\n\nclass TopDownCameraControls {\n constructor(domElement, camera) {\n this.domElement = domElement;\n this.camera = camera;\n this.enablePanning = false;\n this.enabled = true;\n\n this.minAltitude = Number.NEGATIVE_INFINITY;\n this.maxAltitude = Number.POSITIVE_INFINITY;\n\n this.mouseDown = this.mouseDown.bind(this);\n this.mouseMove = this.mouseMove.bind(this);\n this.mouseUp = this.mouseUp.bind(this);\n this.wheel = this.wheel.bind(this);\n\n this.domElement.addEventListener(\'mousedown\', this.mouseDown);\n this.domElement.addEventListener(\'mousemove\', this.mouseMove);\n this.domElement.addEventListener(\'mouseup\', this.mouseUp);\n this.domElement.addEventListener(\'wheel\', this.wheel);\n }\n\n reset(prevCamera) {\n const lookAt = new THREE.Vector3(0, 0, -1);\n lookAt.applyQuaternion(prevCamera.quaternion);\n\n const ray = new THREE.Ray(prevCamera.position, lookAt);\n const intersection = ray.intersectPlane(groundPlane);\n\n if (intersection) {\n this.camera.position.set(intersection.x, 50, intersection.z);\n } else {\n this.camera.position.y = 50;\n }\n\n this.camera.rotation.set(-Math.PI / 2, 0, 0);\n }\n\n mouseDown(event) {\n if (!this.enabled || !this.enablePanning || event.button != 2) return;\n panning = true;\n }\n\n mouseMove(event) {\n if (panning) {\n const distance = 2 * this.camera.position.y * Math.tan((this.camera.fov / 2) * Math.PI / 180) / this.domElement.clientHeight;\n this.camera.position.x -= distance * event.movementX;\n this.camera.position.z -= distance * event.movementY;\n }\n }\n\n mouseUp(event) {\n if (event.button != 2) return;\n panning = false;\n }\n\n wheel(event) {\n if (!this.enabled) return;\n\n event.preventDefault();\n\n this.camera.position.y = Math.max(this.minAltitude, Math.min(this.maxAltitude, this.camera.position.y * Math.pow(0.995, -event.deltaY)));\n }\n}\n\n;// CONCATENATED MODULE: ./js/simulator/Dashboard.js\n\n\nconst MPS_TO_MPH = 2.23694;\nconst METERS_TO_FEET = 3.28084;\n\nclass Dashboard {\n constructor(car) {\n this.car = car;\n this.units = \'metric\';\n\n if (document.readyState == \'complete\') {\n this.fetchDomElements.call(this);\n } else {\n document.addEventListener(\'readystatechange\', event => {\n if (event.target.readyState == \'complete\')\n this.fetchDomElements.call(this);\n });\n }\n }\n\n fetchDomElements() {\n this.wheelDom = document.getElementById(\'wheel\');\n this.wheelPieDom = document.getElementById(\'wheel-pie\');\n this.wheelPieLeftDom = document.getElementById(\'wheel-pie-left\');\n this.wheelPieRightDom = document.getElementById(\'wheel-pie-right\');\n this.gearDom = document.getElementById(\'gear\');\n this.gasDom = document.getElementById(\'gas\');\n this.brakeDom = document.getElementById(\'brake\');\n this.speedDom = document.getElementById(\'speed\');\n this.stationDom = document.getElementById(\'station\');\n this.latitudeDom = document.getElementById(\'latitude\');\n this.planTimeDom = document.getElementById(\'plan-time\');\n this.elapsedTimeDom = document.getElementById(\'elapsed-time\');\n\n this.speedUnitsDom = document.getElementById(\'speed-units\');\n this.stationUnitsDom = document.getElementById(\'station-units\');\n this.latitudeUnitsDom = document.getElementById(\'latitude-units\');\n\n [this.speedUnitsDom, this.stationUnitsDom, this.latitudeUnitsDom].forEach(el => {\n el.addEventListener(\'click\', event => {\n this.toggleUnits();\n });\n });\n }\n\n toggleUnits() {\n let speedUnits;\n let distanceUnits;\n\n if (this.units == \'metric\') {\n this.units = \'imperial\';\n speedUnits = \'mph\';\n distanceUnits = \'feet\';\n } else {\n this.units = \'metric\';\n speedUnits = \'m/s\';\n distanceUnits = \'meters\';\n }\n\n this.speedUnitsDom.textContent = speedUnits;\n this.stationUnitsDom.textContent = distanceUnits;\n this.latitudeUnitsDom.textContent = distanceUnits;\n }\n\n updatePlanTime(planTime) {\n if (!this.wheelDom) return;\n\n this.planTimeDom.textContent = planTime !== null ? (planTime).toLocaleString(undefined, { maximumFractionDigits: 3 }) : \'—\';\n }\n\n update(controls, speed, station, latitude, elapsedTime, planTime) {\n if (!this.wheelDom) return;\n\n const wheelTurn = Math.clamp(this.car.wheelAngle / Car_Car.MAX_WHEEL_ANGLE * 0.95, -1, +1);\n\n this.wheelDom.style.transform = `rotate(${wheelTurn}turn)`;\n\n if (wheelTurn >= 0) {\n this.wheelPieRightDom.style.transform = `rotate(${wheelTurn}turn)`;\n\n if (wheelTurn <= 0.5) {\n this.wheelPieDom.style.clipPath = "inset(0 0 0 50%)";\n this.wheelPieLeftDom.style.transform = "rotate(0)";\n } else {\n this.wheelPieDom.style.clipPath = "inset(0 0 0 0)";\n this.wheelPieLeftDom.style.transform = "rotate(0.5turn)";\n }\n } else {\n this.wheelPieRightDom.style.transform = `rotate(${0.5 + wheelTurn}turn)`;\n\n if (wheelTurn >= -0.5) {\n this.wheelPieDom.style.clipPath = "inset(0 50% 0 0)";\n this.wheelPieLeftDom.style.transform = "rotate(0.5turn)";\n } else {\n this.wheelPieDom.style.clipPath = "inset(0 0 0 0)";\n this.wheelPieLeftDom.style.transform = "rotate(0)";\n }\n }\n\n this.gearDom.innerText = controls.gas < 0 ? \'R\' : \'D\';\n this.brakeDom.style.clipPath = `inset(50% 50% 0 ${50 - controls.brake * 25}%)`;\n this.gasDom.style.clipPath = `inset(50% ${50 - Math.abs(controls.gas) * 25}% 0 50%)`;\n\n if (this.units == \'imperial\') {\n speed *= MPS_TO_MPH;\n station = station !== null ? station * METERS_TO_FEET : null;\n latitude = latitude !== null ? latitude * METERS_TO_FEET : null;\n }\n\n let latitudeText = latitude !== null ? latitude.toFixed(2) : \'—\';\n if (latitudeText == \'-0.00\') latitudeText = \'0.00\';\n\n this.speedDom.textContent = speed.toFixed(1);\n this.stationDom.textContent = station !== null ? station.toLocaleString(undefined, { minimumFractionDigits: 1, maximumFractionDigits: 1 }) : \'—\';\n this.latitudeDom.textContent = latitudeText;\n this.updatePlanTime(planTime);\n\n let mins = Math.floor(elapsedTime / 60);\n let seconds = elapsedTime % 60;\n\n if (mins == 0) {\n this.elapsedTimeDom.textContent = seconds.toFixed(1);\n } else {\n if (seconds < 10)\n seconds = \'0\' + seconds.toFixed(1);\n else\n seconds = seconds.toFixed(1);\n\n this.elapsedTimeDom.textContent = `${mins}:${seconds}`;\n }\n }\n}\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/RoadLattice.js\nclass RoadLattice {\n constructor(lanePath, latticeStartStation, config) {\n const stationInterval = config.spatialHorizon / config.lattice.numStations;\n const centerline = lanePath.sampleStations(latticeStartStation, config.lattice.numStations, stationInterval);\n const lattice = new Array(centerline.length);\n const offset = Math.floor(config.lattice.numLatitudes / 2);\n\n for (let s = 0; s < centerline.length; s++) {\n const sample = centerline[s];\n const latitudes = lattice[s] = new Array(config.lattice.numLatitudes);\n\n for (let l = 0; l < config.lattice.numLatitudes; l++) {\n const latitude = (l - offset) / offset * config.roadWidth / 2;\n const rot = sample.rot;\n const pos = THREE.Vector2.fromAngle(rot + Math.PI / 2).multiplyScalar(latitude).add(sample.pos);\n const curv = sample.curv == 0 ? 0 : 1 / (1 / sample.curv - latitude);\n\n latitudes[l] = { pos, rot, curv };\n }\n }\n\n this.lattice = lattice;\n }\n}\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/xyObstacleGrid.js\nconst OBSTACLE_VERTEX_SHADER = `#version 300 es\nuniform mat3 xform;\nin vec2 position;\n\nvoid main(void) {\n gl_Position = vec4((xform * vec3(position, 1)).xy, 0, 1);\n}\n`;\n\nconst OBSTACLE_KERNEL = `\n vec4 kernel() {\n return vec4(1, 0, 0, 1);\n }\n`;\n\nlet obstacleVertices;\nlet obstacleXform;\n\n// Draw obstacle triangles to XY-space obstacle grid\n/* harmony default export */ const gpgpu_programs_xyObstacleGrid = ({\n setUp() {\n return {\n kernel: OBSTACLE_KERNEL,\n vertexShader: OBSTACLE_VERTEX_SHADER,\n output: { name: \'xyObstacleGrid\' },\n draw: (gpgpu, program) => {\n const gl = gpgpu.gl;\n\n gl.clearColor(0, 0, 0, 0);\n gl.clear(gl.COLOR_BUFFER_BIT);\n\n if (obstacleVertices.length > 0) {\n const buf = gl.createBuffer();\n\n gl.bindBuffer(gl.ARRAY_BUFFER, buf);\n gl.bufferData(gl.ARRAY_BUFFER, obstacleVertices, gl.STATIC_DRAW);\n gl.enableVertexAttribArray(program.positionLocation);\n gl.vertexAttribPointer(program.positionLocation, 2, gl.FLOAT, false, 0, 0);\n\n const xformLocation = gl.getUniformLocation(program.glProgram, \'xform\');\n gl.uniformMatrix3fv(xformLocation, false, obstacleXform.elements);\n\n gl.drawArrays(gl.TRIANGLES, 0, obstacleVertices.length / 2);\n\n gl.deleteBuffer(buf);\n }\n }\n };\n },\n\n update(config, xyWidth, xyHeight, xyCenterPoint, vehicleXform, obstacles) {\n obstacleVertices = new Float32Array(Array.prototype.concat.apply([], obstacles.map(o => o.vertices)));\n\n const translate = new THREE.Matrix3();\n translate.set(\n 1, 0, -xyCenterPoint.x,\n 0, 1, -xyCenterPoint.y,\n 0, 0, 1\n );\n\n const scale = new THREE.Matrix3();\n scale.set(\n 2 / (xyWidth * config.xyGridCellSize), 0, 0,\n 0, 2 / (xyHeight * config.xyGridCellSize), 0,\n 0, 0, 1\n );\n\n obstacleXform = scale.multiply(translate).multiply(vehicleXform);\n\n return {\n width: xyWidth,\n height: xyHeight\n }\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/slObstacleGrid.js\nconst SL_OBSTACLE_KERNEL = `\n\nvec4 kernel() {\n float centerlineWidth = float(textureSize(centerline, 0).x);\n\n vec2 sl = (kernelPosition - 0.5) * vec2(kernelSize) * vec2(slGridCellSize) + slCenterPoint;\n float centerlineCoord = sl.x / centerlineStationInterval / centerlineWidth * (centerlineWidth - 1.0) / centerlineWidth + (0.5 / centerlineWidth);\n if (centerlineCoord < 0.0 || centerlineCoord > 1.0) return vec4(0);\n\n vec3 centerlineSample = texture(centerline, vec2(centerlineCoord, 0)).xyz;\n float perpindicular = centerlineSample.z + radians(90.0);\n vec2 xy = centerlineSample.xy + sl.yy * vec2(cos(perpindicular), sin(perpindicular));\n\n vec2 xyTexCoords = (xy - xyCenterPoint) / vec2(textureSize(xyObstacleGrid, 0)) / vec2(xyGridCellSize) + 0.5;\n return texture(xyObstacleGrid, xyTexCoords);\n}\n\n`;\n\n// Convert XY-space obstacle grid to SL-space obstacle grid\n/* harmony default export */ const gpgpu_programs_slObstacleGrid = ({\n setUp() {\n return {\n kernel: SL_OBSTACLE_KERNEL,\n output: { name: \'slObstacleGrid\' },\n uniforms: {\n xyObstacleGrid: { type: \'outputTexture\' },\n slGridCellSize: { type: \'float\' },\n xyGridCellSize: { type: \'float\' },\n slCenterPoint: { type: \'vec2\' },\n xyCenterPoint: { type: \'vec2\' },\n centerlineStationInterval: { type: \'float\' },\n centerline: { type: \'sharedTexture\' }\n }\n }\n },\n\n update(config, slWidth, slHeight, slCenterPoint, xyCenterPoint) {\n return {\n width: slWidth,\n height: slHeight,\n uniforms: {\n slGridCellSize: config.slGridCellSize,\n xyGridCellSize: config.xyGridCellSize,\n slCenterPoint: [slCenterPoint.x, slCenterPoint.y],\n xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y],\n centerlineStationInterval: config.centerlineStationInterval\n }\n }\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/slObstacleGridDilation.js\nconst SL_OBSTACLE_DILATION_KERNEL = `\n\n// TODO: test performance of returning early if non-zero pixel found\nvec4 kernel() {\n float val = 0.0;\n\n for (int d = 0; d <= collisionDilation; d++) {\n val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(d)).r);\n val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(-d)).r);\n }\n\n for (int d = collisionDilation + 1; d <= collisionDilation + hazardDilation; d++) {\n val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(d)).r * 0.5);\n val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(-d)).r * 0.5);\n }\n\n val = max(val, step(0.1, val) * 0.5);\n\n return vec4(val, 0, 0, 1);\n}\n\n`;\n\n/* harmony default export */ const gpgpu_programs_slObstacleGridDilation = ({\n setUp() {\n return [\n { // SL-space obstacle grid S dilation\n kernel: SL_OBSTACLE_DILATION_KERNEL,\n output: { name: \'slObstacleGridStationDilated\' },\n uniforms: {\n slObstacleGrid: { type: \'outputTexture\' },\n delta: { type: \'vec2\' },\n collisionDilation: { type: \'int\' },\n hazardDilation: { type: \'int\' }\n }\n },\n { // SL-space obstacle grid L dilation\n kernel: SL_OBSTACLE_DILATION_KERNEL,\n output: { name: \'slObstacleGridDilated\' },\n uniforms: {\n slObstacleGrid: { type: \'outputTexture\', name: \'slObstacleGridStationDilated\' },\n delta: { type: \'vec2\' },\n collisionDilation: { type: \'int\' },\n hazardDilation: { type: \'int\' }\n }\n }\n ];\n },\n\n update(config, slWidth, slHeight) {\n return [\n { // SL-space obstacle grid S dilation\n width: slWidth,\n height: slHeight,\n uniforms: {\n delta: [1 / slWidth, 0],\n collisionDilation: Math.ceil(config.collisionDilationS / config.slGridCellSize),\n hazardDilation: Math.ceil(config.hazardDilationS / config.slGridCellSize)\n }\n },\n { // SL-space obstacle grid L dilation\n width: slWidth,\n height: slHeight,\n uniforms: {\n delta: [0, 1 / slHeight],\n collisionDilation: Math.ceil(config.collisionDilationL / config.slGridCellSize),\n hazardDilation: Math.ceil(config.hazardDilationL / config.slGridCellSize)\n }\n }\n ];\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/slDynamicObstacleGrid.js\nconst DYNAMIC_OBSTACLE_VERTEX_SHADER = `#version 300 es\nuniform mat3 xform;\nin vec3 position;\nout float color;\n\nvoid main(void) {\n gl_Position = vec4((xform * vec3(position.xy, 1)).xy, position.z, 1);\n\n // The z coordinate is 0.25 for collision zone and 0.75 for hazard zone,\n // so that the collision zone is drawn on top.\n // Convert this to 1.0 for collision zone, 0.5 for hazard zone\n color = (1.0 - step(0.5, position.z)) * 0.5 + 0.5;\n}\n`;\n\nconst DYNAMIC_OBSTACLE_KERNEL = `\n in float color;\n\n vec4 kernel() {\n return vec4(color, 0, 0, 1);\n }\n`;\n\nlet slDynamicObstacleGrid_obstacleVertices;\nlet slDynamicObstacleGrid_obstacleXform;\nconst numDynamicFrames = 20;\n\n// Draw dynamic obstacle triangles to SL-space obstacle grid\n/* harmony default export */ const gpgpu_programs_slDynamicObstacleGrid = ({\n setUp() {\n return {\n kernel: DYNAMIC_OBSTACLE_KERNEL,\n vertexShader: DYNAMIC_OBSTACLE_VERTEX_SHADER,\n output: { name: \'slDynamicObstacleGrid\', textureType: \'2DArray\', depth: numDynamicFrames },\n draw: (gpgpu, program) => {\n const gl = gpgpu.gl;\n\n gl.enable(gl.DEPTH_TEST);\n\n const renderbuffer = gl.createRenderbuffer();\n gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer);\n gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, program.inputWidth, program.inputHeight);\n gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, renderbuffer);\n\n for (let frame = 0; frame < numDynamicFrames; frame++) {\n gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, program.outputTexture, 0, frame);\n const frameBufferStatus = (gl.checkFramebufferStatus(gl.FRAMEBUFFER) == gl.FRAMEBUFFER_COMPLETE);\n if (!frameBufferStatus)\n throw new Error(\'Error attaching float texture to framebuffer. Your device is probably incompatible.\');\n\n gl.clearColor(0, 0, 0, 0);\n gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);\n\n if (slDynamicObstacleGrid_obstacleVertices[frame].length > 0) {\n const buf = gl.createBuffer();\n\n gl.bindBuffer(gl.ARRAY_BUFFER, buf);\n gl.bufferData(gl.ARRAY_BUFFER, slDynamicObstacleGrid_obstacleVertices[frame], gl.STATIC_DRAW);\n gl.enableVertexAttribArray(program.positionLocation);\n gl.vertexAttribPointer(program.positionLocation, 3, gl.FLOAT, false, 0, 0);\n\n const xformLocation = gl.getUniformLocation(program.glProgram, \'xform\');\n gl.uniformMatrix3fv(xformLocation, false, slDynamicObstacleGrid_obstacleXform.elements);\n\n gl.drawArrays(gl.TRIANGLES, 0, slDynamicObstacleGrid_obstacleVertices[frame].length / 3);\n\n if (frame == 0) {\n const obstacleGrid = new Float32Array(program.inputWidth * program.inputHeight * 4);\n gl.readPixels(0, 0, program.inputWidth, program.inputHeight, gl.RGBA, gl.FLOAT, obstacleGrid);\n gpgpu._dynamicObstacleGrid = obstacleGrid;\n }\n\n gl.deleteBuffer(buf);\n }\n }\n\n gl.bindRenderbuffer(gl.RENDERBUFFER, null);\n gl.deleteRenderbuffer(renderbuffer);\n gl.disable(gl.DEPTH_TEST);\n }\n };\n },\n\n update(config, slWidth, slHeight, slCenterPoint, vehicleStation, startTime, dynamicFrameTime, dynamicObstacles) {\n slDynamicObstacleGrid_obstacleVertices = [];\n\n let time = startTime;\n for (let frame = 0; frame < numDynamicFrames; frame++) {\n const vertices = Array.prototype.concat.apply([], dynamicObstacles.map(o => o.verticesInTimeRange(time, time + dynamicFrameTime, config)));\n slDynamicObstacleGrid_obstacleVertices.push(new Float32Array(vertices));\n time += dynamicFrameTime;\n }\n\n const translate = new THREE.Matrix3();\n translate.set(\n 1, 0, -slCenterPoint.x - vehicleStation,\n 0, 1, -slCenterPoint.y,\n 0, 0, 1\n );\n\n const scale = new THREE.Matrix3();\n scale.set(\n 2 / (slWidth * config.slGridCellSize), 0, 0,\n 0, 2 / (slHeight * config.slGridCellSize), 0,\n 0, 0, 1\n );\n\n slDynamicObstacleGrid_obstacleXform = scale.multiply(translate);\n\n return {\n width: slWidth,\n height: slHeight\n }\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/xyslMap.js\nconst XYSL_MAP_KERNEL = `\n\nvec4 kernel() {\n vec2 xy = (kernelPosition - 0.5) * vec2(kernelSize) * vec2(xyGridCellSize) + xyCenterPoint;\n\n int numSamples = textureSize(centerline, 0).x;\n int closest = 0;\n float closestDist = distance(xy, texelFetch(centerline, ivec2(0, 0), 0).xy);\n for (int i = 1; i < numSamples; i++) {\n float dist = distance(xy, texelFetch(centerline, ivec2(i, 0), 0).xy);\n if (dist < closestDist) {\n closestDist = dist;\n closest = i;\n }\n }\n\n vec2 closestPos = texelFetch(centerline, ivec2(closest, 0), 0).xy;\n vec2 prev, next;\n int prevIndex, nextIndex;\n\n if (closest == 0) {\n prevIndex = 0;\n nextIndex = 1;\n prev = closestPos;\n next = texelFetch(centerline, ivec2(1, 0), 0).xy;\n } else if (closest == numSamples - 1) {\n prevIndex = closest - 1;\n nextIndex = closest;\n prev = texelFetch(centerline, ivec2(prevIndex, 0), 0).xy;\n next = closestPos;\n } else {\n vec2 before = texelFetch(centerline, ivec2(closest - 1, 0), 0).xy;\n vec2 after = texelFetch(centerline, ivec2(closest + 1, 0), 0).xy;\n\n if (distance(before, xy) < distance(after, xy)) {\n prevIndex = closest - 1;\n nextIndex = closest;\n prev = before;\n next = closestPos;\n } else {\n prevIndex = closest;\n nextIndex = closest + 1;\n prev = closestPos;\n next = after;\n }\n }\n\n float dist = distance(prev, next);\n float progress = clamp(dot(xy - prev, next - prev) / dist / dist, 0.0, 1.0);\n vec2 projectedPos = (next - prev) * vec2(progress) + prev;\n\n return vec4(\n (float(prevIndex) + progress) * centerlineStationInterval,\n sign(determinant(mat2(next - prev, xy - prev))) * distance(xy, projectedPos),\n 0,\n 0\n );\n}\n\n`;\n\n// Build XY-SL map\n/* harmony default export */ const gpgpu_programs_xyslMap = ({\n setUp() {\n return {\n kernel: XYSL_MAP_KERNEL,\n output: { name: \'xyslMap\', filter: \'linear\' },\n uniforms: {\n centerline: { type: \'sharedTexture\' },\n xyCenterPoint: { type: \'vec2\' },\n xyGridCellSize: { type: \'float\'},\n centerlineStationInterval: { type: \'float\'}\n }\n };\n },\n\n update(config, xyWidth, xyHeight, xyCenterPoint) {\n return {\n width: xyWidth,\n height: xyHeight,\n uniforms: {\n xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y],\n xyGridCellSize: config.xyGridCellSize,\n centerlineStationInterval: config.centerlineStationInterval\n }\n };\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/optimizeCubicPaths.js\n// Config:\n// num stations\n// num latitudes\n// station connectivity\n// latitude connectivity\n//\n// Shared:\n// lattice\n\nconst OPTIMIZE_CUBIC_SHARED = `\n\nconst int NEWTON_ITERATIONS = 16;\nconst int RELAXATION_ITERATIONS = 16;\nconst float CONVERGENCE_ERROR = 0.01;\n\n// These two consts must stay in sync.\nconst int SIMPSONS_INTERVALS = 8;\n//const float SIMPSONS_COEFFS[SIMPSONS_INTERVALS + 1] = float[](1.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 1.0);\nconst float SIMPSONS_COEFFS[SIMPSONS_INTERVALS + 1] = float[](1.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 1.0);\n\nconst float PI = 3.1415926535897932384626433832795;\nconst float TWO_PI = PI + PI;\n\nconst float RELAXATION_ITERATIONS_F = float(RELAXATION_ITERATIONS);\nconst float SIMPSONS_INTERVALS_F = float(SIMPSONS_INTERVALS);\n\nfloat wrapAngle(float angle) {\n angle = mod(angle, TWO_PI);\n if (angle <= -PI) return angle + TWO_PI;\n else if (angle > PI) return angle - TWO_PI;\n return angle;\n}\n\nvec4 iterate(vec4 goal, float p0, float p1, float p2, float p3, float sG) {\n float ds = sG / SIMPSONS_INTERVALS_F;\n float sG_2 = sG * sG;\n float sG_3 = sG_2 * sG;\n\n vec3 dX_p = vec3(0.0);\n vec3 dY_p = vec3(0.0);\n vec2 guess = vec2(0.0);\n float s = 0.0;\n\n float theta, cosTheta, sinTheta;\n vec3 dT_p;\n\n for (int i = 0; i <= SIMPSONS_INTERVALS; i++) {\n float coeff = SIMPSONS_COEFFS[i];\n\n float a = p0;\n float b = (-5.5 * p0 + 9.0 * p1 - 4.5 * p2 + p3) / sG;\n float c = (9.0 * p0 - 22.5 * p1 + 18.0 * p2 - 4.5 * p3) / sG_2;\n float d = (-4.5 * (p0 - 3.0 * p1 + 3.0 * p2 - p3)) / sG_3;\n\n theta = (((d * s / 4.0 + c / 3.0) * s + b / 2.0) * s + a) * s;\n cosTheta = cos(theta);\n sinTheta = sin(theta);\n\n float s_sG = s / sG;\n\n dT_p = vec3(\n // p1\n ((3.375 * s_sG - 7.5) * s_sG + 4.5) * s_sG * s,\n\n // p2\n ((-3.375 * s_sG + 6.0) * s_sG - 2.25) * s_sG * s,\n\n // sG\n ((3.375 * (p0 - 3.0 * p1 + 3.0 * p2 - p3) * s_sG - 3.0 * (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3)) * s_sG + 0.25 * (11.0 * p0 - 18.0 * p1 + 9.0 * p2 - 2.0 * p3)) * s_sG * s_sG\n );\n\n dX_p -= coeff * sinTheta * dT_p;\n dY_p += coeff * cosTheta * dT_p;\n\n guess += coeff * vec2(cosTheta, sinTheta);\n\n s += ds;\n }\n\n float hOver3 = sG / SIMPSONS_INTERVALS_F / 3.0;\n\n vec3 delta;\n delta.xy = goal.xy - guess * hOver3;\n delta.z = wrapAngle(goal.z - theta);\n\n if (abs(delta.x) + abs(delta.y) + abs(delta.z) < CONVERGENCE_ERROR)\n return vec4(p1, p2, sG, 1.0);\n\n dX_p.xyz *= hOver3;\n dY_p.xyz *= hOver3;\n dX_p.z += cosTheta;\n dY_p.z += sinTheta;\n\n mat3 invJacobian = inverse(transpose(mat3(dX_p, dY_p, dT_p)));\n\n vec3 deltaP = invJacobian * delta;\n vec4 params = vec4(p1, p2, sG, 0.0);\n params.xyz += deltaP;\n\n return params;\n}\n\n/* Input:\n * start: (vec4)\n * x: x position,\n * y: y position,\n * z: theta rotation,\n * w: k curvature\n * end: (vec4)\n * x: x position,\n * y: y position,\n * z: theta rotation,\n * w: k curvature\n *\n * Output: (vec4)\n * x: p1,\n * y: p2,\n * z: sG,\n * w: 1 if converged, 0 if not\n */\n\nvec4 optimize(vec4 start, vec4 end) {\n // Translate and rotate start and end so that start is at the origin\n float sinRot = sin(start.z);\n float cosRot = cos(start.z);\n\n vec4 diff = end - start;\n vec4 goal;\n goal.xy = mat2(cosRot, -sinRot, sinRot, cosRot) * diff.xy;\n goal.z = wrapAngle(diff.z);\n goal.w = end.w;\n\n vec4 originalGoal = goal;\n vec4 dGoal;\n dGoal.x = 0.0;\n dGoal.yzw = goal.yzw / RELAXATION_ITERATIONS_F;\n float dK0 = start.w / RELAXATION_ITERATIONS_F;\n\n // Relax the goal to (x, 0, 0, 0)\n goal.yzw = vec3(0, 0, 0);\n\n // Relax the params to (0, 0, 0, 0, goal.x)\n float p0 = 0.0;\n float p1 = 0.0;\n float p2 = 0.0;\n float p3 = 0.0;\n float sG = goal.x;\n\n if (sG < 0.1) return vec4(0.0);\n\n for (int i = 0; i < RELAXATION_ITERATIONS; i++) {\n p0 += dK0;\n p3 += dGoal.w;\n goal += dGoal;\n \n vec4 result = iterate(goal, p0, p1, p2, p3, sG);\n p1 = result.x;\n p2 = result.y;\n sG = result.z;\n }\n\n goal = originalGoal;\n\n for (int i = 0; i < NEWTON_ITERATIONS; i++) {\n vec4 result = iterate(goal, p0, p1, p2, p3, sG);\n if (result.w == 1.0) {\n result.w = step(0.0, result.z);\n return result;\n }\n\n p1 = result.x;\n p2 = result.y;\n sG = result.z;\n }\n\n return vec4(p1, p2, sG, 0.0);\n}\n\n`;\n\nconst OPTIMIZE_CUBIC_KERNEL = OPTIMIZE_CUBIC_SHARED + `\n\n// width: station * latitude index\n// height: station_conn * lattice_conn\n//\n// lattice:\n// width: latitudes\n// height: stations\n\nvec4 kernel() {\n ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize));\n\n int endStation = indexes.x / numLatitudes;\n int endLatitude = int(mod(float(indexes.x), float(numLatitudes)));\n\n int startStation = endStation - stationConnectivity + indexes.y / latitudeConnectivity;\n int startLatitude = endLatitude - latitudeConnectivity / 2 + int(mod(float(indexes.y), float(latitudeConnectivity)));\n\n if (startStation < 0 || startStation >= numStations || startLatitude < 0 || startLatitude >= numLatitudes)\n return vec4(0.0);\n\n vec4 start = texelFetch(lattice, ivec2(startLatitude, startStation), 0);\n vec4 end = texelFetch(lattice, ivec2(endLatitude, endStation), 0);\n\n return optimize(start, end);\n}\n\n`;\n\nconst OPTIMIZE_CUBIC_FROM_VEHICLE_KERNEL = OPTIMIZE_CUBIC_SHARED + `\n\nvec4 kernel() {\n ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize));\n\n vec4 start = vec4(0, 0, 0, curvVehicle);\n vec4 end = texelFetch(lattice, indexes, 0);\n\n return optimize(start, end);\n}\n\n`;\n\n/* harmony default export */ const gpgpu_programs_optimizeCubicPaths = ({\n setUp() {\n return [\n { // Cubic paths between lattice nodes\n kernel: OPTIMIZE_CUBIC_KERNEL,\n output: { name: \'cubicPaths\', read: true },\n uniforms: {\n lattice: { type: \'sharedTexture\' },\n numStations: { type: \'int\' },\n numLatitudes: { type: \'int\' },\n stationConnectivity: { type: \'int\' },\n latitudeConnectivity: { type: \'int\' }\n }\n },\n { // Cubic paths from vehicle to lattice nodes\n kernel: OPTIMIZE_CUBIC_FROM_VEHICLE_KERNEL,\n output: { name: \'cubicPathsFromVehicle\', read: true },\n uniforms: {\n lattice: { type: \'sharedTexture\' },\n curvVehicle: { type: \'float\' }\n }\n }\n ]\n },\n\n update(config, pose) {\n return [\n { // Cubic paths between lattice nodes\n width: config.lattice.numStations * config.lattice.numLatitudes,\n height: config.lattice.stationConnectivity * config.lattice.latitudeConnectivity,\n uniforms: {\n numStations: config.lattice.numStations,\n numLatitudes: config.lattice.numLatitudes,\n stationConnectivity: config.lattice.stationConnectivity,\n latitudeConnectivity: config.lattice.latitudeConnectivity,\n }\n },\n { // Cubic paths from vehicle to lattice nodes\n width: config.lattice.numLatitudes,\n height: config.lattice.stationConnectivity,\n uniforms: {\n curvVehicle: pose.curv\n }\n }\n ];\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/optimizeQuinticPaths.js\nconst OPTIMIZE_KERNEL = `\n\nconst int NEWTON_ITERATIONS = 32;\nconst int RELAXATION_ITERATIONS = 32;\nconst float CONVERGENCE_ERROR = 0.01;\n\n// These two consts must stay in sync.\nconst int SIMPSONS_INTERVALS = 8;\nconst float SIMPSONS_COEFFS[SIMPSONS_INTERVALS + 1] = float[](1.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 1.0);\n\nconst float PI = 3.1415926535897932384626433832795;\nconst float TWO_PI = PI + PI;\n\nconst float RELAXATION_ITERATIONS_F = float(RELAXATION_ITERATIONS);\nconst float SIMPSONS_INTERVALS_F = float(SIMPSONS_INTERVALS);\n\nfloat wrapAngle(float angle) {\n angle = mod(angle, TWO_PI);\n if (angle <= -PI) return angle + TWO_PI;\n else if (angle > PI) return angle - TWO_PI;\n return angle;\n}\n\nvec4 iterate(vec4 goal, float p0, float p1, float p2, float p3, float p4, float p5, float sG) {\n float ds = sG / SIMPSONS_INTERVALS_F;\n float sG_2 = sG * sG;\n float sG_3 = sG_2 * sG;\n\n vec3 dX_p = vec3(0.0);\n vec3 dY_p = vec3(0.0);\n vec2 guess = vec2(0.0);\n float s = 0.0;\n\n float theta, cosTheta, sinTheta;\n vec3 dT_p;\n\n for (int i = 0; i <= SIMPSONS_INTERVALS; i++) {\n float coeff = SIMPSONS_COEFFS[i];\n\n float a = p0;\n float b = p1;\n float c = p2 / 2.0;\n float d = (-71.875 * p0 + 81.0 * p3 - 10.125 * p4 + p5 - 21.25 * p1 * sG - 2.75 * p2 * sG_2) / sG_3;\n float e = (166.5 * p0 - 202.5 * p3 + 40.5 * p4 - 4.5 * p5 + 45.0 * p1 * sG + 4.5 * p2 * sG_2) / (sG_2 * sG_2);\n float f = (-95.625 * p0 + 121.5 * p3 - 30.375 * p4 + 4.5 * p5 - 24.75 * p1 * sG - 2.25 * p2 * sG_2) / (sG_2 * sG_3);\n\n theta = (((((f * s / 6.0 + e / 5.0) * s + d / 4.0) * s + c / 3.0) * s + b / 2.0) * s + a) * s;\n cosTheta = cos(theta);\n sinTheta = sin(theta);\n\n float s_2 = s * s;\n float s_sG = s / sG;\n float s_sG_2 = s_sG * s_sG;\n float s_sG_3 = s_sG_2 * s_sG;\n float s_sG_4 = s_sG_3 * s_sG;\n float s_sG_5 = s_sG_4 * s_sG;\n\n dT_p = vec3(\n // p3\n ((20.25 * s_sG - 40.5) * s_sG + 20.25) * s_sG_3 * s,\n\n // p4\n ((-5.0625 * s_sG + 8.1) * s_sG - 2.53125) * s_sG_3 * s,\n\n // sG\n (53.90625 * p0 - 60.75 * p3 + 7.59375 * p4 - 0.75 * p5) * s_sG_4 + 10.625 * p1 * s * s_sG_3 + 0.6875 * p2 * s_2 * s_sG_2 + (-133.2 * p0 + 162.0 * p3 - 32.4 * p4 + 3.6 * p5) * s_sG_5 + (-27.0) * p1 * s * s_sG_4 - 1.8 * p2 * s_2 * s_sG_3 + (79.6875 * p0 - 101.25 * p3 + 25.3125 * p4 - 3.75 * p5) * s_sG_5 * s_sG + 16.5 * p1 * s * s_sG_5 + 1.125 * p2 * s_2 * s_sG_4\n );\n\n dX_p -= coeff * sinTheta * dT_p;\n dY_p += coeff * cosTheta * dT_p;\n\n guess += coeff * vec2(cosTheta, sinTheta);\n\n s += ds;\n }\n\n float hOver3 = sG / SIMPSONS_INTERVALS_F / 3.0;\n\n vec3 delta;\n delta.xy = goal.xy - guess * hOver3;\n delta.z = wrapAngle(goal.z - theta);\n\n if (abs(delta.x) + abs(delta.y) + abs(delta.z) < CONVERGENCE_ERROR)\n return vec4(p3, p4, sG, 1.0);\n\n dX_p.xyz *= hOver3;\n dY_p.xyz *= hOver3;\n dX_p.z += cosTheta;\n dY_p.z += sinTheta;\n\n mat3 invJacobian = inverse(transpose(mat3(dX_p, dY_p, dT_p)));\n\n vec3 deltaP = invJacobian * delta;\n vec4 params = vec4(p3, p4, sG, 0.0);\n params.xyz += deltaP;\n\n return params;\n}\n\nvec4 optimize(vec4 start, vec4 end) {\n // Translate and rotate start and end so that start is at the origin\n float sinRot = sin(start.z);\n float cosRot = cos(start.z);\n\n vec4 diff = end - start;\n vec4 goal;\n goal.xy = mat2(cosRot, -sinRot, sinRot, cosRot) * diff.xy;\n goal.z = wrapAngle(diff.z);\n goal.w = end.w;\n\n vec4 originalGoal = goal;\n vec4 dGoal;\n dGoal.x = 0.0;\n dGoal.yzw = goal.yzw / RELAXATION_ITERATIONS_F;\n float d_K0 = start.w / RELAXATION_ITERATIONS_F;\n float d_dK0 = dCurvVehicle / RELAXATION_ITERATIONS_F;\n float d_ddK0 = ddCurvVehicle / RELAXATION_ITERATIONS_F;\n\n // Relax the goal to (x, 0, 0, 0)\n goal.yzw = vec3(0, 0, 0);\n\n // Relax the params to (0, 0, 0, 0, goal.x)\n float p0 = 0.0;\n float p1 = 0.0;\n float p2 = 0.0;\n float p3 = 0.0;\n float p4 = 0.0;\n float p5 = 0.0;\n float sG = goal.x;\n\n if (sG < 0.1) return vec4(0.0);\n\n for (int i = 0; i < RELAXATION_ITERATIONS; i++) {\n p0 += d_K0;\n p1 += d_dK0;\n p2 += d_ddK0;\n p5 += dGoal.w;\n goal += dGoal;\n \n vec4 result = iterate(goal, p0, p1, p2, p3, p4, p5, sG);\n p3 = result.x;\n p4 = result.y;\n sG = result.z;\n }\n\n goal = originalGoal;\n\n for (int i = 0; i < NEWTON_ITERATIONS; i++) {\n vec4 result = iterate(goal, p0, p1, p2, p3, p4, p5, sG);\n if (result.w == 1.0) {\n result.w = step(0.0, result.z);\n return result;\n }\n\n p3 = result.x;\n p4 = result.y;\n sG = result.z;\n }\n\n return vec4(p3, p4, sG, 0.0);\n}\n\nvec4 kernel() {\n ivec2 latticeIndexes = ivec2(kernelPosition * vec2(kernelSize));\n\n vec4 start = vec4(0, 0, 0, curvVehicle);\n vec4 end = texelFetch(lattice, latticeIndexes, 0);\n\n return optimize(start, end);\n}\n\n`;\n\n// Quintic spiral path optimizer\n// * Start of paths is the vehicle pose\n// * x-pos, y-pos, and rotation aren\'t needed, since the lattice origin is the vehicle pose\n// * So assume position and rotation are 0\n// * Ends of paths are all latitudes within the first (stationConnectivity) stations\n/* harmony default export */ const gpgpu_programs_optimizeQuinticPaths = ({\n setUp() {\n return {\n kernel: OPTIMIZE_KERNEL,\n output: { name: \'quinticPathsFromVehicle\', read: true },\n uniforms: {\n lattice: { type: \'sharedTexture\' },\n curvVehicle: { type: \'float\' },\n dCurvVehicle: { type: \'float\' },\n ddCurvVehicle: { type: \'float\' }\n }\n };\n },\n\n update(config, pose) {\n return {\n width: config.lattice.numLatitudes,\n height: config.lattice.stationConnectivity,\n uniforms: {\n curvVehicle: pose.curv,\n dCurvVehicle: pose.dCurv,\n ddCurvVehicle: pose.ddCurv\n }\n };\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/graphSearchShared.js\nconst SHARED_SHADER = `\n\nconst float smallV = 0.01;\nvec4 pathSamples[128];\nfloat pathSampleCurvRates[128];\n\nfloat calculateAcceleration(int index, float initialVelocitySq, float distance) {\n if (index <= 4) {\n // [aMaxHard, aMinHard, aMaxSoft, aMinSoft, 0]\n return accelerationProfiles[index];\n } else {\n float finalVelocity = finalVelocityProfiles[index - 5];\n if (distance < 0.001) return 0.0;\n return clamp((finalVelocity * finalVelocity - initialVelocitySq) / (2.0 * distance), accelerationProfiles[1], accelerationProfiles[0]);\n }\n}\n\nvec2 xy2sl(vec4 xytk) {\n vec2 xy = xytk.xy + rearAxleToCenter * vec2(cos(xytk.z), sin(xytk.z));\n vec2 xyTexCoords = (xy - xyCenterPoint) / vec2(textureSize(xyslMap, 0)) / vec2(xyGridCellSize) + 0.5;\n return texture(xyslMap, xyTexCoords).xy;\n}\n\nfloat sampleStaticCost(vec4 xytk) {\n vec2 sl = xy2sl(xytk);\n vec2 slTexCoords = (sl - slCenterPoint) / vec2(textureSize(slObstacleGrid, 0)) / vec2(slGridCellSize) + 0.5;\n float obstacleCost = texture(slObstacleGrid, slTexCoords).r;\n\n if (obstacleCost >= 0.75) return -1.0; // Infinite cost\n\n obstacleCost = step(0.25, obstacleCost) * obstacleHazardCost;\n\n float absLatitude = abs(sl.y);\n if (absLatitude >= laneShoulderLatitude) return -1.0;\n\n float laneCost = abs(absLatitude - laneCenterLatitude) * laneCostSlope + step(0.0, -sl.y * sign(lanePreference)) * lanePreferenceDiscount;\n\n return obstacleCost + laneCost;\n}\n\nfloat sampleDynamicCost(vec4 xytk, float time, float velocity, float acceleration) {\n vec2 sl = xy2sl(xytk);\n vec2 slTexCoords = (sl - slCenterPoint) / vec2(textureSize(slDynamicObstacleGrid, 0).xy) / vec2(slGridCellSize) + 0.5;\n float dynamicFrame = floor(time / dynamicFrameTime);\n\n float obstacleCost = texture(slDynamicObstacleGrid, vec3(slTexCoords, dynamicFrame)).r;\n\n if (obstacleCost > 0.75) return -1.0; // Infinite cost\n\n return step(0.25, obstacleCost) * obstacleHazardCost;\n}\n\nfloat calculateAverageStaticCost(int numSamples) {\n float averageStaticCost = 0.0;\n\n for (int i = 0; i < numSamples; i++) {\n float cost = sampleStaticCost(pathSamples[i]);\n\n if (cost < 0.0) return cost;\n\n averageStaticCost += cost;\n }\n\n averageStaticCost /= float(numSamples);\n\n return averageStaticCost;\n}\n\nfloat calculateAverageDynamicCost(int numSamples, float pathLength, float initialTime, float initialVelocity, float acceleration, float abandonThreshold) {\n float s = 0.0;\n float ds = pathLength / float(numSamples - 1);\n float averageDynamicCost = 0.0;\n float maxVelocity = 0.0;\n float maxLateralAcceleration = 0.0;\n float numSamples_f = float(numSamples);\n\n for (int i = 0; i < numSamples; i++) {\n vec4 pathSample = pathSamples[i]; // vec4(x-pos, y-pos, theta (rotation), kappa (curvature))\n\n float velocitySq = 2.0 * acceleration * s + initialVelocity * initialVelocity;\n float velocity = max(smallV, sqrt(max(0.0, velocitySq)));\n maxVelocity = max(maxVelocity, velocity);\n maxLateralAcceleration = max(maxLateralAcceleration, abs(pathSample.w * velocity * velocity));\n\n float time = 2.0 * s / (initialVelocity + velocity) + initialTime;\n\n float dCurv = pathSampleCurvRates[i] * velocity;\n if (dCurv > dCurvatureMax) return -1.0;\n\n float cost = sampleDynamicCost(pathSample, time, velocity, acceleration);\n if (cost < 0.0) return cost;\n\n averageDynamicCost += cost;\n if (averageDynamicCost / numSamples_f >= abandonThreshold) return -1.0;\n\n s += ds;\n }\n\n averageDynamicCost /= numSamples_f;\n\n // Apply speeding penality if any velocity along the trajectory is over the speed limit\n averageDynamicCost += step(speedLimit, maxVelocity) * speedLimitPenalty;\n\n // Apply hard acceleration/deceleration penalties if the acceleration/deceleration exceeds the soft limits\n averageDynamicCost += step(accelerationProfiles[2] + 0.0001, acceleration) * hardAccelerationPenalty;\n averageDynamicCost += (1.0 - step(accelerationProfiles[3], acceleration)) * hardDecelerationPenalty;\n\n // Penalize lateral acceleration\n averageDynamicCost += step(softLateralAccelerationLimit, maxLateralAcceleration) * softLateralAccelerationPenalty;\n averageDynamicCost += linearLateralAccelerationPenalty * maxLateralAcceleration;\n\n return averageDynamicCost;\n}\n\nvec3 calculateAVT(int accelerationIndex, float initialVelocity, float initialTime, float pathLength) {\n float initialVelocitySq = initialVelocity * initialVelocity;\n float acceleration = calculateAcceleration(accelerationIndex, initialVelocitySq, pathLength);\n\n float finalVelocitySq = 2.0 * acceleration * pathLength + initialVelocitySq;\n float finalVelocity = max(smallV, sqrt(max(0.0, finalVelocitySq)));\n\n float finalTime = initialTime;\n\n if (acceleration == 0.0) {\n finalTime += pathLength / finalVelocity;\n } else if (finalVelocitySq <= 0.0) { // Calculate final time if the vehicle stops before the end of the trajectory\n float distanceLeft = pathLength - (smallV * smallV - initialVelocitySq) / (2.0 * acceleration);\n finalTime += (finalVelocity - initialVelocity) / acceleration + distanceLeft / smallV;\n } else {\n finalTime += 2.0 * pathLength / (finalVelocity + initialVelocity);\n }\n\n return vec3(acceleration, finalVelocity, finalTime);\n}\n\n`;\n\nconst SAMPLE_CUBIC_PATH_FN = `\n\nint sampleCubicPath(vec4 start, vec4 end, vec4 cubicPathParams) {\n float p0 = start.w;\n float p1 = cubicPathParams.x;\n float p2 = cubicPathParams.y;\n float p3 = end.w;\n float sG = cubicPathParams.z;\n\n if (sG <= 0.0) return 0;\n\n int numSamples = int(ceil(sG / pathSamplingStep)) + 1;\n\n float sG_2 = sG * sG;\n float sG_3 = sG_2 * sG;\n\n float a = p0;\n float b = (-5.5 * p0 + 9.0 * p1 - 4.5 * p2 + p3) / sG;\n float c = (9.0 * p0 - 22.5 * p1 + 18.0 * p2 - 4.5 * p3) / sG_2;\n float d = (-4.5 * (p0 - 3.0 * p1 + 3.0 * p2 - p3)) / sG_3;\n\n pathSamples[0] = start;\n\n float ds = sG / float(numSamples - 1);\n float s = ds;\n vec2 dxy = vec2(0);\n vec2 prevCosSin = vec2(cos(start.z), sin(start.z));\n\n for (int i = 1; i < numSamples; i++) {\n float rot = (((d * s / 4.0 + c / 3.0) * s + b / 2.0) * s + a) * s + start.z;\n float curv = ((d * s + c) * s + b) * s + a;\n\n vec2 cosSin = vec2(cos(rot), sin(rot));\n dxy = dxy * vec2(float(i - 1) / float(i)) + (cosSin + prevCosSin) / vec2(2 * i);\n\n pathSamples[i] = vec4(dxy * vec2(s) + start.xy, rot, curv);\n pathSampleCurvRates[i] = b + s * (2.0 * c + 3.0 * d * s);\n\n s += ds;\n prevCosSin = cosSin;\n }\n\n return numSamples;\n}\n\n`;\n\nconst SAMPLE_QUINTIC_PATH_FN = `\n\nint sampleQuinticPath(vec4 start, vec4 end, vec4 quinticPathParams) {\n float p0 = start.w;\n float p1 = dCurvVehicle;\n float p2 = ddCurvVehicle;\n float p3 = quinticPathParams.x;\n float p4 = quinticPathParams.y;\n float p5 = end.w;\n float sG = quinticPathParams.z;\n\n if (sG <= 0.0) return 0;\n\n int numSamples = int(ceil(sG / pathSamplingStep)) + 1;\n\n float sG_2 = sG * sG;\n float sG_3 = sG_2 * sG;\n\n float a = p0;\n float b = p1;\n float c = p2 / 2.0;\n float d = (-71.875 * p0 + 81.0 * p3 - 10.125 * p4 + p5 - 21.25 * p1 * sG - 2.75 * p2 * sG_2) / sG_3;\n float e = (166.5 * p0 - 202.5 * p3 + 40.5 * p4 - 4.5 * p5 + 45.0 * p1 * sG + 4.5 * p2 * sG_2) / (sG_2 * sG_2);\n float f = (-95.625 * p0 + 121.5 * p3 - 30.375 * p4 + 4.5 * p5 - 24.75 * p1 * sG - 2.25 * p2 * sG_2) / (sG_2 * sG_3);\n\n pathSamples[0] = start;\n\n float ds = sG / float(numSamples - 1);\n float s = ds;\n vec2 dxy = vec2(0);\n vec2 prevCosSin = vec2(cos(start.z), sin(start.z));\n\n for (int i = 1; i < numSamples; i++) {\n float rot = (((((f * s / 6.0 + e / 5.0) * s + d / 4.0) * s + c / 3.0) * s + b / 2.0) * s + a) * s + start.z;\n float curv = ((((f * s + e) * s + d) * s + c) * s + b) * s + a;\n\n vec2 cosSin = vec2(cos(rot), sin(rot));\n dxy = dxy * vec2(float(i - 1) / float(i)) + (cosSin + prevCosSin) / vec2(2 * i);\n\n pathSamples[i] = vec4(dxy * vec2(s) + start.xy, rot, curv);\n pathSampleCurvRates[i] = b + s * (2.0 * c + s * (3.0 * d + s * (4.0 * e + 5.0 * f * s)));\n\n s += ds;\n prevCosSin = cosSin;\n }\n\n return numSamples;\n}\n\n`;\n\nconst NUM_ACCELERATION_PROFILES = 8;\nconst NUM_VELOCITY_RANGES = 4;\nconst NUM_TIME_RANGES = 2;\n\nconst SHARED_UNIFORMS = {\n xyslMap: { type: \'outputTexture\' },\n slObstacleGrid: { type: \'outputTexture\', name: \'slObstacleGridDilated\' },\n slDynamicObstacleGrid: { type: \'outputTexture\', name: \'slDynamicObstacleGrid\', textureType: \'2DArray\' },\n accelerationProfiles: { type: \'float\', length: 5 },\n finalVelocityProfiles: { type: \'float\', length: 3 },\n xyCenterPoint: { type: \'vec2\' },\n xyGridCellSize: { type: \'float\' },\n slCenterPoint: { type: \'vec2\' },\n slGridCellSize: { type: \'float\'},\n laneCenterLatitude: { type: \'float\'},\n laneShoulderLatitude: { type: \'float\'},\n laneCostSlope: { type: \'float\'},\n lanePreference: { type: \'float\' },\n lanePreferenceDiscount: { type: \'float\' },\n obstacleHazardCost: { type: \'float\' },\n speedLimit: { type: \'float\' },\n speedLimitPenalty: { type: \'float\' },\n hardAccelerationPenalty: { type: \'float\' },\n hardDecelerationPenalty: { type: \'float\' },\n softLateralAccelerationLimit: { type: \'float\' },\n softLateralAccelerationPenalty: { type: \'float\' },\n linearLateralAccelerationPenalty: { type: \'float\' },\n dCurvatureMax: { type: \'float\' },\n pathSamplingStep: { type: \'float\' },\n rearAxleToCenter: { type: \'float\' },\n dynamicFrameTime: { type: \'float\' }\n};\n\nfunction buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime) {\n return {\n accelerationProfiles: [3.5, -6.5, 2.0, -3.0, 0],\n finalVelocityProfiles: [0.999 * config.speedLimit, 1.0, 0.01],\n xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y],\n xyGridCellSize: config.xyGridCellSize,\n slCenterPoint: [slCenterPoint.x, slCenterPoint.y],\n slGridCellSize: config.slGridCellSize,\n laneCenterLatitude: config.laneCenterLatitude,\n laneShoulderLatitude: config.laneShoulderLatitude,\n laneCostSlope: config.laneCostSlope,\n lanePreference: config.lanePreference,\n lanePreferenceDiscount: config.lanePreferenceDiscount,\n obstacleHazardCost: config.obstacleHazardCost,\n speedLimit: config.speedLimit,\n speedLimitPenalty: config.speedLimitPenalty,\n hardAccelerationPenalty: config.hardAccelerationPenalty,\n hardDecelerationPenalty: config.hardDecelerationPenalty,\n softLateralAccelerationLimit: config.softLateralAccelerationLimit,\n softLateralAccelerationPenalty: config.softLateralAccelerationPenalty,\n linearLateralAccelerationPenalty: config.linearLateralAccelerationPenalty,\n dCurvatureMax: config.dCurvatureMax,\n pathSamplingStep: config.pathSamplingStep,\n rearAxleToCenter: config.rearAxleToCenter,\n dynamicFrameTime: dynamicFrameTime\n };\n}\n\n\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/pathFromVehicleCosts.js\n\n\nfunction fromVehiclePathCostsKernel(pathType) {\n return SHARED_SHADER + (pathType == \'cubic\' ? SAMPLE_CUBIC_PATH_FN : SAMPLE_QUINTIC_PATH_FN) +\n\n`\n\n/* Calculate cost of a {cubic|quintic} path from vehicle to (stationConnectivity * numLatitudes * numAccelerations) nodes\n * width: numLatitudes\n * height: station * numAccelerations\n */\nvec4 kernel() {\n ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize));\n\n int latitude = indexes.x;\n int station = indexes.y / numAccelerations;\n int accelerationIndex = int(mod(float(indexes.y), float(numAccelerations)));\n\n vec4 pathStart = vec4(0, 0, 0, curvVehicle);\n vec4 pathEnd = texelFetch(lattice, ivec2(latitude, station), 0);\n\n vec4 pathParams = texelFetch(pathsFromVehicle, ivec2(latitude, station), 0);\n\n // If the path didn\'t converge\n if (pathParams.w == 0.0) return vec4(-1);\n\n int numSamples = ${pathType == \'cubic\' ? \'sampleCubicPath\' : \'sampleQuinticPath\'}(pathStart, pathEnd, pathParams);\n float pathLength = pathParams.z;\n\n if (numSamples < 2) return vec4(-1);\n\n float averageStaticCost = calculateAverageStaticCost(numSamples);\n if (averageStaticCost < 0.0) return vec4(-1);\n\n int slIndex = station * kernelSize.x + latitude;\n float hysteresisAdjustment = (slIndex == firstLatticePoint || slIndex == secondLatticePoint) ? 0.0 : hysteresisDiscount;\n averageStaticCost += hysteresisAdjustment;\n\n vec3 avt = calculateAVT(accelerationIndex, velocityVehicle, 0.0, pathLength);\n float acceleration = avt.x;\n float finalVelocity = avt.y;\n float finalTime = avt.z;\n\n float averageDynamicCost = calculateAverageDynamicCost(numSamples, pathLength, 0.0, velocityVehicle, acceleration, 1.0 / 0.0);\n if (averageDynamicCost < 0.0) return vec4(-1);\n\n averageDynamicCost += accelerationChangePenalty;\n\n // The cost of a trajectory is the average sample cost scaled by the path length\n float totalCost = (averageStaticCost + averageDynamicCost + ${pathType == \'cubic\' ? \'(cubicPathPenalty * velocityVehicle * velocityVehicle)\' : \'0.0\'}) * pathLength;\n ${pathType != \'cubic\' ? \'totalCost = -1.0;\' : \'\'}\n\n return vec4(totalCost, finalVelocity, finalTime, ${pathType == \'cubic\' ? \'-2\' : \'-1\'});\n}\n\n`;\n}\n\n/* harmony default export */ const gpgpu_programs_pathFromVehicleCosts = ({\n setUp() {\n return [\n {\n kernel: fromVehiclePathCostsKernel(\'cubic\'),\n output: { name: \'cubicPathFromVehicleCosts\' },\n uniforms: Object.assign({}, SHARED_UNIFORMS, {\n lattice: { type: \'sharedTexture\' },\n pathsFromVehicle: { type: \'outputTexture\', name: \'cubicPathsFromVehicle\' },\n firstLatticePoint: { type: \'int\' },\n secondLatticePoint: { type: \'int\' },\n velocityVehicle: { type: \'float\' },\n curvVehicle: { type: \'float\' },\n numAccelerations: { type: \'int\' },\n cubicPathPenalty: { type: \'float\' },\n hysteresisDiscount: { type: \'float\' },\n accelerationChangePenalty: { type: \'float\' }\n })\n },\n {\n kernel: fromVehiclePathCostsKernel(\'quintic\'),\n output: { name: \'quinticPathFromVehicleCosts\' },\n uniforms: Object.assign({}, SHARED_UNIFORMS, {\n lattice: { type: \'sharedTexture\' },\n pathsFromVehicle: { type: \'outputTexture\', name: \'quinticPathsFromVehicle\' },\n firstLatticePoint: { type: \'int\' },\n secondLatticePoint: { type: \'int\' },\n velocityVehicle: { type: \'float\' },\n curvVehicle: { type: \'float\' },\n dCurvVehicle: { type: \'float\' },\n ddCurvVehicle: { type: \'float\' },\n numAccelerations: { type: \'int\' },\n hysteresisDiscount: { type: \'float\' },\n accelerationChangePenalty: { type: \'float\' }\n })\n }\n ];\n },\n\n update(config, pose, xyCenterPoint, slCenterPoint, firstLatticePoint, secondLatticePoint, dynamicFrameTime) {\n return [\n {\n width: config.lattice.numLatitudes,\n height: config.lattice.stationConnectivity * NUM_ACCELERATION_PROFILES,\n uniforms: Object.assign({}, buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime), {\n firstLatticePoint: firstLatticePoint,\n secondLatticePoint: secondLatticePoint,\n velocityVehicle: pose.velocity,\n curvVehicle: pose.curv,\n numAccelerations: NUM_ACCELERATION_PROFILES,\n cubicPathPenalty: config.cubicPathPenalty,\n hysteresisDiscount: config.hysteresisDiscount,\n accelerationChangePenalty: config.accelerationChangePenalty\n })\n },\n {\n width: config.lattice.numLatitudes,\n height: config.lattice.stationConnectivity * NUM_ACCELERATION_PROFILES,\n uniforms: Object.assign({}, buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime), {\n firstLatticePoint: firstLatticePoint,\n secondLatticePoint: secondLatticePoint,\n velocityVehicle: pose.velocity,\n curvVehicle: pose.curv,\n dCurvVehicle: pose.dCurv,\n ddCurvVehicle: pose.ddCurv,\n numAccelerations: NUM_ACCELERATION_PROFILES,\n hysteresisDiscount: config.hysteresisDiscount,\n accelerationChangePenalty: config.accelerationChangePenalty\n })\n }\n ];\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/graphSearch.js\n/* State Lattice Cost Map\n * \n * 5-dimensional node: station, latitude, acceleration profile, velocity, time\n *\n * A draw call per station s\n * * Input to kernel: latitude l, acceleration profile a, velocity range v, time range t\n * * Find all SL vertices that can connect to this node\n * * For each of those vertices, check if any terminate in this specific velocity and time range\n * * Based on initial velocity, initial time, and acceleration\n * * Each connected SL vertex should have a * v * t nodes that could possibly terminate at this node\n * * For all valid edges, find the one with the lowest cost\n *\n * Input:\n * * 2D texture array cost map\n * * Height: num of latitudes (~20)\n * * Width: num of acceleration profiles * num of time ranges * num of velocity ranges (8 * 2 * 4 = ~64)\n * * A flattened 3D array:\n * d1: acceleration\n * d2: velocity\n * d3: time\n * * Layer: num of stations (~10)\n * \n * Output:\n * * 2D texture slice of the next station in the input 2D texture array cost map\n *\n * Cost Map Elements:\n * * Traversal cost so far\n * * Ending velocity\n * * Ending time\n * * Index of parent node\n *\n * Since one cubic path can be shared between multiple trajectories, they need to be pre-optimized.\n *\n * Quintic Paths:\n * Stations 0 through (numStations - 1) correspond to the stations on the lattice; however,\n * a new station (station -1) will be used to signifiy the single vehicle pose node. Either\n * a cubic path or quintic path can be used to connect this single node to the lattice\n * (depending on vehicle velocity). At station -1, latitude 0 will correspond to a cubic path,\n * and latitude 1 will correspond to a quintic path. All other latitudes will be skipped.\n */\n\n\n\nconst SOLVE_STATION_KERNEL =\n SHARED_SHADER +\n SAMPLE_CUBIC_PATH_FN +\n SAMPLE_QUINTIC_PATH_FN +\n\n`\n\nvec4 kernel() {\n ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize));\n\n int latitude = indexes.y;\n\n int numPerTime = numAccelerations * numVelocities;\n int timeIndex = indexes.x / numPerTime;\n indexes.x -= timeIndex * numPerTime;\n int velocityIndex = indexes.x / numAccelerations;\n int accelerationIndex = int(mod(float(indexes.x), float(numAccelerations)));\n\n int minLatitude = max(latitude - latitudeConnectivity / 2, 0);\n int maxLatitude = min(latitude + latitudeConnectivity / 2, numLatitudes - 1);\n\n int slIndex = station * numLatitudes + latitude;\n\n vec4 pathEnd = texelFetch(lattice, ivec2(latitude, station), 0);\n\n float minVelocity = velocityRanges[velocityIndex];\n float maxVelocity = velocityRanges[velocityIndex + 1];\n\n float minTime = timeRanges[timeIndex];\n float maxTime = timeRanges[timeIndex + 1];\n\n vec4 bestTrajectory = vec4(-1); // -1 means infinite cost\n float bestTerminalCost = 1.0 / 0.0;\n\n float hysteresisAdjustment = (slIndex == firstLatticePoint || slIndex == secondLatticePoint) ? 0.0 : hysteresisDiscount;\n\n for (int prevStation = max(station - stationConnectivity, 0); prevStation < station; prevStation++) {\n int stationConnectivityIndex = prevStation - station + stationConnectivity;\n\n for (int prevLatitude = minLatitude; prevLatitude <= maxLatitude; prevLatitude++) {\n int latitudeConnectivityIndex = prevLatitude - latitude + latitudeConnectivity / 2;\n int connectivityIndex = stationConnectivityIndex * latitudeConnectivity + latitudeConnectivityIndex;\n\n vec4 pathStart = texelFetch(lattice, ivec2(prevLatitude, prevStation), 0);\n vec4 cubicPathParams = texelFetch(cubicPaths, ivec2(slIndex, connectivityIndex), 0);\n\n // If the path didn\'t converge\n if (cubicPathParams.w == 0.0) continue;\n\n int numSamples = sampleCubicPath(pathStart, pathEnd, cubicPathParams);\n float pathLength = cubicPathParams.z;\n\n if (numSamples < 2) continue;\n\n float averageStaticCost = calculateAverageStaticCost(numSamples);\n if (averageStaticCost < 0.0) continue;\n\n averageStaticCost += hysteresisAdjustment;\n\n if (averageStaticCost * pathLength >= bestTerminalCost) continue;\n\n for (int prevVelocity = 0; prevVelocity < numVelocities; prevVelocity++) {\n for (int prevTime = 0; prevTime < numTimes; prevTime++) {\n for (int prevAccel = 0; prevAccel < numAccelerations; prevAccel++) {\n int avtIndex = prevTime * numPerTime + prevVelocity * numAccelerations + prevAccel;\n\n // Cost table entry:\n // x: cost so far\n // y: end velocity\n // z: end time\n // w: parent index\n vec4 costTableEntry = texelFetch(costTable, ivec3(avtIndex, prevLatitude, prevStation), 0);\n\n // If cost entry is infinity\n if (costTableEntry.x < 0.0 || averageStaticCost * pathLength + costTableEntry.x >= bestTerminalCost) continue;\n\n vec3 avt = calculateAVT(accelerationIndex, costTableEntry.y, costTableEntry.z, pathLength);\n float acceleration = avt.x;\n float finalVelocity = avt.y;\n float finalTime = avt.z;\n\n if (averageStaticCost * pathLength + costTableEntry.x + extraTimePenalty * finalTime >= bestTerminalCost) continue;\n\n // If the calculated final velocity does not match this fragment\'s velocity range, then skip this trajectory\n if (finalVelocity < minVelocity || finalVelocity >= maxVelocity) continue;\n\n // If the calculated final time does not match this fragment\'s time range, then skip this trajectory\n if (finalTime < minTime || finalTime >= maxTime) continue;\n\n float abandonThreshold = (bestTerminalCost - extraTimePenalty * finalTime - costTableEntry.x) / pathLength - averageStaticCost;\n float averageDynamicCost = calculateAverageDynamicCost(numSamples, pathLength, costTableEntry.z, costTableEntry.y, acceleration, abandonThreshold);\n if (averageDynamicCost < 0.0) continue;\n\n if (accelerationIndex != prevAccel)\n averageDynamicCost += accelerationChangePenalty;\n\n // The cost of a trajectory is the average sample cost scaled by the path length\n float totalCost = (averageStaticCost + averageDynamicCost) * pathLength + costTableEntry.x;\n\n float terminalCost = totalCost + extraTimePenalty * finalTime;\n if (terminalCost >= bestTerminalCost) continue;\n bestTerminalCost = terminalCost;\n\n int incomingIndex = avtIndex + numPerTime * numTimes * (prevLatitude + numLatitudes * prevStation);\n bestTrajectory = vec4(totalCost, finalVelocity, finalTime, incomingIndex);\n }\n }\n }\n }\n }\n\n if (station < stationConnectivity) {\n ivec2 slaIndex = ivec2(latitude, station * numAccelerations + accelerationIndex);\n\n vec4 costTableEntry = texelFetch(cubicPathFromVehicleCosts, slaIndex, 0);\n float terminalCost;\n\n if (costTableEntry.x >= 0.0) {\n terminalCost = costTableEntry.x + extraTimePenalty * costTableEntry.z;\n\n if (terminalCost < bestTerminalCost) {\n bestTerminalCost = terminalCost;\n bestTrajectory = costTableEntry;\n }\n }\n\n costTableEntry = texelFetch(quinticPathFromVehicleCosts, slaIndex, 0);\n\n if (costTableEntry.x >= 0.0) {\n terminalCost = costTableEntry.x + extraTimePenalty * costTableEntry.z;\n\n if (terminalCost < bestTerminalCost) {\n bestTerminalCost = terminalCost;\n bestTrajectory = costTableEntry;\n }\n }\n }\n\n return bestTrajectory;\n}\n\n`;\n\n/* harmony default export */ const gpgpu_programs_graphSearch = ({\n setUp() {\n return {\n kernel: SOLVE_STATION_KERNEL,\n output: { name: \'graphSearch\' },\n uniforms: Object.assign({}, SHARED_UNIFORMS, {\n lattice: { type: \'sharedTexture\' },\n costTable: { type: \'sharedTexture\', textureType: \'2DArray\' },\n cubicPaths: { type: \'outputTexture\' },\n cubicPathFromVehicleCosts: { type: \'outputTexture\' },\n quinticPathFromVehicleCosts: { type: \'outputTexture\' },\n firstLatticePoint: { type: \'int\' },\n secondLatticePoint: { type: \'int\' },\n velocityVehicle: { type: \'float\' },\n curvVehicle: { type: \'float\' },\n dCurvVehicle: { type: \'float\' },\n ddCurvVehicle: { type: \'float\' },\n extraTimePenalty: { type: \'float\' },\n hysteresisDiscount: { type: \'float\' },\n accelerationChangePenalty: { type: \'float\' },\n numStations: { type: \'int\' },\n numLatitudes: { type: \'int\' },\n numAccelerations: { type: \'int\' },\n numVelocities: { type: \'int\' },\n numTimes: { type: \'int\' },\n stationConnectivity: { type: \'int\' },\n latitudeConnectivity: { type: \'int\' },\n velocityRanges: { type: \'float\', length: NUM_VELOCITY_RANGES + 1 },\n timeRanges: { type: \'float\', length: NUM_TIME_RANGES + 1 },\n station: { type: \'int\' } // Updated in `drawProxy`\n }),\n drawProxy: (gpgpu, program, draw) => {\n const width = NUM_ACCELERATION_PROFILES * NUM_VELOCITY_RANGES * NUM_TIME_RANGES;\n const height = program.meta.lattice.numLatitudes;\n const costTable = new Float32Array(width * height * program.meta.lattice.numStations * 4);\n\n for (let s = 0; s < program.meta.lattice.numStations; s++) {\n gpgpu.updateProgramUniforms(program, { station: s });\n draw();\n\n gpgpu.gl.readPixels(0, 0, width, height, gpgpu.gl.RGBA, gpgpu.gl.FLOAT, costTable, s * width * height * 4);\n\n gpgpu.gl.bindTexture(gpgpu.gl.TEXTURE_2D_ARRAY, gpgpu.sharedTextures.costTable);\n gpgpu.gl.copyTexSubImage3D(gpgpu.gl.TEXTURE_2D_ARRAY, 0, 0, 0, s, 0, 0, width, height);\n }\n\n gpgpu._graphSearchCostTable = costTable;\n }\n };\n },\n\n update(config, pose, xyCenterPoint, slCenterPoint, firstLatticePoint, secondLatticePoint, dynamicFrameTime) {\n return {\n width: NUM_ACCELERATION_PROFILES * NUM_VELOCITY_RANGES * NUM_TIME_RANGES,\n height: config.lattice.numLatitudes,\n meta: {\n lattice: config.lattice\n },\n uniforms: Object.assign({}, buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime), {\n firstLatticePoint: firstLatticePoint,\n secondLatticePoint: secondLatticePoint,\n velocityVehicle: pose.velocity,\n curvVehicle: pose.curv,\n dCurvVehicle: pose.dCurv,\n ddCurvVehicle: pose.ddCurv,\n extraTimePenalty: config.extraTimePenalty,\n hysteresisDiscount: config.hysteresisDiscount,\n accelerationChangePenalty: config.accelerationChangePenalty,\n numStations: config.lattice.numStations,\n numLatitudes: config.lattice.numLatitudes,\n numAccelerations: NUM_ACCELERATION_PROFILES,\n numVelocities: NUM_VELOCITY_RANGES,\n numTimes: NUM_TIME_RANGES,\n stationConnectivity: config.lattice.stationConnectivity,\n latitudeConnectivity: config.lattice.latitudeConnectivity,\n velocityRanges: [0, config.speedLimit / 3, config.speedLimit * 2 / 3, config.speedLimit, 1000000],\n timeRanges: [0, 10, 1000000]\n })\n };\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/xyObstacleCostGrid.js\nconst XY_OBSTACLE_COST_KERNEL = `\n\nvec4 kernel() {\n vec2 xy = (kernelPosition - 0.5) * vec2(kernelSize) * vec2(xyGridCellSize) + xyCenterPoint;\n\n vec2 xyTexCoords = (xy - xyCenterPoint) / vec2(textureSize(xyslMap, 0)) / vec2(xyGridCellSize) + 0.5;\n vec2 sl = texture(xyslMap, xyTexCoords).xy;\n\n vec2 slTexCoords = (sl - slCenterPoint) / vec2(textureSize(slObstacleGrid, 0)) / vec2(slGridCellSize) + 0.5;\n return texture(slObstacleGrid, slTexCoords);\n}\n\n`;\n\n// Build XY obstacle costs using XYSL map\n/* harmony default export */ const xyObstacleCostGrid = ({\n setUp() {\n return {\n kernel: XY_OBSTACLE_COST_KERNEL,\n output: { name: \'xyObstacleCostGrid\', read: true },\n uniforms: {\n xyslMap: { type: \'outputTexture\' },\n slObstacleGrid: { type: \'outputTexture\', name: \'slObstacleGridDilated\' },\n xyCenterPoint: { type: \'vec2\' },\n xyGridCellSize: { type: \'float\'},\n slCenterPoint: { type: \'vec2\' },\n slGridCellSize: { type: \'float\'}\n }\n };\n },\n\n update(config, xyWidth, xyHeight, xyCenterPoint, slCenterPoint) {\n return {\n width: xyWidth,\n height: xyHeight,\n uniforms: {\n xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y],\n xyGridCellSize: config.xyGridCellSize,\n slCenterPoint: [slCenterPoint.x, slCenterPoint.y],\n slGridCellSize: config.slGridCellSize\n }\n };\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/PathPlanner.js\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nconst PathPlanner_NUM_ACCELERATION_PROFILES = 8;\nconst PathPlanner_NUM_VELOCITY_RANGES = 4;\nconst PathPlanner_NUM_TIME_RANGES = 2;\n\n/* Obstacle cost map:\n *\n * 1. Rasterize triangles from polygonal obstacles into XY-space occupancy grid\n * 2. Convert occupancy grid to SL-space\n * * Width is spatial horizon of the state lattice\n * * Height is lane width\n * * Resolution should be higher than XY-grid\n * * Get XY position from centerline texture\n * * Lookup XY in XY occupancy grid (nearest)\n * 3. Dilate SL-space grid using two passes (along station, then along latitude)\n * * collision area: half car size + 0.3m\n * * high cost area: 1 meter\n * 4. Convert back to XY-space using XYSL map\n */\n\nclass PathPlanner {\n constructor() {\n this.previousStartStation = null;\n this.previousFirstLatticePoint = -1;\n this.previousSecondLatticePoint = -1;\n this.previousFirstAcceleration = -1;\n this.previousSecondLatticePoint = -1;\n\n let start = performance.now();\n const programs = [\n xyObstacleGrid.setUp(),\n slObstacleGrid.setUp(),\n ...slObstacleGridDilation.setUp(),\n slDynamicObstacleGrid.setUp(),\n xyslMap.setUp(),\n ...optimizeCubicPaths.setUp(),\n optimizeQuinticPaths.setUp(),\n ...pathFromVehicleCosts.setUp(),\n graphSearch.setUp(),\n ].map(p => Object.assign({}, p, { width: 1, height: 1 }));\n\n this.gpgpu = new GPGPU(programs);\n }\n\n reset() {\n this.previousStartStation = null;\n this.previousFirstLatticePoint = -1;\n this.previousSecondLatticePoint = -1;\n this.previousFirstAcceleration = -1;\n this.previousSecondLatticePoint = -1;\n }\n\n plan(vehiclePose, vehicleStation, lanePath, startTime, staticObstacles, dynamicObstacles) {\n const latticeStationInterval = this._latticeStationInterval();\n\n const centerlineRaw = lanePath.sampleStations(vehicleStation, Math.ceil((this.config.spatialHorizon + latticeStationInterval) / this.config.centerlineStationInterval) + 1, this.config.centerlineStationInterval);\n\n // Transform all centerline points into vehicle frame\n const vehicleXform = vehicleTransform(vehiclePose);\n const centerline = centerlineRaw.map(c => { return { pos: c.pos.clone().applyMatrix3(vehicleXform), rot: c.rot - vehiclePose.rot, curv: c.curv } });\n\n const centerlineData = new Float32Array(centerline.length * 3);\n const maxPoint = new THREE.Vector2(0, 0);\n const minPoint = new THREE.Vector2(0, 0);\n\n for (let i = 0; i < centerline.length; i++) {\n const sample = centerline[i];\n const pos = sample.pos;\n centerlineData[i * 3 + 0] = pos.x;\n centerlineData[i * 3 + 1] = pos.y;\n centerlineData[i * 3 + 2] = sample.rot;\n\n maxPoint.max(pos);\n minPoint.min(pos);\n }\n\n const diff = maxPoint.clone().sub(minPoint);\n const xyCenterPoint = minPoint.clone().add(maxPoint).divideScalar(2);\n\n // Sizes of the xy grids (in pixels, not meters)\n const xyWidth = Math.ceil((diff.x + this.config.gridMargin * 2) / this.config.xyGridCellSize);\n const xyHeight = Math.ceil((diff.y + this.config.gridMargin * 2) / this.config.xyGridCellSize);\n\n const stationWidth = this.config.spatialHorizon + latticeStationInterval * 2;\n const slCenterPoint = new THREE.Vector2(this.config.spatialHorizon / 2, 0);\n\n // Sizes of the sl grids (in pixels, not meters)\n const slWidth = Math.ceil(stationWidth / this.config.slGridCellSize);\n const slHeight = Math.ceil((this.config.roadWidth + this.config.gridMargin * 2) / this.config.slGridCellSize);\n\n let startStation;\n\n if (this.previousStartStation === null || vehicleStation + latticeStationInterval / 2 > this.previousStartStation) {\n startStation = (this.previousStartStation === null ? vehicleStation : this.previousStartStation) + latticeStationInterval;\n this.previousStartStation = startStation;\n this.previousFirstLatticePoint -= this.config.lattice.numLatitudes;\n this.previousSecondLatticePoint -= this.config.lattice.numLatitudes;\n } else {\n startStation = this.previousStartStation;\n }\n\n const lattice = this._buildLattice(lanePath, startStation, vehiclePose.rot, vehicleXform);\n\n const temporalHorizon = this.config.spatialHorizon / this.config.speedLimit;\n const dynamicFrameTime = temporalHorizon / this.config.numDynamicFrames;\n\n for (const [i, p] of [\n xyObstacleGrid.update(this.config, xyWidth, xyHeight, xyCenterPoint, vehicleXform, staticObstacles),\n slObstacleGrid.update(this.config, slWidth, slHeight, slCenterPoint, xyCenterPoint),\n ...slObstacleGridDilation.update(this.config, slWidth, slHeight),\n slDynamicObstacleGrid.update(this.config, slWidth, slHeight, slCenterPoint, vehicleStation, startTime, dynamicFrameTime, dynamicObstacles),\n xyslMap.update(this.config, xyWidth, xyHeight, xyCenterPoint),\n ...optimizeCubicPaths.update(this.config, vehiclePose),\n optimizeQuinticPaths.update(this.config, vehiclePose),\n ...pathFromVehicleCosts.update(this.config, vehiclePose, xyCenterPoint, slCenterPoint, this.previousFirstLatticePoint, this.previousSecondLatticePoint, dynamicFrameTime),\n graphSearch.update(this.config, vehiclePose, xyCenterPoint, slCenterPoint, this.previousFirstLatticePoint, this.previousSecondLatticePoint, dynamicFrameTime)\n ].entries()) {\n this.gpgpu.updateProgram(i, p);\n }\n\n this.gpgpu.updateSharedTextures({\n centerline: {\n width: centerline.length,\n height: 1,\n channels: 3,\n filter: \'linear\',\n data: centerlineData\n },\n costTable: {\n width: PathPlanner_NUM_ACCELERATION_PROFILES * PathPlanner_NUM_VELOCITY_RANGES * PathPlanner_NUM_TIME_RANGES,\n height: this.config.lattice.numLatitudes,\n depth: this.config.lattice.numStations,\n channels: 4,\n textureType: \'2DArray\'\n },\n lattice: {\n width: this.config.lattice.numLatitudes,\n height: this.config.lattice.numStations,\n channels: 4,\n data: lattice\n }\n });\n\n this.gpgpu._graphSearchCostTable = null;\n this.gpgpu._dynamicObstacleGrid = null;\n\n let start = performance.now();\n const outputs = this.gpgpu.run();\n const costTable = this.gpgpu._graphSearchCostTable;\n const cubicPathParams = outputs[6];\n const cubicPathFromVehicleParams = outputs[7];\n const quinticPathFromVehicleParams = outputs[8];\n\n let bestEntry = [Number.POSITIVE_INFINITY];\n let bestEntryIndex;\n const numEntries = costTable.length / 4;\n\n for (let i = 0; i < numEntries; i++) {\n const entryUnpacked = this._unpackCostTableIndex(i);\n const entry = [\n costTable[i * 4],\n costTable[i * 4 + 1],\n costTable[i * 4 + 2],\n costTable[i * 4 + 3]\n ];\n\n if (entry[0] < 0) continue;\n\n entry[0] += this._terminalCost(entryUnpacked, entry);\n\n if (entry[0] < bestEntry[0]) {\n bestEntryIndex = i;\n bestEntry = entry;\n }\n }\n\n const inverseVehicleXform = (new THREE.Matrix3()).getInverse(vehicleXform);\n let bestTrajectory = null;\n let fromVehicleSegment = null;\n let fromVehicleParams = null;\n let firstLatticePoint = -1;\n let firstAcceleration = -1;\n let secondLatticePoint = -1;\n let secondAcceleration = -1;\n\n if (isFinite(bestEntry[0])) {\n [bestTrajectory, fromVehicleSegment, fromVehicleParams, firstLatticePoint, firstAcceleration, secondLatticePoint, secondAcceleration] = this._reconstructTrajectory(\n bestEntryIndex,\n costTable,\n cubicPathParams,\n cubicPathFromVehicleParams,\n quinticPathFromVehicleParams,\n vehiclePose,\n lattice\n );\n\n fromVehicleSegment.forEach(p => {\n p.pos = p.pos.applyMatrix3(inverseVehicleXform);\n p.rot += vehiclePose.rot;\n });\n\n bestTrajectory.forEach(p => {\n p.pos = p.pos.applyMatrix3(inverseVehicleXform);\n p.rot += vehiclePose.rot;\n });\n }\n\n this.previousFirstLatticePoint = firstLatticePoint;\n this.previousFirstAcceleration = firstAcceleration;\n this.previousSecondLatticePoint = secondLatticePoint;\n this.previousSecondAcceleration = secondAcceleration;\n\n return {\n path: bestTrajectory,\n fromVehicleSegment: fromVehicleSegment,\n fromVehicleParams: fromVehicleParams,\n latticeStartStation: this.previousStartStation,\n dynamicObstacleGrid: { data: this.gpgpu._dynamicObstacleGrid, width: slWidth, height: slHeight }\n };\n }\n\n _buildLattice(lanePath, startStation, vehicleRot, vehicleXform) {\n const centerline = lanePath.sampleStations(startStation, this.config.lattice.numStations, this._latticeStationInterval());\n const offset = Math.floor(this.config.lattice.numLatitudes / 2);\n const lattice = new Float32Array(this.config.lattice.numStations * this.config.lattice.numLatitudes * 4);\n let index = 0;\n\n for (let s = 0; s < centerline.length; s++) {\n const sample = centerline[s];\n\n for (let l = 0; l < this.config.lattice.numLatitudes; l++) {\n const latitude = (l - offset) / offset * this.config.roadWidth / 2;\n const rot = sample.rot - vehicleRot;\n const pos = THREE.Vector2.fromAngle(rot + Math.PI / 2).multiplyScalar(latitude).add(sample.pos.clone().applyMatrix3(vehicleXform));\n const curv = sample.curv == 0 ? 0 : 1 / (1 / sample.curv - latitude);\n\n lattice[index++] = pos.x;\n lattice[index++] = pos.y;\n lattice[index++] = rot;\n lattice[index++] = curv;\n }\n }\n\n return lattice;\n }\n\n _latticeStationInterval() {\n return this.config.spatialHorizon / this.config.lattice.numStations;\n }\n\n _terminalCost([stationIndex, latitudeIndex, timeIndex, velocityIndex, accelerationIndex], [cost, finalVelocity, finalTime, incomingIndex]) {\n // Only consider vertices that reach the end of the spatial or temporal horizon\n if (stationIndex != this.config.lattice.numStations - 1 && finalVelocity > 0.05)\n return Number.POSITIVE_INFINITY;\n\n const station = (this.config.spatialHorizon / this.config.lattice.numStations) * (stationIndex + 1);\n\n return station * -this.config.stationReachDiscount + finalTime * this.config.extraTimePenalty;\n }\n\n _unpackCostTableIndex(index) {\n if (index < 0) return [-1, index + 2, null, null, null];\n\n const numPerTime = PathPlanner_NUM_ACCELERATION_PROFILES * PathPlanner_NUM_VELOCITY_RANGES;\n const numPerLatitude = numPerTime * PathPlanner_NUM_TIME_RANGES;\n const numPerStation = this.config.lattice.numLatitudes * numPerLatitude;\n\n const stationIndex = Math.floor(index / numPerStation);\n index -= stationIndex * numPerStation;\n\n const latitudeIndex = Math.floor(index / numPerLatitude);\n index -= latitudeIndex * numPerLatitude;\n\n const timeIndex = Math.floor(index / numPerTime);\n index -= timeIndex * numPerTime;\n\n const velocityIndex = Math.floor(index / PathPlanner_NUM_ACCELERATION_PROFILES);\n const accelerationIndex = index % PathPlanner_NUM_ACCELERATION_PROFILES;\n\n return [stationIndex, latitudeIndex, timeIndex, velocityIndex, accelerationIndex];\n }\n\n _reconstructTrajectory(index, costTable, cubicPathParams, cubicPathFromVehicleParams, quinticPathFromVehicleParams, vehiclePose, lattice) {\n let unpacked = this._unpackCostTableIndex(index);\n unpacked.push(costTable[index * 4 + 1]);\n const nodes = [unpacked];\n\n let count = 0;\n while (unpacked[0] >= 0 && count++ < 100) {\n index = costTable[index * 4 + 3];\n unpacked = this._unpackCostTableIndex(index);\n\n const finalVelocity = unpacked[0] >= 0 ? costTable[index * 4 + 1] : vehiclePose.velocity;\n unpacked.push(finalVelocity);\n\n nodes.unshift(unpacked);\n }\n if (count >= 100) throw new Error(\'Infinite loop encountered while reconstructing trajectory.\');\n\n const points = [];\n let fromVehicleSegment = [];\n let fromVehicleParams = null;\n\n for (let i = 0; i < nodes.length - 1; i++) {\n const [prevStation, prevLatitude, _pt, _pv, _pa, prevVelocity] = nodes[i];\n const [station, latitude, _t, _v, _a, velocity] = nodes[i + 1];\n\n let length;\n let pathBuilder;\n\n if (prevStation < 0) {\n const start = {\n pos: new THREE.Vector2(0, 0),\n rot: 0,\n curv: vehiclePose.curv\n };\n\n const endIndex = (station * this.config.lattice.numLatitudes + latitude) * 4;\n const end = {\n pos: new THREE.Vector2(lattice[endIndex], lattice[endIndex + 1]),\n rot: lattice[endIndex + 2],\n curv: lattice[endIndex + 3]\n };\n\n if (prevLatitude == 0) { // Cubic path from vehicle to lattice node\n length = cubicPathFromVehicleParams[endIndex + 2];\n\n const params = {\n p1: cubicPathFromVehicleParams[endIndex],\n p2: cubicPathFromVehicleParams[endIndex + 1],\n sG: length\n };\n\n pathBuilder = new CubicPath(start, end, params);\n\n fromVehicleParams = { type: \'cubic\', params: params };\n } else { // Quintic path from vehicle to lattice node\n length = quinticPathFromVehicleParams[endIndex + 2];\n\n const params = {\n p3: quinticPathFromVehicleParams[endIndex],\n p4: quinticPathFromVehicleParams[endIndex + 1],\n sG: length\n };\n\n pathBuilder = new QuinticPath(start, end, params);\n\n fromVehicleParams = { type: \'quintic\', params: params };\n }\n } else {\n const startIndex = (prevStation * this.config.lattice.numLatitudes + prevLatitude) * 4;\n const endIndex = (station * this.config.lattice.numLatitudes + latitude) * 4;\n\n const start = {\n pos: new THREE.Vector2(lattice[startIndex], lattice[startIndex + 1]),\n rot: lattice[startIndex + 2],\n curv: lattice[startIndex + 3]\n };\n\n const end = {\n pos: new THREE.Vector2(lattice[endIndex], lattice[endIndex + 1]),\n rot: lattice[endIndex + 2],\n curv: lattice[endIndex + 3]\n };\n\n const slIndex = station * this.config.lattice.numLatitudes + latitude;\n const connectivityIndex = (prevStation - station + this.config.lattice.stationConnectivity) * this.config.lattice.latitudeConnectivity + prevLatitude - latitude + Math.floor(this.config.lattice.latitudeConnectivity / 2);\n const cubicPathIndex = (connectivityIndex * this.config.lattice.numStations * this.config.lattice.numLatitudes + slIndex) * 4;\n\n length = cubicPathParams[cubicPathIndex + 2];\n\n pathBuilder = new CubicPath(start, end, {\n p1: cubicPathParams[cubicPathIndex],\n p2: cubicPathParams[cubicPathIndex + 1],\n sG: length\n });\n }\n\n const path = pathBuilder.buildPath(Math.ceil(length / 0.25));\n\n const prevVelocitySq = prevVelocity * prevVelocity;\n const accel = (velocity * velocity - prevVelocitySq) / 2 / length;\n const ds = length / (path.length - 1);\n let s = 0;\n\n for (let p = 0; p < path.length; p++) {\n path[p].velocity = Math.sqrt(2 * accel * s + prevVelocitySq);\n path[p].acceleration = accel;\n s += ds;\n }\n\n if (prevStation < 0) {\n fromVehicleSegment = path;\n } else {\n if (i > 0) path.shift();\n points.push(...path);\n }\n }\n\n let firstLatticePoint = null\n let firstAcceleration = null;\n let secondLatticePoint = null;\n let secondAcceleration = null;\n\n if (nodes.length >= 2) {\n firstLatticePoint = nodes[1][0] * this.config.lattice.numLatitudes + nodes[1][1];\n firstAcceleration = nodes[1][4];\n }\n\n if (nodes.length >= 3) {\n secondLatticePoint = nodes[2][0] * this.config.lattice.numLatitudes + nodes[2][1];\n secondAcceleration = nodes[2][4];\n }\n\n return [points, fromVehicleSegment, fromVehicleParams, firstLatticePoint, firstAcceleration, secondLatticePoint, secondAcceleration];\n }\n}\n\nfunction vehicleTransform({ pos, rot }) {\n const translate = new THREE.Matrix3();\n translate.set(\n 1, 0, -pos.x,\n 0, 1, -pos.y,\n 0, 0, 1\n );\n\n const cosRot = Math.cos(rot);\n const sinRot = Math.sin(rot);\n\n const rotate = new THREE.Matrix3();\n rotate.set(\n cosRot, sinRot, 0,\n -sinRot, cosRot, 0,\n 0, 0, 1\n );\n\n return rotate.multiply(translate);\n}\n\nfunction obstacleTransform(vehicleXform, xyCenterPoint, width, height) {\n const translate = new THREE.Matrix3();\n translate.set(\n 1, 0, -xyCenterPoint.x,\n 0, 1, -xyCenterPoint.y,\n 0, 0, 1\n );\n\n const scale = new THREE.Matrix3();\n scale.set(\n 2 / width, 0, 0,\n 0, 2 / height, 0,\n 0, 0, 1\n );\n\n return scale.multiply(translate).multiply(vehicleXform);\n}\n\n;// CONCATENATED MODULE: ./js/autonomy/MovingAverage.js\nclass MovingAverage {\n constructor(maxSamples) {\n this.samples = new Array(maxSamples);\n this.numSamples = 0;\n this.nextIndex = 0;\n this.average = null;\n }\n\n addSample(sample) {\n this.samples[this.nextIndex++] = sample;\n this.nextIndex = this.nextIndex % this.samples.length;\n this.numSamples = Math.min(this.numSamples + 1, this.samples.length);\n\n const k = 2 / (this.numSamples + 1);\n let curr = this.nextIndex % this.numSamples;\n let newAverage = this.samples[curr];\n\n for (let i = 1; i < this.numSamples; i++) {\n curr = (curr + 1) % this.numSamples;\n newAverage = this.samples[curr] * k + newAverage * (1 - k);\n }\n\n this.average = newAverage;\n }\n}\n\n// EXTERNAL MODULE: ./node_modules/script-loader/index.js!./js/Utils.js\nvar Utils = __webpack_require__(172);\n;// CONCATENATED MODULE: ./js/Simulator.js\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nconst WELCOME_MODAL_KEY = \'dash_WelcomeModal\';\n\n\n\nclass Simulator {\n constructor(domElement) {\n this.pathPlannerWorker = new Worker(URL.createObjectURL(new Blob([`(${dash_initPathPlannerWorker.toString()})()`], { type: \'text/javascript\' })));\n this.pathPlannerWorker.onmessage = this.receivePlannedPath.bind(this);\n this.pathPlannerConfigEditor = new PathPlannerConfigEditor();\n\n this.physics = new Physics();\n this.car = this.physics.createCar();\n\n this.renderer = new THREE.WebGLRenderer({ antialias: true });\n this.renderer.setPixelRatio(window.devicePixelRatio);\n this.renderer.setSize(domElement.clientWidth, domElement.clientHeight);\n this.renderer.shadowMap.enabled = true;\n domElement.appendChild(this.renderer.domElement);\n\n this.lastPlanParams = null;\n this.renderer.context.canvas.addEventListener(\'webglcontextlost\', event => {\n console.log(\'Simulator: webgl context lost\');\n console.log(event);\n console.log(this.lastPlanParams);\n });\n\n this._setUpCameras(this.renderer.domElement);\n\n this.scene = new THREE.Scene();\n this.sceneFog = null;//new THREE.FogExp2(0x111111, 0.0025);\n this.scene.fog = this.sceneFog;\n this.scene.background = new THREE.Color(0x111111);\n\n this.editor = new Editor(this.renderer.domElement, this.editorCamera, this.scene);\n\n const geolocation = null;//[33.523900, -111.908756];\n const map = new MapObject(geolocation);\n this.scene.add(map);\n\n this.carObject = new CarObject(this.car);\n this.scene.add(this.carObject);\n\n this.scene.add(new THREE.AmbientLight(0x666666));\n const light = new THREE.DirectionalLight(0xffffff, 0.75);\n light.position.set(1, 1, 1).normalize();\n this.scene.add(light);\n\n this.manualCarController = new ManualController();\n this.autonomousCarController = null;\n\n this.dashboard = new Dashboard(this.car);\n\n this.plannerReady = false;\n this.plannerRunning = false;\n this.plannerReset = false;\n this.carStation = null;\n this.plannedPathGroup = new THREE.Group();\n this.scene.add(this.plannedPathGroup);\n\n this.staticObstaclesGroup = new THREE.Group();\n this.scene.add(this.staticObstaclesGroup);\n this.dynamicObstaclesGroup = new THREE.Group();\n this.scene.add(this.dynamicObstaclesGroup);\n\n this.paused = false;\n this.prevTimestamp = null;\n this.frameCounter = 0;\n this.fpsTime = 0;\n this.fps = 0;\n this.simulatedTime = 0;\n this.lastPlanRequestTime = null;\n this.latestPlanTimestamp = null;\n this.averagePlanTime = new MovingAverage(20);\n\n window.addEventListener(\'resize\', e => {\n this._updateCameraAspects(domElement.clientWidth / domElement.clientHeight);\n this.renderer.setSize(domElement.clientWidth, domElement.clientHeight);\n });\n\n window.addEventListener(\'hashchange\', e => {\n if (window.location.hash.startsWith(\'#/s/\'))\n window.location.reload();\n });\n\n this.manualModeButton = document.getElementById(\'mode-manual\');\n this.manualModeButton.addEventListener(\'click\', this.enableManualMode.bind(this));\n this.autonomousModeButton = document.getElementById(\'mode-autonomous\');\n this.autonomousModeButton.addEventListener(\'click\', this.enableAutonomousMode.bind(this));\n\n document.getElementById(\'editor-enable\').addEventListener(\'click\', this.enableEditor.bind(this));\n document.getElementById(\'editor-finalize\').addEventListener(\'click\', this.finalizeEditor.bind(this));\n document.getElementById(\'simulator-load\').addEventListener(\'click\', this.loadScenario.bind(this));\n\n this.scenarioPlayButton = document.getElementById(\'scenario-play\');\n this.scenarioPlayButton.addEventListener(\'click\', this.playScenario.bind(this));\n this.scenarioPauseButton = document.getElementById(\'scenario-pause\');\n this.scenarioPauseButton.addEventListener(\'click\', this.pauseScenario.bind(this));\n for (const btn of document.querySelectorAll(\'[id=scenario-restart]\')) {\n btn.addEventListener(\'click\', this.restartScenario.bind(this));\n }\n\n this.welcomeModal = document.getElementById(\'welcome-modal\');\n document.getElementById(\'show-welcome-modal\').addEventListener(\'click\', e => this.welcomeModal.classList.add(\'is-active\'));\n\n // if (window.localStorage.getItem(WELCOME_MODAL_KEY) !== \'hide\') {\n // this.welcomeModal.classList.add(\'is-active\');\n // }\n\n this.collisionMessage = document.getElementById(\'collision-message\');\n this.successMessage = document.getElementById(\'success-message\');\n // If the click was outside the div, hide it\n document.addEventListener("click", this.setHideCollisionMessageOnClickOutside.bind(this));\n\n document.getElementById(\'welcome-modal-background\').addEventListener(\'click\', this.hideWelcomeModal.bind(this));\n document.getElementById(\'welcome-modal-close\').addEventListener(\'click\', this.hideWelcomeModal.bind(this));\n\n document.getElementById(\'welcome-modal-examples\').addEventListener(\'click\', e => {\n this.welcomeModal.classList.remove(\'is-active\');\n this.loadScenario();\n this.editor.scenarioManager.switchTab(this.editor.scenarioManager.examplesTab);\n });\n\n document.getElementById(\'welcome-modal-create\').addEventListener(\'click\', e => {\n this.welcomeModal.classList.remove(\'is-active\');\n this.enableEditor();\n });\n\n this.simModeBoxes = Array.prototype.slice.call(document.getElementsByClassName(\'sim-mode-box\'), 0);\n this.editModeBoxes = Array.prototype.slice.call(document.getElementsByClassName(\'edit-mode-box\'), 0);\n\n this.fpsBox = document.getElementById(\'fps\');\n\n this.enableManualMode();\n this.changeCamera(\'chase\');\n\n this.aroundAnchorIndex = null;\n this.staticObstacles = [];\n this.dynamicObstacles = [];\n\n this._checkHashScenario();\n\n requestAnimationFrame(this.step.bind(this));\n\n this.editor.scenarioManager._loadScenario(examples[2]);\n this.finalizeEditor();\n }\n\n toss() {\n const pose = this.car.pose;\n const rotVec = THREE.Vector2.fromAngle(pose.rot);\n const pos = rotVec.clone().multiplyScalar(50).add(new THREE.Vector2(rotVec.y, rotVec.x)).add(pose.pos);\n const obstacle = new StaticObstacle(pos, 0, 1.0, 1.0);\n\n const obsGeom = new THREE.PlaneGeometry(obstacle.width, obstacle.height);\n const obsMat = new THREE.MeshBasicMaterial({ color: 0x0000ff, depthTest: false, transparent: true, opacity: 0.5 });\n const obsObj = new THREE.Mesh(obsGeom, obsMat);\n obsObj.rotation.x = -Math.PI / 2;\n obsObj.rotation.z = -obstacle.rot;\n obsObj.position.set(obstacle.pos.x, 0, obstacle.pos.y);\n this.scene.add(obsObj);\n\n this.staticObstacles.push(obstacle);\n }\n\n _checkHashScenario() {\n if (!window.location.hash.startsWith(\'#/s/\')) return;\n\n const [_hash, _s, code] = window.location.hash.split(\'/\');\n\n try {\n const json = JSON.parse(atob(decodeURIComponent(code)));\n this.editor.loadJSON(json);\n this.finalizeEditor();\n this.welcomeModal.classList.remove(\'is-active\');\n window.location.hash = \'\';\n } catch (e) {\n console.log(\'Error importing scenario code:\');\n console.log(code);\n console.log(e);\n }\n }\n\n _setUpCameras(domElement) {\n this.chaseCamera = new THREE.PerspectiveCamera(55, domElement.clientWidth / domElement.clientHeight, 1, 10000);\n this.chaseCameraControls = new simulator_OrbitControls(this.chaseCamera, domElement);\n this.chaseCameraControls.minDistance = 4;\n this.chaseCameraControls.maxDistance = 5000;\n this.chaseCameraControls.maxPolarAngle = Math.PI / 2.02;\n this.chaseCameraControls.enablePan = false;\n this.chaseCameraControls.enabled = false;\n this._resetChaseCamera();\n\n this.freeCamera = new THREE.PerspectiveCamera(55, domElement.clientWidth / domElement.clientHeight, 1, 10000);\n this.freeCameraControls = new simulator_OrbitControls(this.freeCamera, domElement);\n this.freeCameraControls.minDistance = 5;\n this.freeCameraControls.maxDistance = 5000;\n this.freeCameraControls.maxPolarAngle = Math.PI / 2.02;\n this.freeCameraControls.enabled = true;\n this._resetFreeCamera();\n\n this.topDownCamera = new THREE.PerspectiveCamera(55, domElement.clientWidth / domElement.clientHeight, 1, 10000);\n this.topDownCamera.position.set(0, 50, 0);\n this.topDownCamera.lookAt(0, 0, 0);\n this.topDownControls = new TopDownCameraControls(domElement, this.topDownCamera);\n this.topDownControls.enabled = false;\n this.topDownControls.minAltitude = 5;\n this.topDownControls.maxAltitude = 10000;\n\n this.editorCamera = new THREE.PerspectiveCamera(45, domElement.clientWidth / domElement.clientHeight, 1, 10000);\n this.editorCamera.layers.enable(2);\n this.editorCamera.position.set(0, 200, 0);\n this.editorCamera.lookAt(0, 0, 0);\n this.editorCameraControls = new TopDownCameraControls(domElement, this.editorCamera);\n this.editorCameraControls.enabled = false;\n this.editorCameraControls.enablePanning = true;\n this.editorCameraControls.minAltitude = 10;\n this.editorCameraControls.maxAltitude = 10000;\n\n this.cameraButtons = {};\n\n [\'free\', \'chase\', \'topDown\'].forEach(c => {\n const cameraButton = document.getElementById(`camera-${c}`);\n cameraButton.addEventListener(\'click\', () => this.changeCamera(c));\n this.cameraButtons[c] = cameraButton;\n });\n\n this.switchTo2DButton = document.getElementById(\'camera-2D\');\n this.switchTo2DButton.addEventListener(\'click\', this.switchTo2D.bind(this));\n this.switchTo3DButton = document.getElementById(\'camera-3D\');\n this.switchTo3DButton.addEventListener(\'click\', this.switchTo3D.bind(this));\n\n this.switchTo3D();\n }\n\n _resetFreeCamera() {\n this.freeCameraControls.position0.copy(this.chaseCamera.position);\n const carPosition = this.car.position;\n this.freeCameraControls.target0.set(carPosition.x, 0, carPosition.y);\n this.freeCameraControls.reset();\n }\n\n _resetChaseCamera() {\n const pos = this.car.position;\n const dirVector = THREE.Vector2.fromAngle(this.car.rotation).multiplyScalar(-20);\n this.chaseCamera.position.set(pos.x + dirVector.x, 8, pos.y + dirVector.y);\n this.chaseCamera.lookAt(pos.x, 0, pos.y);\n }\n\n _resetTopDownCamera() {\n const carPosition = this.car.position;\n this.topDownCamera.position.set(carPosition.x, 50, carPosition.y);\n this.topDownCamera.rotation.z = -this.car.rotation - Math.PI / 2\n }\n\n _updateCameraAspects(aspect) {\n this.freeCamera.aspect = aspect;\n this.freeCamera.updateProjectionMatrix();\n this.chaseCamera.aspect = aspect;\n this.chaseCamera.updateProjectionMatrix();\n this.topDownCamera.aspect = aspect;\n this.topDownCamera.updateProjectionMatrix();\n this.editorCamera.aspect = aspect;\n this.editorCamera.updateProjectionMatrix();\n }\n\n enableEditor() {\n this.editor.enabled = true;\n this.plannerRunning = false;\n\n this.previousCamera = this.camera;\n this.camera = this.editorCamera;\n this.editorCameraControls.enabled = true;\n this.chaseCameraControls.enabled = false;\n this.topDownControls.enabled = false;\n this.freeCameraControls.enabled = false;\n\n this.scene.fog = null;\n this.carObject.visible = false;\n if (this.plannedPathGroup) this.plannedPathGroup.visible = false;\n this.staticObstaclesGroup.visible = false;\n this.dynamicObstaclesGroup.visible = false;\n\n this.simModeBoxes.forEach(el => el.classList.add(\'is-hidden\'));\n this.editModeBoxes.forEach(el => el.classList.remove(\'is-hidden\'));\n\n this.showPlannerUnavailable(false);\n }\n\n finalizeEditor(replaceCamera = true) {\n this.editor.enabled = false;\n this.editorCameraControls.enabled = false;\n\n this.latestPlanTimestamp = null;\n this.prevTimestamp = null;\n\n this.scene.fog = this.sceneFog;\n this.carObject.visible = true;\n\n this.simModeBoxes.forEach(el => el.classList.remove(\'is-hidden\'));\n this.editModeBoxes.forEach(el => el.classList.add(\'is-hidden\'));\n\n if (this.editor.lanePath.anchors.length > 1) {\n const centerline = this.editor.lanePath.centerline;\n const pos = centerline[0].clone();\n const dir = centerline[1].clone().sub(centerline[0]);\n const rot = Math.atan2(dir.y, dir.x);\n const perpindicular = rot + Math.PI / 2 * (Math.sign(this.editor.lanePreference) || 0);\n const latitude = this.pathPlannerConfigEditor.config.roadWidth / 4;\n\n this.car.setPose(pos.x + Math.cos(perpindicular) * latitude, pos.y + Math.sin(perpindicular) * latitude, rot);\n this.car.velocity = this.editor.initialSpeed;\n\n this.dynamicObstacles = this.editor.dynamicObstacles;\n\n // The `false` value means the controller is waiting to be created after the first planning cycle.\n // This signals the simulator to use neutral controls instead of the hard brake used for the `null` value.\n this.autonomousCarController = false;\n this.enableAutonomousMode();\n\n if (!this.plannerRunning) {\n this.plannerReady = true;\n this.plannerRunning = true;\n }\n this.plannerReset = true;\n this.simulatedTime = 0;\n this.carStation = 0;\n this.aroundAnchorIndex = null;\n\n this.pauseScenario();\n this.autonomousModeButton.classList.add(\'is-loading\');\n this.waitingForFirstPlan = true;\n } else {\n this.dynamicObstacles = [];\n }\n\n this.staticObstacles = this.editor.staticObstacles;\n this.recreateStaticObstacleObjects();\n this.recreateDynamicObstacleObjects();\n\n this.dashboard.update({ steer: 0, brake: 0, gas: 0 }, this.car.velocity, null, null, 0, this.averagePlanTime.average);\n\n if (replaceCamera) {\n this.camera = this.previousCamera;\n\n if (this.previousCamera == this.chaseCamera)\n this.chaseCameraControls.enabled = true;\n else if (this.previousCamera == this.topDownCamera)\n this.topDownControls.enabled = true;\n else if (this.previousCamera == this.freeCamera)\n this.freeCameraControls.enabled = true;\n else\n this.changeCamera(\'chase\');\n }\n\n this._resetFreeCamera();\n this._resetChaseCamera();\n this._resetTopDownCamera();\n }\n\n recreateStaticObstacleObjects() {\n this.scene.remove(this.staticObstaclesGroup);\n this.staticObstaclesGroup = new THREE.Group();\n this.scene.add(this.staticObstaclesGroup);\n\n this.staticObstacles.forEach(o => {\n const obstacleObject = new StaticObstacleObject(o);\n this.staticObstaclesGroup.add(obstacleObject);\n });\n }\n\n recreateDynamicObstacleObjects() {\n this.scene.remove(this.dynamicObstaclesGroup);\n this.dynamicObstaclesGroup = new THREE.Group();\n this.scene.add(this.dynamicObstaclesGroup);\n\n this.dynamicObstacles.forEach(o => {\n const obstacleObject = new DynamicObstacleObject(o, this.editor.lanePath);\n this.dynamicObstaclesGroup.add(obstacleObject);\n });\n\n this.updateDynamicObjects(this.simulatedTime);\n }\n\n updateDynamicObjects(time) {\n this.dynamicObstaclesGroup.children.forEach(o => o.update(time));\n }\n\n playScenario() {\n this.paused = false;\n this.scenarioPlayButton.classList.add(\'is-hidden\');\n this.scenarioPauseButton.classList.remove(\'is-hidden\');\n this.showPlannerUnavailable(false);\n }\n\n pauseScenario() {\n this.paused = true;\n this.scenarioPlayButton.classList.remove(\'is-hidden\');\n this.scenarioPauseButton.classList.add(\'is-hidden\');\n\n this.showPlannerUnavailable(false);\n this.waitingForFirstPlan = false;\n }\n\n restartScenario() {\n if (this.editor.enabled) return;\n\n if (this.plannedPathGroup)\n this.scene.remove(this.plannedPathGroup);\n\n this.finalizeEditor(false);\n\n this.successMessage.classList.remove(\'is-active\');\n this.collisionMessage.classList.remove(\'is-active\');\n\n this.latestPlanTimestamp = null;\n this.showPlannerUnavailable(false);\n }\n\n loadScenario() {\n if (this.editor.enabled) return;\n\n this.editor.scenarioManager.showModal(this.finalizeEditor.bind(this));\n }\n\n enableManualMode() {\n this.manualModeButton.classList.remove(\'is-outlined\');\n this.manualModeButton.classList.add(\'is-selected\');\n this.autonomousModeButton.classList.add(\'is-outlined\', \'is-inverted\');\n this.autonomousModeButton.classList.remove(\'is-selected\', \'is-link\');\n\n this.carControllerMode = \'manual\';\n\n this.showPlannerUnavailable(false);\n }\n\n enableAutonomousMode() {\n this.autonomousModeButton.classList.remove(\'is-outlined\', \'is-inverted\');\n this.autonomousModeButton.classList.add(\'is-selected\', \'is-link\');\n this.manualModeButton.classList.add(\'is-outlined\');\n this.manualModeButton.classList.remove(\'is-selected\');\n\n this.carControllerMode = \'autonomous\';\n }\n\n changeCamera(mode) {\n if (this.editor.enabled) return;\n\n switch (mode) {\n case "free":\n this.chaseCameraControls.enabled = false;\n this.topDownControls.enabled = false;\n this.freeCameraControls.enabled = true;\n\n if (this.camera == this.freeCamera)\n this._resetFreeCamera();\n else\n this.camera = this.freeCamera;\n\n break;\n case "chase":\n this.freeCameraControls.enabled = false;\n this.topDownControls.enabled = false;\n this.chaseCameraControls.enabled = true;\n\n if (this.camera == this.chaseCamera)\n this._resetChaseCamera();\n else\n this.camera = this.chaseCamera;\n\n break;\n case "topDown":\n this.freeCameraControls.enabled = false;\n this.chaseCameraControls.enabled = false;\n this.topDownControls.enabled = true;\n\n if (this.camera == this.topDownCamera)\n this._resetTopDownCamera();\n else\n this.camera = this.topDownCamera;\n\n break;\n default:\n console.log(`Unknown camera mode: ${mode}`);\n return;\n }\n\n for (const c in this.cameraButtons) {\n const classes = this.cameraButtons[c].classList;\n if (c == mode) {\n classes.remove(\'is-outlined\');\n classes.add(\'is-selected\');\n } else {\n classes.add(\'is-outlined\');\n classes.remove(\'is-selected\');\n }\n }\n }\n\n switchTo2D() {\n this.switchTo2DButton.classList.remove(\'is-outlined\');\n this.switchTo2DButton.classList.add(\'is-selected\');\n this.switchTo3DButton.classList.add(\'is-outlined\');\n this.switchTo3DButton.classList.remove(\'is-selected\');\n\n this.chaseCamera.layers.enable(2);\n this.topDownCamera.layers.enable(2);\n this.freeCamera.layers.enable(2);\n this.chaseCamera.layers.disable(3);\n this.topDownCamera.layers.disable(3);\n this.freeCamera.layers.disable(3);\n }\n\n switchTo3D() {\n this.switchTo3DButton.classList.remove(\'is-outlined\');\n this.switchTo3DButton.classList.add(\'is-selected\');\n this.switchTo2DButton.classList.add(\'is-outlined\');\n this.switchTo2DButton.classList.remove(\'is-selected\');\n\n this.chaseCamera.layers.enable(3);\n this.topDownCamera.layers.enable(3);\n this.freeCamera.layers.enable(3);\n this.chaseCamera.layers.disable(2);\n this.topDownCamera.layers.disable(2);\n this.freeCamera.layers.disable(2);\n }\n\n hideWelcomeModal() {\n this.welcomeModal.classList.remove(\'is-active\');\n window.localStorage.setItem(WELCOME_MODAL_KEY, \'hide\');\n }\n\n showPlannerUnavailable(show) {\n const message = document.getElementById("planner-unavailable-message");\n if (show) {\n message.classList.add(\'is-active\');\n this.autonomousModeButton.classList.add(\'is-loading\');\n } else {\n message.classList.remove(\'is-active\');\n this.autonomousModeButton.classList.remove(\'is-loading\');\n }\n }\n\n setHideCollisionMessageOnClickOutside() {\n if (!this.collisionMessage.contains(event.target)) {\n this.collisionMessage.classList.remove(\'is-active\');\n }\n if (!this.successMessage.contains(event.target)) {\n this.successMessage.classList.remove(\'is-active\');\n }\n }\n\n startPlanner(pose, station) {\n this.plannerReady = false;\n this.lastPlanRequestTime = performance.now();\n\n // In order to create a stable trajectory between successive planning\n // cycles, we must compensate for the latency between when a planning cycle\n // starts and when it ends. The average planning time is used to forward\n // simulate the vehicle to the pose it is expected to have when the\n // planning actually finishes.\n\n let predictedPose = pose;\n let predictedStation = station;\n let startTime = this.simulatedTime;\n\n if (!this.plannerReset && !this.paused && this.autonomousCarController && this.carControllerMode == \'autonomous\') {\n const latency = this.averagePlanTime.average;\n predictedPose = this.autonomousCarController.predictPoseAfterTime(pose, latency);\n predictedStation = this.editor.lanePath.stationLatitudeFromPosition(predictedPose.pos, this.aroundAnchorIndex)[0];\n startTime += latency;\n }\n\n const reset = this.plannerReset;\n this.plannerReset = false;\n\n this.lastPlanParams = {\n type: \'plan\',\n config: Object.assign({}, this.pathPlannerConfigEditor.config, { speedLimit: this.editor.speedLimit, lanePreference: this.editor.lanePreference }),\n vehiclePose: predictedPose,\n vehicleStation: predictedStation,\n lanePath: this.editor.lanePath,\n startTime: startTime,\n staticObstacles: this.staticObstacles,\n dynamicObstacles: this.dynamicObstacles.filter(o => o.positionAtTime(startTime).x >= 0),\n reset: reset\n };\n\n this.pathPlannerWorker.postMessage(this.lastPlanParams);\n }\n\n receivePlannedPath(event) {\n if (event.data.error) {\n if (event.data.error === "planner_unavailable" && !this.paused) {\n this.showPlannerUnavailable(true);\n }\n //document.getElementById(\'planner-error\').classList.remove(\'is-hidden\')\n return;\n }\n\n this.showPlannerUnavailable(false);\n\n this.latestPlanTimestamp = performance.now();\n\n if (this.waitingForFirstPlan && !this.plannerReset) {\n this.waitingForFirstPlan = false;\n this.autonomousModeButton.classList.remove(\'is-loading\');\n this.playScenario();\n }\n\n if (this.editor.enabled) return;\n\n const { fromVehicleParams, vehiclePose, vehicleStation, latticeStartStation, config, dynamicObstacleGrid } = event.data;\n let { path, fromVehicleSegment } = event.data;\n\n const planningDuration = Math.min((this.latestPlanTimestamp - this.lastPlanRequestTime) / 1000, 0.3);\n this.averagePlanTime.addSample(planningDuration);\n this.plannerReady = true;\n\n if (this.plannerReset) return;\n\n if (this.plannedPathGroup)\n this.scene.remove(this.plannedPathGroup);\n this.plannedPathGroup = new THREE.Group();\n this.scene.add(this.plannedPathGroup);\n\n const circleGeom = new THREE.CircleGeometry(0.1, 32);\n const circleMat = new THREE.MeshBasicMaterial({ color: 0x00ff80, transparent: true, opacity: 0.7 });\n\n if (latticeStartStation) {\n const lattice = new RoadLattice(this.editor.lanePath, latticeStartStation, config);\n lattice.lattice.forEach(cells => {\n cells.forEach(c => {\n const circle = new THREE.Mesh(circleGeom, circleMat);\n circle.position.set(c.pos.x, 0, c.pos.y);\n circle.rotation.x = -Math.PI / 2;\n this.plannedPathGroup.add(circle);\n });\n });\n }\n\n // TODO: clear this up or just remove it\n if (false) {}\n\n if (path === null) {\n this.autonomousCarController = null;\n return;\n }\n\n if (fromVehicleParams.type == \'cubic\') {\n const start = this.car.pose;\n const end = fromVehicleSegment[fromVehicleSegment.length - 1];\n\n const pathBuilder = new CubicPath_CubicPath(start, end, fromVehicleParams.params);\n\n if (pathBuilder.optimize()) {\n fromVehicleSegment = pathBuilder.buildPath(Math.ceil(pathBuilder.params.sG / 0.25));\n\n const prevVelocitySq = this.car.velocity * this.car.velocity;\n const accel = (end.velocity * end.velocity - prevVelocitySq) / 2 / pathBuilder.params.sG;\n const ds = pathBuilder.params.sG / (fromVehicleSegment.length - 1);\n let s = 0;\n\n for (let p = 0; p < fromVehicleSegment.length; p++) {\n fromVehicleSegment[p].velocity = Math.sqrt(2 * accel * s + prevVelocitySq);\n fromVehicleSegment[p].acceleration = accel;\n s += ds;\n }\n }\n }\n\n if (fromVehicleSegment.length > 0) {\n path = fromVehicleSegment.concat(path);\n }\n\n path.forEach(p => Object.setPrototypeOf(p.pos, THREE.Vector2.prototype));\n const followPath = new Path(path);\n\n if (this.autonomousCarController)\n this.autonomousCarController.replacePath(followPath);\n else\n this.autonomousCarController = new FollowController(followPath, this.car);\n\n const pathGeometry = new THREE.Geometry();\n pathGeometry.setFromPoints(path.map(p => new THREE.Vector3(p.pos.x, 0, p.pos.y)));\n const pathLine = new MeshLine();\n pathLine.setGeometry(pathGeometry);\n\n const color = fromVehicleParams.type == \'cubic\' ? new THREE.Color(0xff8800) : new THREE.Color(0xffff40);\n const pathObject = new THREE.Mesh(\n pathLine.geometry,\n new MeshLineMaterial({\n color: color,\n lineWidth: 0.15,\n resolution: new THREE.Vector2(this.renderer.domElement.clientWidth, this.renderer.domElement.clientHeight)\n })\n );\n pathObject.renderOrder = 1;\n this.plannedPathGroup.add(pathObject);\n }\n\n _hasCarStaticObstacleCollision(carRectangle) {\n for (const obstacle of this.staticObstacles) {\n const obstacleRectangle = {\n x: obstacle.pos.x,\n y: obstacle.pos.y,\n width: obstacle.width,\n height: obstacle.height,\n angle: obstacle.rot,\n };\n if (areRectanglesColliding(carRectangle, obstacleRectangle)) {\n return true;\n }\n }\n }\n\n _hasCarDynamicObstacleCollision(carRectangle) {\n for (const obstacle of this.dynamicObstaclesGroup.children) {\n const positoin_at_time = obstacle.position\n const obstacleRectangle = {\n x: positoin_at_time.x,\n y: positoin_at_time.z,\n width: obstacle.size.w + 0.4, // 30 cm is collision buffer\n height: obstacle.size.h + 0.4,\n angle: obstacle.rotation.y,\n };\n if (areRectanglesColliding(carRectangle, obstacleRectangle)) {\n return true;\n }\n }\n }\n\n _hasCarOutOfRoadCollision(carRectangle) {\n for (const left_boundary of this.editor.lanePath.leftBoundaries) {\n if (checkRectanglePolylineIntersection(carRectangle, left_boundary)) {\n return true;\n }\n }\n\n for (const right_boundary of this.editor.lanePath.rightBoundaries) {\n if (checkRectanglePolylineIntersection(carRectangle, right_boundary)) {\n return true;\n }\n }\n\n return false;\n }\n\n hasAnyCollisions() {\n const carRectangle = {\n x: this.car.position.x,\n y: this.car.position.y,\n height: Car_Car.HALF_CAR_WIDTH * 2,\n width: Car_Car.HALF_CAR_LENGTH * 2,\n angle: this.car.pose.rot,\n };\n\n if (this._hasCarStaticObstacleCollision(carRectangle)) {\n return "Collision with static object";\n }\n if (this._hasCarDynamicObstacleCollision(carRectangle)) {\n return "Collision with bot";\n }\n if (this._hasCarOutOfRoadCollision(carRectangle)) {\n return "Out of road";\n }\n\n return null;\n }\n\n checkScenarioCompletion() {\n return this.carStation >= this.editor.lanePath.arcLength - 5.0;\n }\n\n step(timestamp) {\n if (this.prevTimestamp == null) {\n this.prevTimestamp = timestamp;\n requestAnimationFrame(this.step.bind(this));\n return;\n }\n\n // plan is outdated, should pause simulation\n const planWaitingThreshold = 0.3; // path expected to be updated once in 300ms\n const timeSinceLastPlanUpdate =\n this.latestPlanTimestamp != null ? (performance.now() - this.latestPlanTimestamp) / 1000.0 : 0; // in ms\n if (!this.editor.enabled &&\n (this.waitingForFirstPlan || (!this.paused && timeSinceLastPlanUpdate > planWaitingThreshold))) {\n this.showPlannerUnavailable(true);\n this.prevTimestamp = timestamp;\n }\n const dt = (timestamp - this.prevTimestamp) / 1000;\n\n this.editor.update();\n\n // skip simulation when dt is not in valid expected range\n if (!this.editor.enabled && !this.paused && dt > 1e-6 && dt < 0.5) {\n this.showPlannerUnavailable(false);\n\n this.simulatedTime += dt;\n\n const prevCarPosition = this.car.position;\n const prevCarRotation = this.car.rotation;\n\n const manualControls = this.manualCarController.control(this.car.pose, this.car.wheelAngle, this.car.velocity, dt);\n if (manualControls.steer != 0 || manualControls.brake != 0 || manualControls.gas != 0)\n this.enableManualMode();\n\n let autonomousControls = { steer: 0, brake: 0, gas: 0};\n if (this.autonomousCarController)\n autonomousControls = this.autonomousCarController.control(this.car.pose, this.car.wheelAngle, this.car.velocity, dt, this.carControllerMode == \'autonomous\') ;\n else if (this.autonomousCarController === null)\n autonomousControls = { steer: 0, brake: 1, gas: 0 };\n\n const controls = this.carControllerMode == \'autonomous\' ? autonomousControls : manualControls;\n\n this.car.update(controls, dt);\n this.physics.step(dt);\n\n this.updateDynamicObjects(this.simulatedTime);\n\n const carPosition = this.car.position;\n const carRotation = this.car.rotation;\n const carRearAxle = this.car.rearAxlePosition;\n const carVelocity = this.car.velocity;\n\n const positionOffset = { x: carPosition.x - prevCarPosition.x, y: 0, z: carPosition.y - prevCarPosition.y };\n this.chaseCamera.position.add(positionOffset);\n this.chaseCameraControls.target.set(carPosition.x, 0, carPosition.y);\n this.chaseCameraControls.rotateLeft(carRotation - prevCarRotation);\n this.chaseCameraControls.update();\n\n this.topDownCamera.position.setX(carPosition.x);\n this.topDownCamera.position.setZ(carPosition.y);\n this.topDownCamera.rotation.z = -carRotation - Math.PI / 2\n\n let latitude = null;\n\n if (this.editor.lanePath.anchors.length > 1) {\n const [s, l, aroundAnchorIndex] = this.editor.lanePath.stationLatitudeFromPosition(carRearAxle, this.aroundAnchorIndex);\n this.aroundAnchorIndex = aroundAnchorIndex;\n\n this.carStation = s;\n latitude = l;\n }\n\n const any_collision = this.hasAnyCollisions();\n if (any_collision != null) {\n this.pauseScenario();\n this.collisionMessage.classList.add(\'is-active\');\n document.getElementById(\'collision-message-text\').innerText = "Case failed: " + any_collision;\n\n this.pathPlannerWorker.postMessage({\n type: \'notify_case_status\',\n status: {status: "failed", reason: any_collision}\n });\n\n } else if (this.checkScenarioCompletion()) {\n this.pauseScenario();\n this.successMessage.classList.add(\'is-active\');\n\n this.pathPlannerWorker.postMessage({\n type: \'notify_case_status\',\n status: {status: "completed"}\n });\n }\n\n this.dashboard.update(\n controls,\n carVelocity,\n this.carStation,\n latitude,\n this.simulatedTime,\n this.averagePlanTime.average);\n }\n\n if (!this.editor.enabled && this.plannerReady) {\n this.startPlanner(this.car.pose, this.carStation || 0);\n this.dashboard.updatePlanTime(this.averagePlanTime.average);\n } else if (!this.plannerReady) {\n this.dashboard.updatePlanTime(timeSinceLastPlanUpdate);\n }\n\n this.frameCounter++;\n this.fpsTime += dt;\n if (this.fpsTime >= 1) {\n this.fps = this.frameCounter / this.fpsTime;\n this.frameCounter = 0;\n this.fpsTime = 0;\n this.fpsBox.textContent = this.fps.toFixed(1);\n }\n\n this.renderer.render(this.scene, this.camera);\n\n this.prevTimestamp = timestamp;\n\n requestAnimationFrame(this.step.bind(this));\n }\n}\n\n;// CONCATENATED MODULE: ./js/Dash.js\n\n\n\ndocument.addEventListener(\'DOMContentLoaded\', e => {\n window.simulator = new Simulator(document.getElementById(\'container\'));\n});\n//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"236.js","mappings":";;AAAe,MAAM,OAAG;AACxB;AACA;AACA;;AAEA;AACA,uDAAuD,OAAG;AAC1D;;AAEA;AACA,WAAW,OAAG;AACd;;AAEA;AACA,uDAAuD,OAAG;AAC1D;;AAEA;AACA,wDAAwD,OAAG;AAC3D;;AAEA;AACA,aAAa;AACb;;AAEA;AACA,uCAAuC,OAAG;AAC1C;;AAEA;AACA,YAAY,OAAO;AACnB;AACA,iDAAiD,OAAG,oCAAoC,OAAG;AAC3F;;AAEA;AACA,YAAY,OAAO;AACnB;AACA,iDAAiD,OAAG,qCAAqC,OAAG;AAC5F;;AAEA;AACA;AACA,SAAS,OAAG;AACZ,SAAS,OAAG;;AAEZ;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB,qBAAqB;AACrB;;AAEA;AACA;AACA;;AAEA,wBAAwB,OAAG,cAAc,OAAG,gBAAgB,OAAG,4CAA4C,OAAG;AAC9G,iDAAiD,OAAG;;AAEpD;AACA,+CAA+C,OAAG,qBAAqB,OAAG,iCAAiC,OAAG;AAC9G;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,sDAAsD,OAAG;AACzD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN,0BAA0B,OAAG;AAC7B;;AAEA;AACA,0CAA0C,OAAG;AAC7C,MAAM;AACN,gEAAgE,OAAG,wDAAwD,OAAG,kBAAkB,OAAG;AACnJ;AACA;AACA;;AAEA,OAAG,wBAAwB;AAC3B,OAAG,qBAAqB;AACxB,OAAG,2BAA2B;AAC9B,OAAG,0BAA0B;AAC7B,OAAG,uCAAuC;AAC1C,OAAG,cAAc;AACjB,OAAG;AACH,OAAG,6BAA6B;AAChC,OAAG,sBAAsB;AACzB,OAAG;AACH,OAAG,uBAAuB,OAAO;AACjC,OAAG,sBAAsB;AACzB,OAAG,wBAAwB;AAC3B,OAAG,4BAA4B;AAC/B,OAAG,uBAAuB;AAC1B,OAAG,wBAAwB;AAC3B,OAAG,cAAc,OAAG,kBAAkB,OAAG,gBAAgB;AACzD,OAAG,2BAA2B;;;ACzHH;;AAEZ;AACf;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,uBAAuB,OAAG;AAC1B;;AAEA;AACA;AACA;;;ACjBmC;;AAEnC,iBAAiB;AACjB,WAAW;AACI;AACf;AACA;;AAEA,oBAAoB,kBAAkB;AACtC;;AAEA;AACA;;AAEA;AACA;AACA,UAAU;AACV;AACA,UAAU;AACV;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,yBAAyB;AACzB,yBAAyB;;AAEzB;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,kDAAkD;;AAElD;AACA,UAAU;AACV;AACA;AACA;AACA;;AAEA,sBAAsB,OAAG;AACzB,qBAAqB,OAAG;AACxB;AACA;AACA;;;AC3DA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACe,MAAM,mBAAS;AAC9B;AACA,iCAAiC;AACjC,+BAA+B;;AAE/B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,oCAAoC,YAAY,wCAAwC;AACxF;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,oBAAoB,2BAA2B;AAC/C;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,oBAAoB,uBAAuB;AAC3C;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,YAAY,qBAAqB;;AAEjC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,2BAA2B,yBAAyB;AACpD;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,YAAY,qBAAqB;;AAEjC;AACA;;AAEA;AACA;AACA;AACA;;AAEA,oBAAoB,gGAAgG;AACpH;AACA;AACA;AACA;AACA;AACA;;AAEA,oBAAoB,aAAa;AACjC;AACA;AACA;AACA;;AAEA;AACA;;AAEA,kBAAkB,4FAA4F;;AAE9G;AACA;AACA;AACA;;AAEA,gBAAgB,wFAAwF;;AAExG;AACA;AACA;;;AC5MsC;;AAEvB;AACf;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,iBAAiB;;AAEjB;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,aAAa;AACb;;AAEA;AACA,qFAAqF,MAAM;AAC3F;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,4BAA4B,SAAS;AACrC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;;AAEA,kDAAkD,MAAM;AACxD;AACA;AACA;AACA;AACA;AACA;;;ACpLsC;;AAEvB;AACf;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,qCAAqC,OAAG,gBAAgB,OAAG;AAC3D;AACA,wCAAwC,OAAG,kBAAkB,OAAG;;AAEhE;AACA;;AAEA;AACA,sDAAsD,OAAG;AACzD;AACA,gDAAgD,OAAG;;AAEnD;AACA;AACA;AACA,6DAA6D,OAAG,uDAAuD,OAAG;;AAE1H;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,aAAa;AACb;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,4BAA4B,SAAS;AACrC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,qCAAqC,sCAAqB;AAC1D;AACA,MAAM;AACN,qCAAqC,sCAAqB;AAC1D;AACA,MAAM;AACN;AACA;AACA;AACA,uDAAuD,sCAAqB;AAC5E,yDAAyD,sCAAqB;;AAE9E;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;;AAEA,kDAAkD,MAAM;AACxD,SAAS,sCAAqB;AAC9B;AACA;;AAEA;AACA;AACA;;;AChLe;AACf;AACA,qBAAqB;;AAErB;AACA;AACA,yDAAyD;AACzD,0DAA0D;AAC1D,sDAAsD;AACtD,uDAAuD;AACvD,6CAA6C;AAC7C;AACA,KAAK;;AAEL;AACA;AACA,0DAA0D;AAC1D,2DAA2D;AAC3D,uDAAuD;AACvD,wDAAwD;AACxD,8CAA8C;AAC9C;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,aAAa;AACb;AACA;;;ACtCA;AACe;AACf;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AA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;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA,IAAI;;AAEJ;AACA;;AAEA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB;AACA;;AAEA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB,aAAa,QAAQ;AACrB;AACA;;AAEA;AACA;AACA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB,aAAa,QAAQ;AACrB;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA,IAAI;;AAEJ;;AAEA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB,aAAa,QAAQ;AACrB;AACA;;AAEA;AACA;AACA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB,aAAa,QAAQ;AACrB;AACA;;AAEA;AACA;AACA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB,aAAa,QAAQ;AACrB;AACA;;AAEA;AACA;AACA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB,aAAa,QAAQ;AACrB;AACA;;AAEA;AACA;AACA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,UAAU;AACtB,YAAY,QAAQ;AACpB,aAAa,QAAQ;AACrB;AACA;;AAEA;;AAEA,mBAAmB,eAAe;;AAElC;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA,YAAY,QAAQ;AACpB;AACA;AACA;;AAEA;;AAEA;;AAEA,EAAE;;AAEF;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,QAAQ;AACpB;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,gDAAe,eAAe,EAAC;;;ACxnC/B,0CAAe,iBAAiB,w8zpDAAw8zpD,EAAC;;;ACAr8zpD;AACG;AACI;;AAE3C;AACA;;AAEe;AACf;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,8BAA8B,OAAG,sBAAsB,OAAG;AAC1D,oCAAoC,qEAAqE;AACzG;AACA;AACA;AACA;;AAEA,kDAAkD,OAAG,wBAAwB,OAAG;AAChF,wDAAwD,uEAAuE;;AAE/H;AACA;AACA,gCAAgC,OAAG,oBAAoB,OAAG;AAC1D;AACA;AACA;;AAEA;AACA;AACA,gCAAgC,OAAG,qBAAqB,OAAG;AAC3D;AACA;AACA;;AAEA;AACA;AACA,yBAAyB,OAAG,mBAAmB,OAAG;AAClD;AACA;AACA;;AAEA;AACA;AACA,yBAAyB,OAAG,oBAAoB,OAAG;AACnD;AACA;AACA;AACA;;AAEA;AACA,uBAAuB,SAAS;AAChC;;AAEA,gBAAgB,GAAQ;AACxB;AACA;AACA;;AAEA;AACA,0BAA0B,OAAG;AAC7B,yBAAyB,OAAG;AAC5B;;AAEA;AACA;AACA;;AAEA;;AAEA,uDAAuD,iBAAiB;AACxE,yDAAyD,iBAAiB;;AAE1E;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO;;AAEP;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACzHA;AACA;;AAEe;AACf;AACA;;AAEA;AACA;AACA,oCAAoC,iEAAiE;AACrG;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,mCAAmC,oDAAoD;AACvF;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;;AC/Be;AACf;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,oCAAoC,oGAAoG;AACxI;AACA;AACA;AACA;;AAEA;AACA;AACA,mCAAmC,kFAAkF;AACrH;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;;AC1DA;;AAEA;AACA;AACA;;AAEe;AACf;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA,oBAAoB,SAAS;AAC7B;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,qBAAqB,gBAAgB;AACrC;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,gCAAgC,gCAAgC;AAChE;AACA;;AAEA;AACA;;AAEA,6CAA6C,+BAA+B;AAC5E;AACA,gCAAgC,iCAAiC;AACjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,8BAA8B,WAAW;AACzC;AACA;AACA;;AAEA;AACA;;AAEA,4BAA4B,gBAAgB;AAC5C;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,mCAAmC,mBAAmB;AACtD;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,oBAAoB,eAAe;AACnC;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,oBAAoB,yBAAyB;AAC7C;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;;AClTe;AACf;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACzDA;AACA,uBAAuB;AACvB,uBAAuB;AACvB,0BAA0B;;AAEX;AACf;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,sCAAsC;AACtC;;AAEA;AACA,sCAAsC;AACtC;;AAEA;AACA,sCAAsC;AACtC;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,oBAAoB,gBAAgB;AACpC;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;;;AClGoC;;AAEpC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;;AAEA;AACA;;AAEA,iBAAiB,OAAG,mBAAmB,OAAG;AAC1C,qBAAqB,OAAG;AACxB;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA,sBAAsB,OAAG;AACzB;AACA,sBAAsB,OAAG;AACzB;;AAEA;AACA;;AAEA;;AAEA;AACA,6DAA6D,OAAG;AAChE;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEe;AACf;AACA,mCAAmC;;AAEnC;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,MAAM;;AAEN;AACA;AACA;AACA;AACA;;AAEA;AACA,2BAA2B;AAC3B;;AAEA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;;AAEA;AACA;AACA;AACA,kEAAkE;AAClE,2EAA2E,IAAI,IAAI,IAAI;AACvF;AACA;AACA;AACA,iEAAiE;AACjE,gDAAgD,IAAI,UAAU,IAAI,0BAA0B,gDAAgD,kCAAkC,kBAAkB,WAAW,MAAM;AACjN;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA,+DAA+D,EAAE;AACjE;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,MAAM;AACN;;AAEA;AACA,mCAAmC;;AAEnC;AACA;AACA,MAAM;;AAEN;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;;AC9J6D;AACM;;AAEpD;AACf;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,oBAAoB,kBAAkB;AACtC;AACA,uBAAuB;;AAEvB;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;;AAEA,oBAAoB,kBAAkB;AACtC;AACA,uBAAuB;;AAEvB;AACA;;AAEA,2FAA2F,uBAAuB;AAClH;AACA;;AAEA,yBAAyB,eAAe;AACxC;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,oBAAoB,kBAAkB;AACtC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,uIAAuI,MAAM;AAC7I;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A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CA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,2EAA2E,UAAU;;AAErF;;AAEA;AACA,0EAA0E,cAAc;AACxF;AACA;;AAEA;AACA;AACA;AACA,KAAK;;AAEL;AACA;;AAEA;AACA;AACA,+CAA+C,UAAU;;AAEzD;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,gCAAgC,iCAAiB;AACjD;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,oHAAoH,aAAa;AACjI,gCAAgC,KAAK,mCAAmC,oDAAoD,EAAE;AAC9H;AACA;AACA,oHAAoH,aAAa;AACjI,qCAAqC,KAAK,cAAc;AACxD;AACA;AACA,oHAAoH,aAAa;AACjI,sCAAsC,KAAK,cAAc;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,gIAAgI,YAAY;AAC5I;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;;;AC3Pe;AACf;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;;AChD+C;AACY;AACI;AACZ;AACN;AACF;;AAE3C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEe;AACf;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,eAAe;AAC9C,4BAA4B,YAAY;;AAExC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,wBAAwB,QAAQ;AAChC,qCAAqC,qBAAqB;;AAE1D;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,oDAAoD,cAAc;AAClE;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA,wBAAwB,QAAQ;AAChC,oBAAoB,mBAAmB;AACvC;AACA;AACA;AACA;;AAEA;AACA,6BAA6B,cAAc;AAC3C;AACA,KAAK;;AAEL;;AAEA;AACA;AACA,UAAU,2BAA2B;AACrC,UAAU,0BAA0B;;AAEpC;AACA;;AAEA;AACA;AACA;AACA;AACA,MAAM;;AAEN;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;;AAEA;;AAEA;AACA;AACA,0CAA0C,wFAAwF;AAClI;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,MAAM;AACN;AACA;AACA,MAAM;AACN;AACA;AACA;AACA,OAAO;;AAEP;AACA;AACA;AACA,OAAO;;AAEP;;AAEA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,oCAAoC,mGAAmG;AACvI;AACA;AACA;AACA;AACA,0BAA0B;;AAE1B;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA,2FAA2F,oDAAoD;AAC/I;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,uBAAuB;;AAEvB;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,wBAAwB,QAAQ;AAChC;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,OAAO;;AAEP;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;;AAEA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA,OAAO;;AAEP;AACA;AACA;AACA,UAAU;AACV;AACA;;AAEA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,6BAA6B,UAAU;;AAEvC;AACA;AACA,MAAM,sCAAsC,KAAK,+BAA+B,iBAAiB;AACjG;AACA,iCAAiC,UAAU;AAC3C;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC/pBA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,yBAAyB;AACzB,+BAA+B;;AAE/B;AACA;AACA,oCAAoC;AACpC,kCAAkC;;AAElC;AACA;AACA;AACA;;AAEA,sDAAsD;AACtD;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,yBAAyB;;AAEzB;AACA;AACA;AACA,6BAA6B;;AAE7B;AACA;;AAEA;AACA,eAAe;;AAEf;AACA,uBAAuB;;AAEvB;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;;AAGA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA,KAAK;;AAEL;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,EAAE;;AAEF;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA,2BAA2B,kBAAkB,GAAG;;AAEhD;;AAEA;AACA;AACA;;AAEA;;AAEA,qBAAqB;AACrB,oBAAoB;AACpB,kBAAkB;;AAElB,eAAe;;AAEf;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,6CAA6C;AAC7C;;AAEA;;AAEA;;AAEA,EAAE;;AAEF;;AAEA;;AAEA;;AAEA,6CAA6C;AAC7C;;AAEA;;AAEA;;AAEA,EAAE;;AAEF,qCAAqC;AACrC;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA,KAAK;;AAEL;AACA;AACA;;AAEA,KAAK;;AAEL;AACA;AACA;;AAEA;;AAEA;;AAEA,EAAE;;AAEF;;AAEA;;AAEA;;AAEA,IAAI;;AAEJ;AACA;AACA;;AAEA,IAAI;;AAEJ;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,IAAI;;AAEJ;AACA;AACA;;AAEA,IAAI;;AAEJ;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,IAAI;;AAEJ;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,IAAI;;AAEJ;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA,IAAI;;AAEJ;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;;AAEA,qCAAqC;AACrC;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA,gDAAgD;;AAEhD;;AAEA;;AAEA;;AAEA;AACA,+CAA+C;;AAE/C;;AAEA;;AAEA;;AAEA;AACA,6CAA6C;;AAE7C;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;;AAEA,EAAE;;AAEF;;AAEA;;AAEA;;AAEA;AACA;;AAEA,GAAG;;AAEH;;AAEA;AACA;;AAEA;;AAEA,EAAE;;AAEF;;AAEA;;AAEA;AACA;;AAEA,GAAG;;AAEH;;AAEA;AACA;;AAEA;;AAEA,EAAE;;AAEF;;AAEA;;AAEA;AACA;;AAEA,GAAG;;AAEH;;AAEA;AACA;;AAEA;;AAEA,EAAE;;AAEF;;AAEA;;AAEA;AACA;;AAEA,GAAG;;AAEH;;AAEA;AACA;;AAEA;;AAEA,EAAE;;AAEF;;AAEA;;AAEA;AACA;;AAEA,GAAG;;AAEH;;AAEA;AACA;;AAEA;;AAEA,EAAE;;AAEF;;AAEA;;AAEA;AACA;;AAEA,GAAG;;AAEH;;AAEA;AACA;;AAEA;;AAEA;;AAEA,EAAE;;AAEF,8DAAe,aAAa,EAAC;;;ACvhC7B;AACA;;AAEe;AACf;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,MAAM;AACN;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;;ACjEoC;;AAEpC;AACA;;AAEe;AACf;AACA;AACA;;AAEA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,8FAA8F,0BAA0B;AACxH;;AAEA;AACA;;AAEA,uDAAuD,OAAG;;AAE1D,8CAA8C,UAAU;;AAExD;AACA,wDAAwD,UAAU;;AAElE;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA,MAAM;AACN,wDAAwD,gBAAgB;;AAExE;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;;AAEA;AACA,sDAAsD,yBAAyB;AAC/E,8CAA8C,iCAAiC;;AAE/E;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,yFAAyF,oDAAoD;AAC7I;AACA;;AAEA;AACA;;AAEA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;;AAEA,2CAA2C,KAAK,GAAG,QAAQ;AAC3D;AACA;AACA;;;ACnIe;AACf;AACA;AACA;AACA;AACA;;AAEA,oBAAoB,uBAAuB;AAC3C;AACA;;AAEA,sBAAsB,iCAAiC;AACvD;AACA;AACA;AACA;;AAEA,yBAAyB;AACzB;AACA;;AAEA;AACA;AACA;;;ACvBA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,oEAAe;AACf;AACA;AACA;AACA;AACA,gBAAgB,wBAAwB;AACxC;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,CAAC;;;AC1ED;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA,oEAAe;AACf;AACA;AACA;AACA,gBAAgB,wBAAwB;AACxC;AACA,0BAA0B,uBAAuB;AACjD,0BAA0B,eAAe;AACzC,0BAA0B,eAAe;AACzC,yBAAyB,cAAc;AACvC,yBAAyB,cAAc;AACvC,qCAAqC,eAAe;AACpD,sBAAsB;AACtB;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;AClDD;;AAEA;AACA;AACA;;AAEA,kBAAkB,wBAAwB;AAC1C;AACA;AACA;;AAEA,sCAAsC,yCAAyC;AAC/E;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA,4EAAe;AACf;AACA;AACA,QAAQ;AACR;AACA,kBAAkB,sCAAsC;AACxD;AACA,4BAA4B,uBAAuB;AACnD,mBAAmB,cAAc;AACjC,+BAA+B,aAAa;AAC5C,4BAA4B;AAC5B;AACA,OAAO;AACP,QAAQ;AACR;AACA,kBAAkB,+BAA+B;AACjD;AACA,4BAA4B,6DAA6D;AACzF,mBAAmB,cAAc;AACjC,+BAA+B,aAAa;AAC5C,4BAA4B;AAC5B;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;ACvED;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,IAAI,sCAAgB;AACpB,IAAI,mCAAa;AACjB;;AAEA;AACA,2EAAe;AACf;AACA;AACA;AACA;AACA,gBAAgB,gFAAgF;AAChG;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA,4BAA4B,0BAA0B;AACtD;AACA;AACA;AACA;;AAEA;AACA;;AAEA,cAAc,sCAAgB;AAC9B;;AAEA;AACA,2CAA2C,sCAAgB;AAC3D;AACA;;AAEA;AACA,sDAAsD,mCAAa;;AAEnE,2CAA2C,sCAAgB;;AAE3D;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA,IAAI,sCAAgB;;AAEpB;AACA,wBAAwB,0BAA0B;AAClD;AACA,MAAM,sCAAgB;AACtB;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,IAAI,mCAAa;;AAEjB;AACA;AACA;AACA;AACA;AACA,CAAC;;;AClHD;;AAEA;AACA;;AAEA;AACA;AACA;AACA,kBAAkB,gBAAgB;AAClC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,6DAAe;AACf;AACA;AACA;AACA,gBAAgB,mCAAmC;AACnD;AACA,sBAAsB,uBAAuB;AAC7C,yBAAyB,cAAc;AACvC,0BAA0B,cAAc;AACxC,qCAAqC;AACrC;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;ACvFD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,kBAAkB,yBAAyB;AAC3C;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,kBAAkB,2BAA2B;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,kBAAkB,uBAAuB;AACzC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA,wEAAe;AACf;AACA;AACA,QAAQ;AACR;AACA,kBAAkB,gCAAgC;AAClD;AACA,qBAAqB,uBAAuB;AAC5C,yBAAyB,aAAa;AACtC,0BAA0B,aAAa;AACvC,iCAAiC,aAAa;AAC9C,kCAAkC;AAClC;AACA,OAAO;AACP,QAAQ;AACR;AACA,kBAAkB,2CAA2C;AAC7D;AACA,qBAAqB,uBAAuB;AAC5C,yBAAyB;AACzB;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;AC5QD;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,kBAAkB,yBAAyB;AAC3C;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,kBAAkB,2BAA2B;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,kBAAkB,uBAAuB;AACzC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,0EAAe;AACf;AACA;AACA;AACA,gBAAgB,6CAA6C;AAC7D;AACA,mBAAmB,uBAAuB;AAC1C,uBAAuB,eAAe;AACtC,wBAAwB,eAAe;AACvC,yBAAyB;AACzB;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;AC3MD;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,yCAAyC;;AAEzC;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA,wCAAwC;;AAExC;AACA;;AAEA;AACA;;AAEA,kBAAkB,gBAAgB;AAClC;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,kBAAkB,gBAAgB;AAClC,sCAAsC;;AAEtC;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA,IAAI,mCAAmC;AACvC;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C,aAAa;AAC7C,0BAA0B,uBAAuB,mBAAmB,MAAM;AAC1E,sBAAsB,uBAAuB,eAAe,MAAM;AAClE,mBAAmB,cAAc;AACjC,OAAO;AACP;AACA,sBAAsB,yBAAyB,GAAG,mBAAmB,GAAG,eAAe;AACvF;AACA;;AAEA,wBAAwB,sCAAsC;AAC9D,iDAAiD,YAAY;AAC7D;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA,aAAa,yBAAyB,GAAG,mBAAmB,GAAG,eAAe;AAC9E;AACA;AACA;AACA,OAAO;AACP,gCAAgC,EAAE,kBAAkB;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,yBAAyB;AACnD,uBAAuB,mBAAmB;AAC1C,kBAAkB,eAAe;AACjC;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,CAAC;;;AC1QD;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA,yDAAe;AACf;AACA;AACA;AACA,gBAAgB,wCAAwC;AACxD;AACA,mBAAmB,uBAAuB;AAC1C,0BAA0B,sDAAsD;AAChF,yBAAyB,cAAc;AACvC,0BAA0B,cAAc;AACxC,yBAAyB,cAAc;AACvC,0BAA0B;AAC1B;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;AC3CkC;AACI;AACA;AACI;AACqB;AACA;AACgB;AACF;AAC5B;AACsB;AACI;AACA;AAClB;AACc;;AAExE,MAAM,qCAAyB;AAC/B,MAAM,+BAAmB;AACzB,MAAM,2BAAe;;AAErB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEe;AACf;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,OAAO,qBAAqB;;AAE3D;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA,gDAAgD,SAAS,6FAA6F;;AAEtJ;AACA;AACA;;AAEA,oBAAoB,uBAAuB;AAC3C;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA,eAAe,qCAAyB,GAAG,+BAAmB,GAAG,2BAAe;AAChF;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,oBAAoB,gBAAgB;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,OAAO;;AAEP;AACA;AACA;AACA,OAAO;AACP;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,oBAAoB,uBAAuB;AAC3C;;AAEA,sBAAsB,sCAAsC;AAC5D;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA,uBAAuB,qCAAyB,GAAG,+BAAmB;AACtE,wCAAwC,2BAAe;AACvD;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA,6CAA6C,qCAAyB;AACtE,sCAAsC,qCAAyB;;AAE/D;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,oBAAoB,sBAAsB;AAC1C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,iCAAiC;AACjC;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,gCAAgC;AAChC,UAAU,OAAO;AACjB;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,gCAAgC;AAChC;AACA,QAAQ;AACR;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA,sBAAsB,iBAAiB;AACvC;AACA;AACA;AACA;;AAEA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,4BAA4B,UAAU;AACtC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;ACrde;AACf;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,oBAAoB,qBAAqB;AACzC;AACA;AACA;;AAEA;AACA;AACA;;;;;ACxB2C;AACL;AACwB;AACgB;AACR;AACA;AACvB;AACA;AACsB;AACE;AAC5B;AACc;AACgB;AACxB;AAClB;AACmC;AACA;AACR;AACE;AACJ;AACqB;AAC1C;;AAEU;;AAE7C;;AAE+C;;AAEhC;AACf;AACA,0EAA0E,sCAAsC,SAAS,yBAAyB;AAClJ;AACA,uCAAuC,uBAAuB;;AAE9D,uBAAuB,OAAO;AAC9B;;AAEA,8CAA8C,iBAAiB;AAC/D;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;;AAEA;AACA,yBAAyB;AACzB;AACA;;AAEA,sBAAsB,MAAM;;AAE5B,6BAA6B;AAC7B,oBAAoB,SAAS;AAC7B;;AAEA,yBAAyB,SAAS;AAClC;;AAEA;AACA;AACA;AACA;;AAEA,mCAAmC,gBAAgB;AACnD;;AAEA,yBAAyB,SAAS;;AAElC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,aAAa;;AAE5C;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA,KAAK;;AAEL;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;;AAEA,8CAA8C,QAAQ;AACtD;AACA;;AAEA;AACA;AACA;AACA;AACA,yBAAyB,cAAc;;AAEvC;AACA,iDAAiD,oEAAoE;AACrH;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,mCAAmC,uBAAa;AAChD;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,kCAAkC,uBAAa;AAC/C;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,+BAA+B,qBAAqB;AACpD;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,oCAAoC,qBAAqB;AACzD;AACA;AACA;AACA;;AAEA;;AAEA;AACA,6DAA6D,EAAE;AAC/D;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAM;AACN;AACA;;AAEA;AACA;AACA;;AAEA,4BAA4B,4BAA4B;;AAExD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,iCAAiC,oBAAoB;AACrD;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;;AAEA;AACA,iCAAiC,qBAAqB;AACtD;AACA,KAAK;;AAEL;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,4CAA4C,KAAK;AACjD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,8BAA8B,yCAAyC,gFAAgF;AACvJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,YAAY,mGAAmG;AAC/G,UAAU,2BAA2B;;AAErC;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,oDAAoD,kDAAkD;;AAEtG;AACA,0BAA0B,WAAW;AACrC;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP;;AAEA;AACA,QAAQ,KAA4B,EAAE,EAiBjC;;AAEL;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,8BAA8B,mBAAS;;AAEvC;AACA;;AAEA;AACA;AACA;AACA;;AAEA,wBAAwB,+BAA+B;AACvD;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,2BAA2B,IAAI;;AAE/B;AACA;AACA;AACA,yCAAyC,gBAAgB;;AAEzD;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,cAAc,OAAG;AACjB,aAAa,OAAG;AAChB;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,uCAAuC;AACvC;AACA,uGAAuG;AACvG;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA,iCAAiC;AACjC;AACA;AACA;AACA,+BAA+B;;AAE/B;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA,+BAA+B;AAC/B;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,mBAAmB;AACnB,SAAS;;AAET,QAAQ;AACR;AACA;;AAEA;AACA;AACA,mBAAmB;AACnB,SAAS;AACT;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,MAAM;AACN;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;;;AC16BuC;AACmB;;AAE1D;AACA,yBAAyB,SAAS;AAClC,CAAC","sources":["webpack://dash/./js/physics/Car.js?2c0e","webpack://dash/./js/physics/Physics.js?4fe1","webpack://dash/./js/autonomy/Path.js?d9f8","webpack://dash/./js/autonomy/path-planning/CubicPath.js?940c","webpack://dash/./js/autonomy/control/AutonomousController.js?ee7c","webpack://dash/./js/autonomy/control/FollowController.js?9179","webpack://dash/./js/autonomy/control/ManualController.js?3451","webpack://dash/./js/objects/MapObject.js?434b","webpack://dash/./js/objects/TDSLoader.js?9e54","webpack://dash/./models/suv.js?cd48","webpack://dash/./js/objects/CarObject.js?84cc","webpack://dash/./js/objects/StaticObstacleObject.js?a247","webpack://dash/./js/objects/DynamicObstacleObject.js?e555","webpack://dash/./js/autonomy/LanePath.js?0fa4","webpack://dash/./js/autonomy/StaticObstacle.js?8906","webpack://dash/./js/autonomy/DynamicObstacle.js?2e70","webpack://dash/./js/simulator/PathPlannerConfigEditor.js?946f","webpack://dash/./js/simulator/DynamicObstacleEditor.js?19dd","webpack://dash/./js/Helpers.js?929b","webpack://dash/./js/simulator/examples.js?1dce","webpack://dash/./js/simulator/ScenarioManager.js?b4b7","webpack://dash/./js/simulator/ShareManager.js?608f","webpack://dash/./js/simulator/Editor.js?a7d0","webpack://dash/./js/simulator/OrbitControls.js?e177","webpack://dash/./js/simulator/TopDownCameraControls.js?cff7","webpack://dash/./js/simulator/Dashboard.js?9633","webpack://dash/./js/autonomy/path-planning/RoadLattice.js?81a8","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/xyObstacleGrid.js?d78c","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/slObstacleGrid.js?e54b","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/slObstacleGridDilation.js?1749","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/slDynamicObstacleGrid.js?6c0e","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/xyslMap.js?5ba9","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/optimizeCubicPaths.js?153d","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/optimizeQuinticPaths.js?c05d","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/graphSearchShared.js?2052","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/pathFromVehicleCosts.js?e50c","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/graphSearch.js?4c88","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/xyObstacleCostGrid.js?c974","webpack://dash/./js/autonomy/path-planning/PathPlanner.js?d326","webpack://dash/./js/autonomy/MovingAverage.js?fbcc","webpack://dash/./js/Simulator.js?1d71","webpack://dash/./js/Dash.js?5195"],"sourcesContent":["export default class Car {\n  constructor(x = 0, y = 0, rotation = 0) {\n    this.setPose(x, y, rotation);\n  }\n\n  static getFrontAxlePosition(pos, rot) {\n    return THREE.Vector2.fromAngle(rot).multiplyScalar(Car.WHEEL_BASE).add(pos);\n  }\n\n  static getFakeAxlePosition(pos, rot) {\n    return Car.frontToRearAxlePosition(pos, rot);\n  }\n\n  static centerToRearAxlePosition(pos, rot) {\n    return THREE.Vector2.fromAngle(rot).multiplyScalar(Car.REAR_AXLE_POS).add(pos);\n  }\n\n  static frontToRearAxlePosition(pos, rot) {\n    return THREE.Vector2.fromAngle(rot).multiplyScalar(-Car.WHEEL_BASE).add(pos);\n  }\n\n  get pose() {\n    return { pos: this.rearAxlePosition.clone(), rot: this.rotation, velocity: this.velocity, curv: this.curvature, dCurv: this.dCurv, ddCurv: this.ddCurv };\n  }\n\n  get curvature() {\n    return Math.tan(this.wheelAngle) / Car.WHEEL_BASE;\n  }\n\n  get rearAxlePosition() {\n    const { x, y } = this.position;\n    const rot = this.rotation;\n    return new THREE.Vector2(x + Math.cos(rot) * Car.REAR_AXLE_POS, y + Math.sin(rot) * Car.REAR_AXLE_POS);\n  }\n\n  get frontAxlePosition() {\n    const { x, y } = this.position;\n    const rot = this.rotation;\n    return new THREE.Vector2(x + Math.cos(rot) * Car.FRONT_AXLE_POS, y + Math.sin(rot) * Car.FRONT_AXLE_POS);\n  }\n\n  setPose(x, y, rotation) {\n    // Translate so that x and y become the center of the vehicle (instead of the center of the rear axle)\n    x -= Car.REAR_AXLE_POS * Math.cos(rotation);\n    y -= Car.REAR_AXLE_POS * Math.sin(rotation);\n\n    this.position = new THREE.Vector2(x, y);\n    this.rotation = Math.wrapAngle(rotation);\n    this.velocity = 0;\n    this.acceleration = 0;\n    this.wheelAngle = 0;\n    this.wheelAngularVelocity = 0;\n    this.dCurv = 0; // derivative with respect to arc length\n    this.ddCurv = 0; // derivative with respect to arc length\n  }\n\n  step(dt) {\n    const curvPrev = this.curvature;\n    const dCurvPrev = this.dCurv;\n\n    const drag = (0.5 * Car.DRAG_COEFF * Car.FRONTAL_AREA * Car.DENSITY_OF_AIR * Math.abs(this.velocity) + Car.ROLL_RESIST) * -this.velocity;\n    this.velocity += (this.acceleration + drag / Car.MASS) * dt;\n\n    const velocitySq = this.velocity * this.velocity;\n    const maxWheelAngle = Math.clamp(Math.atan(Car.MAX_LATERAL_ACCEL * Car.WHEEL_BASE / velocitySq), 0.07, Car.MAX_WHEEL_ANGLE);\n    this.wheelAngle = Math.clamp(Math.wrapAngle(this.wheelAngle + this.wheelAngularVelocity * dt), -maxWheelAngle, maxWheelAngle);\n\n    const angularVelocity = this.velocity * this.curvature;\n    this.rotation = Math.wrapAngle(this.rotation + angularVelocity * dt);\n\n    const dist = this.velocity * dt;\n    this.position = THREE.Vector2.fromAngle(this.rotation).multiplyScalar(dist).add(this.position);\n\n    this.dCurv = dist > 0.1 ? (this.curvature - curvPrev) / dist : 0;\n    this.ddCurv = dist > 0.1 ? (this.dCurv - dCurvPrev) / dist : 0;\n  }\n\n  update(controls, dt) {\n    const gas = Math.clamp(controls.gas, -1, +1);\n    const brake = Math.clamp(controls.brake, 0, 1);\n    const steer = Math.clamp(controls.steer, -1, +1);\n\n    if (brake > 0) {\n      this.acceleration = -Math.sign(this.velocity) * Car.MAX_BRAKE_DECEL * brake;\n      const newVelocity = this.velocity + this.acceleration * dt;\n\n      // If applying the braking deceleration at the next step would cause the velocity\n      // to change directions, then just set the car as stopped.\n      if (Math.sign(newVelocity) != Math.sign(this.velocity)) {\n        this.velocity = 0;\n        this.acceleration = 0;\n      }\n    } else {\n      this.acceleration = Car.MAX_GAS_ACCEL * gas;\n    }\n\n    if (steer != 0) {\n      this.wheelAngularVelocity = steer * Car.MAX_STEER_SPEED;\n    } else {\n      this.wheelAngularVelocity = Math.clamp(-this.wheelAngle / Car.MAX_WHEEL_ANGLE * this.velocity * this.velocity * dt, -Car.MAX_STEER_SPEED, Car.MAX_STEER_SPEED);\n    }\n  }\n}\n\nCar.HALF_CAR_LENGTH = 2.5; // meters\nCar.HALF_CAR_WIDTH = 1; // meters\nCar.HALF_WHEEL_LENGTH = 0.38; // meters\nCar.HALF_WHEEL_WIDTH = 0.12; // meters\nCar.MAX_WHEEL_ANGLE = 32 / 180 * Math.PI; // radians\nCar.MASS = 1600; // kg\nCar.DRAG_COEFF = 0.7;\nCar.DENSITY_OF_AIR = 1.8580608; // (kg/m^3)\nCar.FRONTAL_AREA = 1.85; // m^2\nCar.ROLL_RESIST = 0;\nCar.MAX_STEER_SPEED = 0.8;//1.2; // Radians per second\nCar.MAX_GAS_ACCEL = 3.0; // m / s^2\nCar.MAX_BRAKE_DECEL = 3.0; // m / s^2\nCar.WHEEL_LATERAL_POS = 0.843; // meters\nCar.FRONT_AXLE_POS = 1.6; // meters\nCar.REAR_AXLE_POS = -1.43; // meters\nCar.WHEEL_BASE = Car.FRONT_AXLE_POS - Car.REAR_AXLE_POS; // meters\nCar.MAX_LATERAL_ACCEL = 5.81; // m / s^2\n","import Car from \"./Car.js\";\n\nexport default class Physics {\n  constructor() {\n    this.cars = [];\n  }\n\n  step(dt) {\n    this.cars.forEach(c => c.step(dt));\n  }\n\n  createCar() {\n    const newCar = new Car();\n    this.cars.push(newCar);\n\n    return newCar;\n  }\n};\n","import Car from \"../physics/Car.js\"\n\n// input pose: { pos: Vector2 [, rot: radians] }\n// pose: { pos: Vector2, frontPos: Vector2, fakePos: Vector2, rot: radians }\nexport default class Path {\n  constructor(poses, startRotation = 0, goalRotation = 0) {\n    this.poses = poses;\n\n    for (let i = 0; i < poses.length; i++) {\n      const pose = poses[i];\n\n      if (pose.rot === undefined || pose.rot == null) {\n        let rot;\n\n        if (i == 0) {\n          rot = startRotation;\n        } else if (i == poses.length - 1) {\n          rot = goalRotation;\n        } else {\n          const prev = poses[i - 1].pos;\n          const next = poses[i + 1].pos;\n          rot = Math.atan2(next.y - prev.y, next.x - prev.x);\n        }\n\n        pose.rot = rot;\n      }\n\n      if (pose.curv === undefined || pose.curv == null) {\n        if (i > 0 && i < poses.length - 1) {\n          const prev = poses[i - 1].pos;\n          const cur = poses[i].pos;\n          const next = poses[i + 1].pos;\n\n          const dir1 = { x: cur.x - prev.x, y: cur.y - prev.y };\n          const dir2 = { x: next.x - cur.x, y: next.y - cur.y };\n\n          const angle1 = Math.atan2(dir1.y, dir1.x);\n          const angle2 = Math.atan2(dir2.y, dir2.x);\n\n          // Calculate the angular difference in a way that properly handles the wrap-around from -π to π\n          let deltaAngle = angle2 - angle1;\n          // Normalize the angle difference to be within the range [-π, π]\n          deltaAngle = (deltaAngle + Math.PI) % (2 * Math.PI) - Math.PI;\n\n          // Assuming uniform segment lengths, the curvature (inverse radius of curvature) can be\n          // approximated as the change in angle. For non-uniform segment lengths, include arc length in calculation\n          const curvature = Math.abs(deltaAngle); // Using absolute value of angle difference\n\n          pose.curv = curvature;\n        } else {\n          // Assign zero curvature for start and end points or handle as needed\n          pose.curv = 0;\n        }\n      }\n\n      pose.frontPos = Car.getFrontAxlePosition(pose.pos, pose.rot);\n      pose.fakePos = Car.getFakeAxlePosition(pose.pos, pose.rot);\n    }\n  }\n}\n","const SIMPSONS_INTERVALS = 8;\nconst NEWTON_ITERATIONS = 16;\nconst RELAXATION_ITERATIONS = 32;\nconst CONVERGENCE_ERROR = 0.01;\n\nconst jacobian = new THREE.Matrix3();\nconst invJacobian = new THREE.Matrix3();\n\n// Alternate reference implementation: https://github.com/ApolloAuto/apollo/blob/master/modules/planning/math/spiral_curve/cubic_spiral_curve.cc\nexport default class CubicPath {\n  constructor(start, end, params = null) {\n    this.start = Object.assign({}, start);\n    this.end = Object.assign({}, end);\n\n    if (start.pos) {\n      this.start.x = start.pos.x;\n      this.start.y = start.pos.y\n    }\n\n    if (end.pos) {\n      this.end.x = end.pos.x;\n      this.end.y = end.pos.y\n    }\n\n    const diffX = this.end.x - this.start.x;\n    const diffY = this.end.y - this.start.y;\n    const sinRot = Math.sin(this.start.rot);\n    const cosRot = Math.cos(this.start.rot);\n\n    this.goal = {\n      x: cosRot * diffX + sinRot * diffY,\n      y: -sinRot * diffX + cosRot * diffY,\n      rot: Math.wrapAngle(this.end.rot - this.start.rot),\n      curv: this.end.curv\n    };\n\n    if (params)\n      this.params = Object.assign({}, params, { p0: this.start.curv, p3: this.end.curv });\n    else\n      this.guessInitialParams();\n\n    this.converged = false;\n  }\n\n  guessInitialParams() {\n    const originalGoal = this.goal;\n    const dStartCurv = this.start.curv / RELAXATION_ITERATIONS;\n    const dGoalY = originalGoal.y / RELAXATION_ITERATIONS;\n    const dGoalRot = originalGoal.rot / RELAXATION_ITERATIONS;\n    const dGoalCurv = originalGoal.curv / RELAXATION_ITERATIONS;\n\n    this.goal = {\n      x: originalGoal.x,\n      y: 0,\n      rot: 0,\n      curv: 0\n    };\n\n    this.params = {\n      p0: 0,\n      p1: 0,\n      p2: 0,\n      p3: 0,\n      sG: originalGoal.x\n    };\n\n    for (let i = 0; i < RELAXATION_ITERATIONS; i++) {\n      this.params.p0 += dStartCurv;\n      this.params.p3 += dGoalCurv;\n      this.goal.y += dGoalY;\n      this.goal.rot += dGoalRot;\n      this.goal.curv += dGoalCurv;\n\n      this.iterate();\n    }\n\n    this.goal = originalGoal;\n  }\n\n  optimize() {\n    for (let i = 0; i < NEWTON_ITERATIONS; i++) {\n      if (this.iterate()) {\n        this.converged = true;\n        return true;\n      }\n    }\n\n    this.converged = false;\n    return false;\n  }\n\n  iterate() {\n    const { p0, p1, p2, p3, sG } = this.params;\n\n    const ds = sG / SIMPSONS_INTERVALS;\n    const sG_2 = sG * sG;\n    const sG_3 = sG_2 * sG;\n\n    let dX_p1 = 0;\n    let dX_p2 = 0;\n    let dX_sG = 0;\n    let dY_p1 = 0;\n    let dY_p2 = 0;\n    let dY_sG = 0;\n    let guessX = 0;\n    let guessY = 0;\n\n    let theta, cosTheta, sinTheta, dT_p1, dT_p2, dT_sG;\n\n    for (let i = 0, s = 0; i <= SIMPSONS_INTERVALS; i++, s += ds) {\n      const coeff = i == 0 || i == SIMPSONS_INTERVALS ? 1 : i % 2 == 0 ? 2 : 4;\n\n      const a = p0;\n      const b = (-5.5 * p0 + 9 * p1 - 4.5 * p2 + p3) / sG;\n      const c = (9 * p0 - 22.5 * p1 + 18 * p2 - 4.5 * p3) / sG_2;\n      const d = (-4.5 * (p0 - 3 * p1 + 3 * p2 - p3)) / sG_3;\n\n      theta = (((d * s / 4 + c / 3) * s + b / 2) * s + a) * s;\n      cosTheta = Math.cos(theta);\n      sinTheta = Math.sin(theta);\n\n      const s_sG = s / sG;\n      dT_p1 = ((3.375 * s_sG - 7.5) * s_sG + 4.5) * s_sG * s;\n      dT_p2 = ((-3.375 * s_sG + 6) * s_sG - 2.25) * s_sG * s;\n      dT_sG = ((3.375 * (p0 - 3 * p1 + 3 * p2 - p3) * s_sG - 3 * (2 * p0 - 5 * p1 + 4 * p2 - p3)) * s_sG + 0.25 * (11 * p0 - 18 * p1 + 9 * p2 - 2 * p3)) * s_sG * s_sG;\n\n      dX_p1 -= coeff * sinTheta * dT_p1;\n      dX_p2 -= coeff * sinTheta * dT_p2;\n      dX_sG -= coeff * sinTheta * dT_sG;\n\n      dY_p1 += coeff * cosTheta * dT_p1;\n      dY_p2 += coeff * cosTheta * dT_p2;\n      dY_sG += coeff * cosTheta * dT_sG;\n\n      guessX += coeff * cosTheta;\n      guessY += coeff * sinTheta;\n    }\n\n    // After the Simpson's integration loop, `theta`, `cosTheta`, `sinTheta`,\n    // `dT_p1`, `dT_p2`, and `dT_sG` hold the appropriate values for `sG`.\n\n    const hOver3 = sG / SIMPSONS_INTERVALS / 3;\n\n    const deltaX = this.goal.x - guessX * hOver3;\n    const deltaY = this.goal.y - guessY * hOver3;\n    const deltaRot = Math.wrapAngle(this.goal.rot - theta);\n\n    if (Math.abs(deltaX) + Math.abs(deltaY) + Math.abs(deltaRot) < CONVERGENCE_ERROR)\n      return true;\n\n    jacobian.set(\n      dX_p1 * hOver3, dX_p2 * hOver3, cosTheta + dX_sG * hOver3,\n      dY_p1 * hOver3, dY_p2 * hOver3, sinTheta + dY_sG * hOver3,\n      dT_p1, dT_p2, dT_sG\n    );\n\n    const [m11, m21, m31, m12, m22, m32, m13, m23, m33] = invJacobian.getInverse(jacobian).elements;\n\n    this.params.p1 += m11 * deltaX + m12 * deltaY + m13 * deltaRot;\n    this.params.p2 += m21 * deltaX + m22 * deltaY + m23 * deltaRot;\n    this.params.sG += m31 * deltaX + m32 * deltaY + m33 * deltaRot;\n\n    return false;\n  }\n\n  buildPath(num) {\n    const { p0, p1, p2, p3, sG } = this.params;\n\n    const sG_2 = sG * sG;\n    const sG_3 = sG_2 * sG;\n\n    const a = p0;\n    const b = (-5.5 * p0 + 9 * p1 - 4.5 * p2 + p3) / sG;\n    const c = (9 * p0 - 22.5 * p1 + 18 * p2 - 4.5 * p3) / sG_2;\n    const d = (-4.5 * (p0 - 3 * p1 + 3 * p2 - p3)) / sG_3;\n\n    const path = [{ pos: new THREE.Vector2(this.start.x, this.start.y), rot: this.start.rot, curv: this.start.curv }];\n    const ds = sG / (num - 1);\n    let s = ds;\n    let dx = 0;\n    let dy = 0;\n    let prevCosRot = Math.cos(path[0].rot);\n    let prevSinRot = Math.sin(path[0].rot);\n\n    for (let i = 1; i < num - 1; i++) {\n      const rot = (((d * s / 4 + c / 3) * s + b / 2) * s + a) * s + this.start.rot;\n      const curv = ((d * s + c) * s + b) * s + a;\n      const cosRot = Math.cos(rot);\n      const sinRot = Math.sin(rot);\n\n      dx = dx * (i - 1) / i + (cosRot + prevCosRot) / (2 * i);\n      dy = dy * (i - 1) / i + (sinRot + prevSinRot) / (2 * i);\n\n      path.push({ pos: new THREE.Vector2(s * dx + this.start.x, s * dy + this.start.y), rot: rot, curv: curv });\n\n      s += ds;\n      prevCosRot = cosRot;\n      prevSinRot = sinRot;\n    }\n\n    path.push({ pos: new THREE.Vector2(this.end.x, this.end.y), rot: this.end.rot, curv: this.end.curv });\n\n    return path;\n  }\n}\n","import Car from \"../../physics/Car.js\"\n\nexport default class AutonomousController {\n  constructor(path) {\n    this.path = path;\n    this.nextIndex = 1;\n    this.prevPhiError = 0;\n    this.prevVelocity = 0;\n  }\n\n  reset() {\n    this.prevVelocity = 0;\n  }\n\n  replacePath(path) {\n    this.path = path;\n    this.nextIndex = 1;\n  }\n\n  predictPoseAfterTime(currentPose, predictionTime) {\n    const pathPoses = this.path.poses;\n    const frontAxlePos = Car.getFrontAxlePosition(currentPose.pos, currentPose.rot);\n    let [nextIndex, progress] = this.findNextIndex(frontAxlePos);\n    let currentVelocity = currentPose.velocity;\n\n    if (currentVelocity <= 0.01) return currentPose;\n\n    while (predictionTime > 0) {\n      const prevPose = pathPoses[nextIndex - 1];\n      const nextPose = pathPoses[nextIndex];\n\n      const segmentDist = nextPose.pos.distanceTo(prevPose.pos);\n      const distLeft = segmentDist * (1 - progress);\n      const sumV = currentVelocity + nextPose.velocity;\n      const timeToNextIndex = 2 * distLeft / (sumV == 0 ? 0.01 : sumV);\n      //const timeToNextIndex = distLeft / currentVelocity;\n\n      if (timeToNextIndex >= predictionTime || nextIndex + 1 >= pathPoses.length) {\n        const dist = sumV / 2 * predictionTime;\n        const newProgress = progress + dist / segmentDist;\n\n        return {\n          pos: nextPose.pos.clone().sub(prevPose.pos).multiplyScalar(newProgress).add(nextPose.pos),\n          rot: prevPose.rot + (nextPose.rot - prevPose.rot) * newProgress,\n          curv: prevPose.curv + (nextPose.curv - prevPose.curv) * newProgress,\n          dCurv: 0,\n          ddCurv: 0,\n          velocity: nextPose.velocity\n        }\n      }\n\n      //currentVelocity = nextPose.velocity;\n      predictionTime -= timeToNextIndex;\n      progress = 0;\n      nextIndex++;\n    }\n  }\n\n  control(pose, wheelAngle, velocity, dt) {\n    const pathPoses = this.path.poses;\n    const frontAxlePos = Car.getFrontAxlePosition(pose.pos, pose.rot);\n    const [nextIndex, progress] = this.findNextIndex(frontAxlePos);\n    this.nextIndex = nextIndex;\n\n    let gas = 0;\n    let brake = 0;\n    let phi = 0; // the desired wheel deflection\n\n    if (nextIndex >= pathPoses.length - 1 && progress >= 1) {\n      gas = 0;\n      brake = 1;\n      phi = 0;\n    } else {\n      const kp_a = 4;\n      const kd_a = 0.5;\n      const kff_a = 0.5;\n\n      const currentAccel = (velocity - this.prevVelocity) / dt;\n      const prevNextDist = pathPoses[this.nextIndex].pos.distanceTo(pathPoses[this.nextIndex - 1].pos);\n      const targetVelocity = Math.sqrt(2 * pathPoses[nextIndex].acceleration * prevNextDist * Math.clamp(progress, 0, 1) + pathPoses[this.nextIndex - 1].velocity * pathPoses[this.nextIndex - 1].velocity);\n      const diffVelocity = targetVelocity - velocity;\n      const diffAccel = pathPoses[this.nextIndex].acceleration - currentAccel;\n      const targetAccel = kp_a * diffVelocity + kd_a * diffAccel + kff_a * pathPoses[this.nextIndex].acceleration;\n\n      if (targetAccel > 0)\n        gas = Math.min(targetAccel / Car.MAX_GAS_ACCEL, 1);\n      else\n        brake = Math.min(-targetAccel / Car.MAX_BRAKE_DECEL, 1);\n\n      this.prevVelocity = velocity;\n\n      const closestFrontPathPos = projectPointOnSegment(frontAxlePos, pathPoses[this.nextIndex - 1].frontPos, pathPoses[this.nextIndex].frontPos)[0];\n\n      // Determine the desired heading at the specific point on the front path by lerping between prevHeading and nextHeading using progress as the weight\n      const prevHeading = this.nextIndex > 1 ? pathPoses[nextIndex].frontPos.clone().sub(pathPoses[nextIndex - 2].frontPos).angle() : pathPoses[0].rot;\n      const nextHeading = this.nextIndex < pathPoses.length - 1 ? pathPoses[nextIndex + 1].frontPos.clone().sub(pathPoses[nextIndex - 1].frontPos).angle() : pathPoses[pathPoses.length - 1].rot;\n      const desiredHeading = prevHeading + (nextHeading - prevHeading) * progress;\n\n      // Determine if the front axle is to the left or right of the front path\n      const pathVec = pathPoses[nextIndex].frontPos.clone().sub(pathPoses[nextIndex - 1].frontPos).normalize();\n      const zero = new THREE.Vector2(0, 0);\n      const left = pathVec.clone().rotateAround(zero, Math.PI / 2).add(closestFrontPathPos);\n      const right = pathVec.clone().rotateAround(zero, -Math.PI / 2).add(closestFrontPathPos);\n      const dir = frontAxlePos.distanceToSquared(left) < frontAxlePos.distanceToSquared(right) ? -1 : 1;\n\n      const k = 4;\n      const gain = 0.8;\n      const crossTrackError = frontAxlePos.distanceTo(closestFrontPathPos);\n      const headingError = Math.wrapAngle(pose.rot - desiredHeading);\n\n      //phi = -headingError + gain * Math.atan(k * dir * crossTrackError / velocity);\n\n      const curv = pathPoses[nextIndex - 1].curv + (pathPoses[nextIndex].curv - pathPoses[nextIndex - 1].curv) * progress;\n\n      phi = Math.atan(curv * Car.WHEEL_BASE) + gain * Math.atan(k * dir * crossTrackError / Math.max(velocity, 0.01));\n\n      const checkSteer = Math.clamp((phi - wheelAngle) / dt / Car.MAX_STEER_SPEED, -1, 1);\n    }\n\n    const phiError = phi - wheelAngle;\n    /*\n    const dPhiError = (phiError - this.prevPhiError) / dt;\n    this.prevPhiError = phiError;\n    \n    const steer = Math.clamp(12 * phiError + 0.8 * dPhiError, -1, 1);\n    */\n\n    const steer = Math.clamp(phiError / dt / Car.MAX_STEER_SPEED, -1, 1);\n\n    return { gas, brake, steer };\n  }\n\n  // Finds the next point the vehicle is approaching and the progress between the prev point and the next point\n  // Returns [nextPointIndex, progress from (nextPointIndex - 1) to nextPointIndex, {0 - 1}]\n  findNextIndex(frontAxlePos) {\n    const pathPoses = this.path.poses;\n\n    // Constrain the search to just a few points surrounding the current nextIndex\n    // for performance and to avoid problems with a path that crosses itself\n    const start = Math.max(0, this.nextIndex - 20);\n    const end = Math.min(pathPoses.length - 1, this.nextIndex + 20);\n    let closestDistSqr = frontAxlePos.distanceToSquared(pathPoses[start].frontPos);\n    let closestIndex = start;\n\n    for (let i = start + 1; i < end; i++) {\n      const distSqr = frontAxlePos.distanceToSquared(pathPoses[i].frontPos);\n      if (distSqr < closestDistSqr) {\n        closestDistSqr = distSqr;\n        closestIndex = i;\n      }\n    }\n\n    if (closestIndex == pathPoses.length - 1) {\n      const [_, progress] = projectPointOnSegment(frontAxlePos, pathPoses[closestIndex - 1].frontPos, pathPoses[closestIndex].frontPos);\n      return [closestIndex, progress];\n    } else if (closestIndex == 0) {\n      const [_, progress] = projectPointOnSegment(frontAxlePos, pathPoses[closestIndex].frontPos, pathPoses[closestIndex + 1].frontPos);\n      return [closestIndex + 1, progress];\n    } else {\n      // The nextPoint is either (closestPoint) or (closestPoint + 1). Project the frontAxlePos to both\n      // of those two line segments (the segment preceding closestPoint and the segment succeeding closestPoint)\n      // to determine which segment it's closest to.\n      const [precedingProjection, precedingProgress] = projectPointOnSegment(frontAxlePos, pathPoses[closestIndex - 1].frontPos, pathPoses[closestIndex].frontPos);\n      const [succeedingProjection, succeedingProgress] = projectPointOnSegment(frontAxlePos, pathPoses[closestIndex].frontPos, pathPoses[closestIndex + 1].frontPos);\n\n      if (frontAxlePos.distanceToSquared(precedingProjection) < frontAxlePos.distanceToSquared(succeedingProjection)) {\n        return [closestIndex, precedingProgress];\n      } else {\n        return [closestIndex + 1, succeedingProgress];\n      }\n    }\n  }\n}\n\n// Returns [pointOnSegment, progressAlongSegment {0 - 1}]\nfunction projectPointOnSegment(point, start, end) {\n  const distSqr = start.distanceToSquared(end);\n  //const progress = Math.clamp(point.clone().sub(start).dot(end.clone().sub(start)) / distSqr, 0, 1);\n  const progress = point.clone().sub(start).dot(end.clone().sub(start)) / distSqr;\n  return [end.clone().sub(start).multiplyScalar(progress).add(start), progress];\n}\n","import Car from \"../../physics/Car.js\"\n\nexport default class FollowController {\n  constructor(path, car) {\n    this.path = path;\n    this.car = car;\n    this.nextIndex = 1;\n    this.prevVelocity = 0;\n    this.prevAccel = 0;\n  }\n\n  reset() {\n    this.prevVelocity = 0;\n    this.prevAccel = 0;\n  }\n\n  replacePath(path) {\n    this.path = path;\n    this.nextIndex = 1;\n  }\n\n  predictPoseAfterTime(currentPose, predictionTime) {\n    const pathPoses = this.path.poses;\n    let [nextIndex, progress] = this.findNextIndex(currentPose.pos);\n    let currentVelocity = currentPose.velocity;\n\n    if (currentVelocity <= 0.01) return currentPose;\n\n    while (predictionTime > 0) {\n      const prevPose = pathPoses[nextIndex - 1];\n      const nextPose = pathPoses[nextIndex];\n\n      const segmentDist = nextPose.pos.distanceTo(prevPose.pos);\n      const distLeft = segmentDist * (1 - progress);\n      const sumV = (currentVelocity + nextPose.velocity) / 2;\n      const timeToNextIndex = 2 * distLeft / (sumV == 0 ? 0.01 : sumV);\n\n      if (timeToNextIndex >= predictionTime || nextIndex + 1 >= pathPoses.length) {\n        const dist = sumV / 2 * predictionTime;\n        const newProgress = progress + dist / segmentDist;\n        const newRotation = Math.wrapAngle(prevPose.rot + Math.wrapAngle(nextPose.rot - prevPose.rot) * newProgress);\n\n        const pprevPose = nextIndex - 2 >= 0 ? pathPoses[nextIndex - 2] : prevPose;\n        const nnextPose = nextIndex + 1 < pathPoses.length ? pathPoses[nextIndex + 1] : nextPose;\n\n        const dCurv = (nextPose.curv - prevPose.curv) / segmentDist;\n        const dCurvPrev = ((prevPose.curv - pprevPose.curv) / pprevPose.pos.distanceTo(prevPose.pos) + dCurv) / 2;\n        const dCurvNext = (dCurv + (nnextPose.curv - nextPose.curv) / nextPose.pos.distanceTo(nnextPose.pos)) / 2;\n\n        const ddCurv = (dCurvNext - dCurvPrev) / segmentDist;\n\n        return {\n          pos: nextPose.pos.clone().sub(prevPose.pos).multiplyScalar(newProgress).add(nextPose.pos),\n          rot: newRotation,\n          curv: prevPose.curv + (nextPose.curv - prevPose.curv) * newProgress,\n          dCurv: dCurv,\n          ddCurv: ddCurv,\n          velocity: nextPose.velocity\n        }\n      }\n\n      currentVelocity = nextPose.velocity;\n      predictionTime -= timeToNextIndex;\n      progress = 0;\n      nextIndex++;\n    }\n  }\n\n  control(pose, wheelAngle, velocity, dt, lockPath = false) {\n    const pathPoses = this.path.poses;\n    const [nextIndex, progress, projection] = this.findNextIndex(pose.pos);\n    this.nextIndex = nextIndex;\n\n    const prevPose = pathPoses[nextIndex - 1];\n    const nextPose = pathPoses[nextIndex];\n\n    let gas = 0;\n    let brake = 0;\n    let steer = 0;\n\n    if (nextIndex >= pathPoses.length - 2 && progress >= 1 - 1e-6) {\n      brake = 1;\n    } else {\n      /*\n      const kp_a = 4;\n      const kd_a = 0.5;\n      const kff_a = 0.5;\n\n      const currentAccel = (velocity - this.prevVelocity) / dt;\n      const prevNextDist = nextPose.pos.distanceTo(prevPose.pos);\n      const targetVelocity = Math.sqrt(2 * nextPose.acceleration * prevNextDist * Math.clamp(progress, 0, 1) + prevPose.velocity * prevPose.velocity);\n      const diffVelocity = targetVelocity - velocity;\n      const diffAccel = nextPose.acceleration - currentAccel;\n      const targetAccel = kp_a * diffVelocity + kd_a * diffAccel + kff_a * nextPose.acceleration;\n      */\n      const accelDamping = 0.1;\n      const targetAccel = nextPose.acceleration;\n      const dampedAccel = this.prevAccel * (1 - accelDamping) + targetAccel * accelDamping;\n\n      if (dampedAccel > 0)\n        gas = Math.min(dampedAccel / Car.MAX_GAS_ACCEL, Car.MAX_GAS_ACCEL);\n      else\n        brake = Math.min(-dampedAccel / Car.MAX_BRAKE_DECEL, Car.MAX_BRAKE_DECEL);\n\n      this.prevVelocity = velocity;\n      this.prevAccel = dampedAccel;\n\n      const curvature = prevPose.curv + (nextPose.curv - prevPose.curv) * progress;\n      const desiredWheelAngle = Math.atan(curvature * Car.WHEEL_BASE);\n      const wheelAngleError = desiredWheelAngle - wheelAngle;\n      steer = Math.clamp(wheelAngleError / dt / Car.MAX_STEER_SPEED, -1, 1);\n\n      if (lockPath) {\n        const damping = 0.1;\n        const newRotation = Math.wrapAngle(prevPose.rot + Math.wrapAngle(nextPose.rot - prevPose.rot) * progress);\n        const newPosition = new THREE.Vector2(projection.x - Car.REAR_AXLE_POS * Math.cos(newRotation), projection.y - Car.REAR_AXLE_POS * Math.sin(newRotation));\n\n        if (Math.abs(Math.wrapAngle(newRotation - this.car.rotation)) > 0.5) {\n          console.log('wut');\n        }\n\n        this.car.rotation += damping * Math.wrapAngle(newRotation - this.car.rotation);\n        this.car.position = this.car.position.clone().multiplyScalar(1 - damping).add(newPosition.multiplyScalar(damping));\n      }\n    }\n\n    return { gas, brake, steer };\n  }\n\n  findNextIndex(pos) {\n    const pathPoses = this.path.poses;\n\n    // Constrain the search to just a few points surrounding the current nextIndex\n    // for performance and to avoid problems with a path that crosses itself\n    const start = Math.max(0, this.nextIndex - 20);\n    const end = Math.min(pathPoses.length - 1, this.nextIndex + 20);\n    let closestDistSqr = pos.distanceToSquared(pathPoses[start].pos);\n    let closestIndex = start;\n\n    for (let i = start + 1; i < end; i++) {\n      const distSqr = pos.distanceToSquared(pathPoses[i].pos);\n      if (distSqr < closestDistSqr) {\n        closestDistSqr = distSqr;\n        closestIndex = i;\n      }\n    }\n\n    if (closestIndex == pathPoses.length - 1) {\n      const [projection, progress] = projectPointOnSegment(pos, pathPoses[closestIndex - 1].pos, pathPoses[closestIndex].pos);\n      return [closestIndex, progress, projection];\n    } else if (closestIndex == 0) {\n      const [projection, progress] = projectPointOnSegment(pos, pathPoses[closestIndex].pos, pathPoses[closestIndex + 1].pos);\n      return [closestIndex + 1, progress, projection];\n    } else {\n      // The nextPoint is either (closestPoint) or (closestPoint + 1). Project the pos to both\n      // of those two line segments (the segment preceding closestPoint and the segment succeeding closestPoint)\n      // to determine which segment it's closest to.\n      const [precedingProjection, precedingProgress] = projectPointOnSegment(pos, pathPoses[closestIndex - 1].pos, pathPoses[closestIndex].pos);\n      const [succeedingProjection, succeedingProgress] = projectPointOnSegment(pos, pathPoses[closestIndex].pos, pathPoses[closestIndex + 1].pos);\n\n      if (pos.distanceToSquared(precedingProjection) < pos.distanceToSquared(succeedingProjection)) {\n        return [closestIndex, precedingProgress, precedingProjection];\n      } else {\n        return [closestIndex + 1, succeedingProgress, succeedingProjection];\n      }\n    }\n  }\n}\n\n// Returns [pointOnSegment, progressAlongSegment {0 - 1}]\nfunction projectPointOnSegment(point, start, end) {\n  const distSqr = start.distanceToSquared(end);\n  const progress = point.clone().sub(start).dot(end.clone().sub(start)) / distSqr;\n\n  const clampedProgress = Math.max(0, Math.min(1, progress));\n  return [end.clone().sub(start).multiplyScalar(clampedProgress).add(start), clampedProgress];\n}\n","export default class ManualController {\n  constructor() {\n    this.carKeys = { forward: false, backward: false, left: false, right: false, brake: false };\n\n    document.addEventListener('keydown', event => {\n      switch (event.key) {\n        case 'w': case 'W': this.carKeys.forward = true; break;\n        case 's': case 'S': this.carKeys.backward = true; break;\n        case 'a': case 'A': this.carKeys.left = true; break;\n        case 'd': case 'D': this.carKeys.right = true; break;\n        case ' ': this.carKeys.brake = true; break;\n      }\n    });\n\n    document.addEventListener('keyup', event => {\n      switch (event.key) {\n        case 'w': case 'W': this.carKeys.forward = false; break;\n        case 's': case 'S': this.carKeys.backward = false; break;\n        case 'a': case 'A': this.carKeys.left = false; break;\n        case 'd': case 'D': this.carKeys.right = false; break;\n        case ' ': this.carKeys.brake = false; break;\n      }\n    });\n  }\n\n  control() {\n    let gas = 0;\n    let brake = 0;\n    let steer = 0;\n\n    if (this.carKeys.forward) gas += 1;\n    if (this.carKeys.backward) gas -= 1;\n    if (this.carKeys.left) steer -= 1;\n    if (this.carKeys.right) steer += 1;\n    if (this.carKeys.brake) brake += 1;\n\n    return { gas, brake, steer };\n  }\n}\n","// geolocation = [33.523900, -111.908756];\nexport default class MapObject extends THREE.Object3D {\n  constructor(geolocation = null) {\n    super();\n\n    this.geolocation = geolocation;\n    this.tilesGroup = null;\n\n    const tileSize = geolocation ? this.tileSizeInMeters() : 10;\n    const grid = new THREE.GridHelper(MapObject.HALF_NUM_TILES * 8 * tileSize, MapObject.HALF_NUM_TILES * 8, 0x333333, 0x333333);\n    grid.renderOrder = -1;\n    grid.material.depthTest = false;\n    grid.position.add(new THREE.Vector3(-tileSize / 2, 0, -tileSize / 2));\n    this.add(grid);\n\n    if (geolocation)\n      this.drawTiles();\n  }\n\n  // Converts lat-long geolocation to Google Maps world coodinates\n  static geoToWorld(latlng) {\n    const latitudeRadians = latlng[0] * Math.PI / 180;\n    const x = (latlng[1] + 180) / 360 * 256;\n    const y = ((1 - Math.log(Math.tan(latitudeRadians) + 1 / Math.cos(latitudeRadians)) / Math.PI) / 2) * 256;\n    return [x, y];\n  }\n\n  // Calculates the x and y tile indices for the provided world coordinates\n  static worldToTile(worldCoordinates) {\n    return [Math.floor(worldCoordinates[0] * MapObject.SCALE / 256), Math.floor(worldCoordinates[1] * MapObject.SCALE / 256)];\n  }\n\n  drawTiles() {\n    if (this.tileGroup != null) this.remove(this.tilesGroup);\n    this.tileGroup = new THREE.Group();\n\n    const originTile = MapObject.worldToTile(MapObject.geoToWorld(this.geolocation));\n    const tileSize = this.tileSizeInMeters();\n\n    for (let x = -MapObject.HALF_NUM_TILES, h = 0; x < MapObject.HALF_NUM_TILES; x++) {\n      for (let y = -MapObject.HALF_NUM_TILES; y < MapObject.HALF_NUM_TILES; y++, h++) {\n        const tileTexture = new THREE.TextureLoader().load(`https://khms${h % 4}.google.com/kh/v=748?x=${originTile[0] + x}&y=${originTile[1] + y}&z=${MapObject.ZOOM}`);\n        tileTexture.anisotropy = 16;\n        const tileGeometry = new THREE.PlaneBufferGeometry(tileSize, tileSize);\n        const tileMaterial = new THREE.MeshBasicMaterial({ map: tileTexture, color: 0xffffff });\n        const tile = new THREE.Mesh(tileGeometry, tileMaterial);\n        tile.rotation.x = -Math.PI / 2;\n        tile.position.x = x * tileSize;\n        tile.position.z = y * tileSize;\n\n        this.tileGroup.add(tile);\n      }\n    }\n\n    this.add(this.tileGroup);\n  }\n\n  tileSizeInMeters() {\n    // Because of the Mercator projection used to create the tile images, the size of a tile (in meters) depends on the latitude\n    return 2 * Math.PI * MapObject.EARTH_RADIUS * Math.cos(this.geolocation[0] * Math.PI / 180) / Math.pow(2, MapObject.ZOOM);\n  }\n}\n\nMapObject.EARTH_RADIUS = 6378137; // meters\nMapObject.TILE_PIXELS = 256; // pixels per tile\nMapObject.ZOOM = 20;\nMapObject.SCALE = 1 << MapObject.ZOOM;\nMapObject.HALF_NUM_TILES = 20;\n","/*\n * Autodesk 3DS threee.js file loader, based on lib3ds.\n *\n * Loads geometry with uv and materials basic properties with texture support.\n *\n * @author @tentone\n * @author @timknip\n * @class TDSLoader\n * @constructor\n */\n\n'use strict';\n\nTHREE.TDSLoader = function ( manager ) {\n\n\tthis.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;\n\tthis.debug = false;\n\n\tthis.group = null;\n\tthis.position = 0;\n\n\tthis.materials = [];\n\tthis.meshes = [];\n\n};\n\nTHREE.TDSLoader.prototype = {\n\n\tconstructor: THREE.TDSLoader,\n\n\t/**\n\t * Load 3ds file from url.\n\t *\n\t * @method load\n\t * @param {[type]} url URL for the file.\n\t * @param {Function} onLoad onLoad callback, receives group Object3D as argument.\n\t * @param {Function} onProgress onProgress callback.\n\t * @param {Function} onError onError callback.\n\t */\n\tload: function ( url, onLoad, onProgress, onError ) {\n\n\t\tvar scope = this;\n\n\t\tvar path = this.path !== undefined ? this.path : THREE.LoaderUtils.extractUrlBase( url );\n\n\t\tvar loader = new THREE.FileLoader( this.manager );\n\n\t\tloader.setResponseType( 'arraybuffer' );\n\n\t\tloader.load( url, function ( data ) {\n\n\t\t\tonLoad( scope.parse( data, path ) );\n\n\t\t}, onProgress, onError );\n\n\t},\n\n\t/**\n\t * Parse arraybuffer data and load 3ds file.\n\t *\n\t * @method parse\n\t * @param {ArrayBuffer} arraybuffer Arraybuffer data to be loaded.\n\t * @param {String} path Path for external resources.\n\t * @return {Object3D} Group loaded from 3ds file.\n\t */\n\tparse: function ( arraybuffer, path ) {\n\n\t\tthis.group = new THREE.Group();\n\t\tthis.position = 0;\n\t\tthis.materials = [];\n\t\tthis.meshes = [];\n\n\t\tthis.readFile( arraybuffer, path );\n\n\t\tfor ( var i = 0; i < this.meshes.length; i ++ ) {\n\n\t\t\tthis.group.add( this.meshes[ i ] );\n\n\t\t}\n\n\t\treturn this.group;\n\n\t},\n\n\t/**\n\t * Decode file content to read 3ds data.\n\t *\n\t * @method readFile\n\t * @param {ArrayBuffer} arraybuffer Arraybuffer data to be loaded.\n\t */\n\treadFile: function ( arraybuffer, path ) {\n\n\t\tvar data = new DataView( arraybuffer );\n\t\tvar chunk = this.readChunk( data );\n\n\t\tif ( chunk.id === MLIBMAGIC || chunk.id === CMAGIC || chunk.id === M3DMAGIC ) {\n\n\t\t\tvar next = this.nextChunk( data, chunk );\n\n\t\t\twhile ( next !== 0 ) {\n\n\t\t\t\tif ( next === M3D_VERSION ) {\n\n\t\t\t\t\tvar version = this.readDWord( data );\n\t\t\t\t\tthis.debugMessage( '3DS file version: ' + version );\n\n\t\t\t\t} else if ( next === MDATA ) {\n\n\t\t\t\t\tthis.resetPosition( data );\n\t\t\t\t\tthis.readMeshData( data, path );\n\n\t\t\t\t} else {\n\n\t\t\t\t\tthis.debugMessage( 'Unknown main chunk: ' + next.toString( 16 ) );\n\n\t\t\t\t}\n\n\t\t\t\tnext = this.nextChunk( data, chunk );\n\n\t\t\t}\n\n\t\t}\n\n\t\tthis.debugMessage( 'Parsed ' + this.meshes.length + ' meshes' );\n\n\t},\n\n\t/**\n\t * Read mesh data chunk.\n\t *\n\t * @method readMeshData\n\t * @param {Dataview} data Dataview in use.\n\t */\n\treadMeshData: function ( data, path ) {\n\n\t\tvar chunk = this.readChunk( data );\n\t\tvar next = this.nextChunk( data, chunk );\n\n\t\twhile ( next !== 0 ) {\n\n\t\t\tif ( next === MESH_VERSION ) {\n\n\t\t\t\tvar version = + this.readDWord( data );\n\t\t\t\tthis.debugMessage( 'Mesh Version: ' + version );\n\n\t\t\t} else if ( next === MASTER_SCALE ) {\n\n\t\t\t\tvar scale = this.readFloat( data );\n\t\t\t\tthis.debugMessage( 'Master scale: ' + scale );\n\t\t\t\tthis.group.scale.set( scale, scale, scale );\n\n\t\t\t} else if ( next === NAMED_OBJECT ) {\n\n\t\t\t\tthis.debugMessage( 'Named Object' );\n\t\t\t\tthis.resetPosition( data );\n\t\t\t\tthis.readNamedObject( data );\n\n\t\t\t} else if ( next === MAT_ENTRY ) {\n\n\t\t\t\tthis.debugMessage( 'Material' );\n\t\t\t\tthis.resetPosition( data );\n\t\t\t\tthis.readMaterialEntry( data, path );\n\n\t\t\t} else {\n\n\t\t\t\tthis.debugMessage( 'Unknown MDATA chunk: ' + next.toString( 16 ) );\n\n\t\t\t}\n\n\t\t\tnext = this.nextChunk( data, chunk );\n\n\t\t}\n\n\t},\n\n\t/**\n\t * Read named object chunk.\n\t *\n\t * @method readNamedObject\n\t * @param {Dataview} data Dataview in use.\n\t */\n\treadNamedObject: function ( data ) {\n\n\t\tvar chunk = this.readChunk( data );\n\t\tvar name = this.readString( data, 64 );\n\t\tchunk.cur = this.position;\n\n\t\tvar next = this.nextChunk( data, chunk );\n\t\twhile ( next !== 0 ) {\n\n\t\t\tif ( next === N_TRI_OBJECT ) {\n\n\t\t\t\tthis.resetPosition( data );\n\t\t\t\tvar mesh = this.readMesh( data );\n\t\t\t\tmesh.name = name;\n\t\t\t\tthis.meshes.push( mesh );\n\n\t\t\t} else {\n\n\t\t\t\tthis.debugMessage( 'Unknown named object chunk: ' + next.toString( 16 ) );\n\n\t\t\t}\n\n\t\t\tnext = this.nextChunk( data, chunk );\n\n\t\t}\n\n\t\tthis.endChunk( chunk );\n\n\t},\n\n\t/**\n\t * Read material data chunk and add it to the material list.\n\t *\n\t * @method readMaterialEntry\n\t * @param {Dataview} data Dataview in use.\n\t */\n\treadMaterialEntry: function ( data, path ) {\n\n\t\tvar chunk = this.readChunk( data );\n\t\tvar next = this.nextChunk( data, chunk );\n\t\tvar material = new THREE.MeshPhongMaterial();\n\n\t\twhile ( next !== 0 ) {\n\n\t\t\tif ( next === MAT_NAME ) {\n\n\t\t\t\tmaterial.name = this.readString( data, 64 );\n\t\t\t\tthis.debugMessage( '   Name: ' + material.name );\n\n\t\t\t} else if ( next === MAT_WIRE ) {\n\n\t\t\t\tthis.debugMessage( '   Wireframe' );\n\t\t\t\tmaterial.wireframe = true;\n\n\t\t\t} else if ( next === MAT_WIRE_SIZE ) {\n\n\t\t\t\tvar value = this.readByte( data );\n\t\t\t\tmaterial.wireframeLinewidth = value;\n\t\t\t\tthis.debugMessage( '   Wireframe Thickness: ' + value );\n\n\t\t\t} else if ( next === MAT_TWO_SIDE ) {\n\n\t\t\t\tmaterial.side = THREE.DoubleSide;\n\t\t\t\tthis.debugMessage( '   DoubleSided' );\n\n\t\t\t} else if ( next === MAT_ADDITIVE ) {\n\n\t\t\t\tthis.debugMessage( '   Additive Blending' );\n\t\t\t\tmaterial.blending = THREE.AdditiveBlending;\n\n\t\t\t} else if ( next === MAT_DIFFUSE ) {\n\n\t\t\t\tthis.debugMessage( '   Diffuse Color' );\n\t\t\t\tmaterial.color = this.readColor( data );\n\n\t\t\t} else if ( next === MAT_SPECULAR ) {\n\n\t\t\t\tthis.debugMessage( '   Specular Color' );\n\t\t\t\tmaterial.specular = this.readColor( data );\n\n\t\t\t} else if ( next === MAT_AMBIENT ) {\n\n\t\t\t\tthis.debugMessage( '   Ambient color' );\n\t\t\t\tmaterial.color = this.readColor( data );\n\n\t\t\t} else if ( next === MAT_SHININESS ) {\n\n\t\t\t\tvar shininess = this.readWord( data );\n\t\t\t\tmaterial.shininess = shininess;\n\t\t\t\tthis.debugMessage( '   Shininess : ' + shininess );\n\n\t\t\t} else if ( next === MAT_TEXMAP ) {\n\n\t\t\t\tthis.debugMessage( '   ColorMap' );\n\t\t\t\tthis.resetPosition( data );\n\t\t\t\tmaterial.map = this.readMap( data, path );\n\n\t\t\t} else if ( next === MAT_BUMPMAP ) {\n\n\t\t\t\tthis.debugMessage( '   BumpMap' );\n\t\t\t\tthis.resetPosition( data );\n\t\t\t\tmaterial.bumpMap = this.readMap( data, path );\n\n\t\t\t} else if ( next === MAT_OPACMAP ) {\n\n\t\t\t\tthis.debugMessage( '   OpacityMap' );\n\t\t\t\tthis.resetPosition( data );\n\t\t\t\tmaterial.alphaMap = this.readMap( data, path );\n\n\t\t\t} else if ( next === MAT_SPECMAP ) {\n\n\t\t\t\tthis.debugMessage( '   SpecularMap' );\n\t\t\t\tthis.resetPosition( data );\n\t\t\t\tmaterial.specularMap = this.readMap( data, path );\n\n\t\t\t} else {\n\n\t\t\t\tthis.debugMessage( '   Unknown material chunk: ' + next.toString( 16 ) );\n\n\t\t\t}\n\n\t\t\tnext = this.nextChunk( data, chunk );\n\n\t\t}\n\n\t\tthis.endChunk( chunk );\n\n\t\tthis.materials[ material.name ] = material;\n\n\t},\n\n\t/**\n\t * Read mesh data chunk.\n\t *\n\t * @method readMesh\n\t * @param {Dataview} data Dataview in use.\n\t */\n\treadMesh: function ( data ) {\n\n\t\tvar chunk = this.readChunk( data );\n\t\tvar next = this.nextChunk( data, chunk );\n\n\t\tvar useBufferGeometry = false;\n\t\tvar geometry = null;\n\t\tvar uvs = [];\n\n\t\tif ( useBufferGeometry ) {\n\n\t\t\tgeometry = new THREE.BufferGeometry();\n\n\t\t}\telse {\n\n\t\t\tgeometry = new THREE.Geometry();\n\n\t\t}\n\n\t\tvar material = new THREE.MeshPhongMaterial();\n\t\tvar mesh = new THREE.Mesh( geometry, material );\n\t\tmesh.name = 'mesh';\n\n\t\twhile ( next !== 0 ) {\n\n\t\t\tif ( next === POINT_ARRAY ) {\n\n\t\t\t\tvar points = this.readWord( data );\n\n\t\t\t\tthis.debugMessage( '   Vertex: ' + points );\n\n\t\t\t\t//BufferGeometry\n\n\t\t\t\tif ( useBufferGeometry )\t{\n\n\t\t\t\t\tvar vertices = [];\n\t\t\t\t\tfor ( var i = 0; i < points; i ++ )\t\t{\n\n\t\t\t\t\t\tvertices.push( this.readFloat( data ) );\n\t\t\t\t\t\tvertices.push( this.readFloat( data ) );\n\t\t\t\t\t\tvertices.push( this.readFloat( data ) );\n\n\t\t\t\t\t}\n\n\t\t\t\t\tgeometry.addAttribute( 'position', new THREE.BufferAttribute( new Float32Array( vertices ), 3 ) );\n\n\t\t\t\t} else\t{ //Geometry\n\n\t\t\t\t\tfor ( var i = 0; i < points; i ++ )\t\t{\n\n\t\t\t\t\t\tgeometry.vertices.push( new THREE.Vector3( this.readFloat( data ), this.readFloat( data ), this.readFloat( data ) ) );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} else if ( next === FACE_ARRAY ) {\n\n\t\t\t\tthis.resetPosition( data );\n\t\t\t\tthis.readFaceArray( data, mesh );\n\n\t\t\t} else if ( next === TEX_VERTS ) {\n\n\t\t\t\tvar texels = this.readWord( data );\n\n\t\t\t\tthis.debugMessage( '   UV: ' + texels );\n\n\t\t\t\t//BufferGeometry\n\n\t\t\t\tif ( useBufferGeometry )\t{\n\n\t\t\t\t\tvar uvs = [];\n\t\t\t\t\tfor ( var i = 0; i < texels; i ++ )\t\t{\n\n\t\t\t\t\t\tuvs.push( this.readFloat( data ) );\n\t\t\t\t\t\tuvs.push( this.readFloat( data ) );\n\n\t\t\t\t\t}\n\t\t\t\t\tgeometry.addAttribute( 'uv', new THREE.BufferAttribute( new Float32Array( uvs ), 2 ) );\n\n\t\t\t\t} else { //Geometry\n\n\t\t\t\t\tuvs = [];\n\t\t\t\t\tfor ( var i = 0; i < texels; i ++ )\t\t{\n\n\t\t\t\t\t\tuvs.push( new THREE.Vector2( this.readFloat( data ), this.readFloat( data ) ) );\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} else if ( next === MESH_MATRIX ) {\n\n\t\t\t\tthis.debugMessage( '   Tranformation Matrix (TODO)' );\n\n\t\t\t\tvar values = [];\n\t\t\t\tfor ( var i = 0; i < 12; i ++ ) {\n\n\t\t\t\t\tvalues[ i ] = this.readFloat( data );\n\n\t\t\t\t}\n\n\t\t\t\tvar matrix = new THREE.Matrix4();\n\n\t\t\t\t//X Line\n\t\t\t\tmatrix.elements[ 0 ] = values[ 0 ];\n\t\t\t\tmatrix.elements[ 1 ] = values[ 6 ];\n\t\t\t\tmatrix.elements[ 2 ] = values[ 3 ];\n\t\t\t\tmatrix.elements[ 3 ] = values[ 9 ];\n\n\t\t\t\t//Y Line\n\t\t\t\tmatrix.elements[ 4 ] = values[ 2 ];\n\t\t\t\tmatrix.elements[ 5 ] = values[ 8 ];\n\t\t\t\tmatrix.elements[ 6 ] = values[ 5 ];\n\t\t\t\tmatrix.elements[ 7 ] = values[ 11 ];\n\n\t\t\t\t//Z Line\n\t\t\t\tmatrix.elements[ 8 ] = values[ 1 ];\n\t\t\t\tmatrix.elements[ 9 ] = values[ 7 ];\n\t\t\t\tmatrix.elements[ 10 ] = values[ 4 ];\n\t\t\t\tmatrix.elements[ 11 ] = values[ 10 ];\n\n\t\t\t\t//W Line\n\t\t\t\tmatrix.elements[ 12 ] = 0;\n\t\t\t\tmatrix.elements[ 13 ] = 0;\n\t\t\t\tmatrix.elements[ 14 ] = 0;\n\t\t\t\tmatrix.elements[ 15 ] = 1;\n\n\t\t\t\tmatrix.transpose();\n\n\t\t\t\tvar inverse = new THREE.Matrix4();\n\t\t\t\tinverse.getInverse( matrix, true );\n\t\t\t\tgeometry.applyMatrix( inverse );\n\n\t\t\t\tmatrix.decompose( mesh.position, mesh.quaternion, mesh.scale );\n\n\t\t\t} else {\n\n\t\t\t\tthis.debugMessage( '   Unknown mesh chunk: ' + next.toString( 16 ) );\n\n\t\t\t}\n\n\t\t\tnext = this.nextChunk( data, chunk );\n\n\t\t}\n\n\t\tthis.endChunk( chunk );\n\n\t\tif ( ! useBufferGeometry ) {\n\n\t\t\t//geometry.faceVertexUvs[0][faceIndex][vertexIndex]\n\n\t\t\tif ( uvs.length > 0 ) {\n\n\t\t\t\tvar faceUV = [];\n\n\t\t\t\tfor ( var i = 0; i < geometry.faces.length; i ++ ) {\n\n\t\t\t\t\tfaceUV.push( [ uvs[ geometry.faces[ i ].a ], uvs[ geometry.faces[ i ].b ], uvs[ geometry.faces[ i ].c ] ] );\n\n\t\t\t\t}\n\n\t\t\t\tgeometry.faceVertexUvs[ 0 ] = faceUV;\n\n\t\t\t}\n\n\t\t\tgeometry.computeVertexNormals();\n\n\t\t}\n\n\t\treturn mesh;\n\n\t},\n\n\t/**\n\t * Read face array data chunk.\n\t *\n\t * @method readFaceArray\n\t * @param {Dataview} data Dataview in use.\n\t * @param {Mesh} mesh Mesh to be filled with the data read.\n\t */\n\treadFaceArray: function ( data, mesh ) {\n\n\t\tvar chunk = this.readChunk( data );\n\t\tvar faces = this.readWord( data );\n\n\t\tthis.debugMessage( '   Faces: ' + faces );\n\n\t\tfor ( var i = 0; i < faces; ++ i ) {\n\n\t\t\tmesh.geometry.faces.push( new THREE.Face3( this.readWord( data ), this.readWord( data ), this.readWord( data ) ) );\n\n\t\t\tvar visibility = this.readWord( data );\n\n\t\t}\n\n\t\t//The rest of the FACE_ARRAY chunk is subchunks\n\n\t\twhile ( this.position < chunk.end ) {\n\n\t\t\tvar chunk = this.readChunk( data );\n\n\t\t\tif ( chunk.id === MSH_MAT_GROUP ) {\n\n\t\t\t\tthis.debugMessage( '      Material Group' );\n\n\t\t\t\tthis.resetPosition( data );\n\n\t\t\t\tvar group = this.readMaterialGroup( data );\n\n\t\t\t\tvar material = this.materials[ group.name ];\n\n\t\t\t\tif ( material !== undefined )\t{\n\n\t\t\t\t\tmesh.material = material;\n\n\t\t\t\t\tif ( material.name === '' )\t\t{\n\n\t\t\t\t\t\tmaterial.name = mesh.name;\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t} else {\n\n\t\t\t\tthis.debugMessage( '      Unknown face array chunk: ' + chunk.toString( 16 ) );\n\n\t\t\t}\n\n\t\t\tthis.endChunk( chunk );\n\n\t\t}\n\n\t\tthis.endChunk( chunk );\n\n\t},\n\n\t/**\n\t * Read texture map data chunk.\n\t *\n\t * @method readMap\n\t * @param {Dataview} data Dataview in use.\n\t * @return {Texture} Texture read from this data chunk.\n\t */\n\treadMap: function ( data, path ) {\n    if (this.skipMaps) return null;\n\n\t\tvar chunk = this.readChunk( data );\n\t\tvar next = this.nextChunk( data, chunk );\n\t\tvar texture = {};\n\n\t\tvar loader = new THREE.TextureLoader( this.manager );\n\t\tloader.setPath( path );\n\n\t\twhile ( next !== 0 ) {\n\n\t\t\tif ( next === MAT_MAPNAME ) {\n\n\t\t\t\tvar name = this.readString( data, 128 );\n\t\t\t\ttexture = loader.load( name );\n\n\t\t\t\tthis.debugMessage( '      File: ' + path + name );\n\n\t\t\t} else if ( next === MAT_MAP_UOFFSET ) {\n\n\t\t\t\ttexture.offset.x = this.readFloat( data );\n\t\t\t\tthis.debugMessage( '      OffsetX: ' + texture.offset.x );\n\n\t\t\t} else if ( next === MAT_MAP_VOFFSET ) {\n\n\t\t\t\ttexture.offset.y = this.readFloat( data );\n\t\t\t\tthis.debugMessage( '      OffsetY: ' + texture.offset.y );\n\n\t\t\t} else if ( next === MAT_MAP_USCALE ) {\n\n\t\t\t\ttexture.repeat.x = this.readFloat( data );\n\t\t\t\tthis.debugMessage( '      RepeatX: ' + texture.repeat.x );\n\n\t\t\t} else if ( next === MAT_MAP_VSCALE ) {\n\n\t\t\t\ttexture.repeat.y = this.readFloat( data );\n\t\t\t\tthis.debugMessage( '      RepeatY: ' + texture.repeat.y );\n\n\t\t\t} else {\n\n\t\t\t\tthis.debugMessage( '      Unknown map chunk: ' + next.toString( 16 ) );\n\n\t\t\t}\n\n\t\t\tnext = this.nextChunk( data, chunk );\n\n\t\t}\n\n\t\tthis.endChunk( chunk );\n\n\t\treturn texture;\n\n\t},\n\n\t/**\n\t * Read material group data chunk.\n\t *\n\t * @method readMaterialGroup\n\t * @param {Dataview} data Dataview in use.\n\t * @return {Object} Object with name and index of the object.\n\t */\n\treadMaterialGroup: function ( data ) {\n\n\t\tvar chunk = this.readChunk( data );\n\t\tvar name = this.readString( data, 64 );\n\t\tvar numFaces = this.readWord( data );\n\n\t\tthis.debugMessage( '         Name: ' + name );\n\t\tthis.debugMessage( '         Faces: ' + numFaces );\n\n\t\tvar index = [];\n\t\tfor ( var i = 0; i < numFaces; ++ i ) {\n\n\t\t\tindex.push( this.readWord( data ) );\n\n\t\t}\n\n\t\treturn { name: name, index: index };\n\n\t},\n\n\t/**\n\t * Read a color value.\n\t *\n\t * @method readColor\n\t * @param {DataView} data Dataview.\n\t * @return {Color} Color value read..\n\t */\n\treadColor: function ( data ) {\n\n\t\tvar chunk = this.readChunk( data );\n\t\tvar color = new THREE.Color();\n\n\t\tif ( chunk.id === COLOR_24 || chunk.id === LIN_COLOR_24 ) {\n\n\t\t\tvar r = this.readByte( data );\n\t\t\tvar g = this.readByte( data );\n\t\t\tvar b = this.readByte( data );\n\n\t\t\tcolor.setRGB( r / 255, g / 255, b / 255 );\n\n\t\t\tthis.debugMessage( '      Color: ' + color.r + ', ' + color.g + ', ' + color.b );\n\n\t\t}\telse if ( chunk.id === COLOR_F || chunk.id === LIN_COLOR_F ) {\n\n\t\t\tvar r = this.readFloat( data );\n\t\t\tvar g = this.readFloat( data );\n\t\t\tvar b = this.readFloat( data );\n\n\t\t\tcolor.setRGB( r, g, b );\n\n\t\t\tthis.debugMessage( '      Color: ' + color.r + ', ' + color.g + ', ' + color.b );\n\n\t\t}\telse {\n\n\t\t\tthis.debugMessage( '      Unknown color chunk: ' + chunk.toString( 16 ) );\n\n\t\t}\n\n\t\tthis.endChunk( chunk );\n\t\treturn color;\n\n\t},\n\n\t/**\n\t * Read next chunk of data.\n\t *\n\t * @method readChunk\n\t * @param {DataView} data Dataview.\n\t * @return {Object} Chunk of data read.\n\t */\n\treadChunk: function ( data ) {\n\n\t\tvar chunk = {};\n\n\t\tchunk.cur = this.position;\n\t\tchunk.id = this.readWord( data );\n\t\tchunk.size = this.readDWord( data );\n\t\tchunk.end = chunk.cur + chunk.size;\n\t\tchunk.cur += 6;\n\n\t\treturn chunk;\n\n\t},\n\n\t/**\n\t * Set position to the end of the current chunk of data.\n\t *\n\t * @method endChunk\n\t * @param {Object} chunk Data chunk.\n\t */\n\tendChunk: function ( chunk ) {\n\n\t\tthis.position = chunk.end;\n\n\t},\n\n\t/**\n\t * Move to the next data chunk.\n\t *\n\t * @method nextChunk\n\t * @param {DataView} data Dataview.\n\t * @param {Object} chunk Data chunk.\n\t */\n\tnextChunk: function ( data, chunk ) {\n\n\t\tif ( chunk.cur >= chunk.end ) {\n\n\t\t\treturn 0;\n\n\t\t}\n\n\t\tthis.position = chunk.cur;\n\n\t\ttry {\n\n\t\t\tvar next = this.readChunk( data );\n\t\t\tchunk.cur += next.size;\n\t\t\treturn next.id;\n\n\t\t}\tcatch ( e ) {\n\n\t\t\tthis.debugMessage( 'Unable to read chunk at ' + this.position );\n\t\t\treturn 0;\n\n\t\t}\n\n\t},\n\n\t/**\n\t * Reset dataview position.\n\t *\n\t * @method resetPosition\n\t * @param {DataView} data Dataview.\n\t */\n\tresetPosition: function () {\n\n\t\tthis.position -= 6;\n\n\t},\n\n\t/**\n\t * Read byte value.\n\t *\n\t * @method readByte\n\t * @param {DataView} data Dataview to read data from.\n\t * @return {Number} Data read from the dataview.\n\t */\n\treadByte: function ( data ) {\n\n\t\tvar v = data.getUint8( this.position, true );\n\t\tthis.position += 1;\n\t\treturn v;\n\n\t},\n\n\t/**\n\t * Read 32 bit float value.\n\t *\n\t * @method readFloat\n\t * @param {DataView} data Dataview to read data from.\n\t * @return {Number} Data read from the dataview.\n\t */\n\treadFloat: function ( data ) {\n\n\t\ttry {\n\n\t\t\tvar v = data.getFloat32( this.position, true );\n\t\t\tthis.position += 4;\n\t\t\treturn v;\n\n\t\t}\tcatch ( e ) {\n\n\t\t\tthis.debugMessage( e + ' ' + this.position + ' ' + data.byteLength );\n\n\t\t}\n\n\t},\n\n\t/**\n\t * Read 32 bit signed integer value.\n\t *\n\t * @method readInt\n\t * @param {DataView} data Dataview to read data from.\n\t * @return {Number} Data read from the dataview.\n\t */\n\treadInt: function ( data ) {\n\n\t\tvar v = data.getInt32( this.position, true );\n\t\tthis.position += 4;\n\t\treturn v;\n\n\t},\n\n\t/**\n\t * Read 16 bit signed integer value.\n\t *\n\t * @method readShort\n\t * @param {DataView} data Dataview to read data from.\n\t * @return {Number} Data read from the dataview.\n\t */\n\treadShort: function ( data ) {\n\n\t\tvar v = data.getInt16( this.position, true );\n\t\tthis.position += 2;\n\t\treturn v;\n\n\t},\n\n\t/**\n\t * Read 64 bit unsigned integer value.\n\t *\n\t * @method readDWord\n\t * @param {DataView} data Dataview to read data from.\n\t * @return {Number} Data read from the dataview.\n\t */\n\treadDWord: function ( data ) {\n\n\t\tvar v = data.getUint32( this.position, true );\n\t\tthis.position += 4;\n\t\treturn v;\n\n\t},\n\n\t/**\n\t * Read 32 bit unsigned integer value.\n\t *\n\t * @method readWord\n\t * @param {DataView} data Dataview to read data from.\n\t * @return {Number} Data read from the dataview.\n\t */\n\treadWord: function ( data ) {\n\n\t\tvar v = data.getUint16( this.position, true );\n\t\tthis.position += 2;\n\t\treturn v;\n\n\t},\n\n\t/**\n\t * Read string value.\n\t *\n\t * @method readString\n\t * @param {DataView} data Dataview to read data from.\n\t * @param {Number} maxLength Max size of the string to be read.\n\t * @return {String} Data read from the dataview.\n\t */\n\treadString: function ( data, maxLength ) {\n\n\t\tvar s = '';\n\n\t\tfor ( var i = 0; i < maxLength; i ++ ) {\n\n\t\t\tvar c = this.readByte( data );\n\t\t\tif ( ! c ) {\n\n\t\t\t\tbreak;\n\n\t\t\t}\n\n\t\t\ts += String.fromCharCode( c );\n\n\t\t}\n\n\t\treturn s;\n\n\t},\n\n\t/**\n\t * Set resource path used to determine the file path to attached resources.\n\t *\n\t * @method setPath\n\t * @param {String} path Path to resources.\n\t * @return Self for chaining.\n\t */\n\tsetPath: function ( path ) {\n\n\t\tthis.path = path;\n\n\t\treturn this;\n\n\t},\n\n\t/**\n\t * Print debug message to the console.\n\t *\n\t * Is controlled by a flag to show or hide debug messages.\n\t *\n\t * @method debugMessage\n\t * @param {Object} message Debug message to print to the console.\n\t */\n\tdebugMessage: function ( message ) {\n\n\t\tif ( this.debug ) {\n\n\t\t\tconsole.log( message );\n\n\t\t}\n\n\t}\n};\n\nvar NULL_CHUNK = 0x0000;\nvar M3DMAGIC = 0x4D4D;\nvar SMAGIC = 0x2D2D;\nvar LMAGIC = 0x2D3D;\nvar MLIBMAGIC = 0x3DAA;\nvar MATMAGIC = 0x3DFF;\nvar CMAGIC = 0xC23D;\nvar M3D_VERSION = 0x0002;\nvar M3D_KFVERSION = 0x0005;\nvar COLOR_F = 0x0010;\nvar COLOR_24 = 0x0011;\nvar LIN_COLOR_24 = 0x0012;\nvar LIN_COLOR_F = 0x0013;\nvar INT_PERCENTAGE = 0x0030;\nvar FLOAT_PERCENTAGE = 0x0031;\nvar MDATA = 0x3D3D;\nvar MESH_VERSION = 0x3D3E;\nvar MASTER_SCALE = 0x0100;\nvar LO_SHADOW_BIAS = 0x1400;\nvar HI_SHADOW_BIAS = 0x1410;\nvar SHADOW_MAP_SIZE = 0x1420;\nvar SHADOW_SAMPLES = 0x1430;\nvar SHADOW_RANGE = 0x1440;\nvar SHADOW_FILTER = 0x1450;\nvar RAY_BIAS = 0x1460;\nvar O_CONSTS = 0x1500;\nvar AMBIENT_LIGHT = 0x2100;\nvar BIT_MAP = 0x1100;\nvar SOLID_BGND = 0x1200;\nvar V_GRADIENT = 0x1300;\nvar USE_BIT_MAP = 0x1101;\nvar USE_SOLID_BGND = 0x1201;\nvar USE_V_GRADIENT = 0x1301;\nvar FOG = 0x2200;\nvar FOG_BGND = 0x2210;\nvar LAYER_FOG = 0x2302;\nvar DISTANCE_CUE = 0x2300;\nvar DCUE_BGND = 0x2310;\nvar USE_FOG = 0x2201;\nvar USE_LAYER_FOG = 0x2303;\nvar USE_DISTANCE_CUE = 0x2301;\nvar MAT_ENTRY = 0xAFFF;\nvar MAT_NAME = 0xA000;\nvar MAT_AMBIENT = 0xA010;\nvar MAT_DIFFUSE = 0xA020;\nvar MAT_SPECULAR = 0xA030;\nvar MAT_SHININESS = 0xA040;\nvar MAT_SHIN2PCT = 0xA041;\nvar MAT_TRANSPARENCY = 0xA050;\nvar MAT_XPFALL = 0xA052;\nvar MAT_USE_XPFALL = 0xA240;\nvar MAT_REFBLUR = 0xA053;\nvar MAT_SHADING = 0xA100;\nvar MAT_USE_REFBLUR = 0xA250;\nvar MAT_SELF_ILLUM = 0xA084;\nvar MAT_TWO_SIDE = 0xA081;\nvar MAT_DECAL = 0xA082;\nvar MAT_ADDITIVE = 0xA083;\nvar MAT_WIRE = 0xA085;\nvar MAT_FACEMAP = 0xA088;\nvar MAT_TRANSFALLOFF_IN = 0xA08A;\nvar MAT_PHONGSOFT = 0xA08C;\nvar MAT_WIREABS = 0xA08E;\nvar MAT_WIRE_SIZE = 0xA087;\nvar MAT_TEXMAP = 0xA200;\nvar MAT_SXP_TEXT_DATA = 0xA320;\nvar MAT_TEXMASK = 0xA33E;\nvar MAT_SXP_TEXTMASK_DATA = 0xA32A;\nvar MAT_TEX2MAP = 0xA33A;\nvar MAT_SXP_TEXT2_DATA = 0xA321;\nvar MAT_TEX2MASK = 0xA340;\nvar MAT_SXP_TEXT2MASK_DATA = 0xA32C;\nvar MAT_OPACMAP = 0xA210;\nvar MAT_SXP_OPAC_DATA = 0xA322;\nvar MAT_OPACMASK = 0xA342;\nvar MAT_SXP_OPACMASK_DATA = 0xA32E;\nvar MAT_BUMPMAP = 0xA230;\nvar MAT_SXP_BUMP_DATA = 0xA324;\nvar MAT_BUMPMASK = 0xA344;\nvar MAT_SXP_BUMPMASK_DATA = 0xA330;\nvar MAT_SPECMAP = 0xA204;\nvar MAT_SXP_SPEC_DATA = 0xA325;\nvar MAT_SPECMASK = 0xA348;\nvar MAT_SXP_SPECMASK_DATA = 0xA332;\nvar MAT_SHINMAP = 0xA33C;\nvar MAT_SXP_SHIN_DATA = 0xA326;\nvar MAT_SHINMASK = 0xA346;\nvar MAT_SXP_SHINMASK_DATA = 0xA334;\nvar MAT_SELFIMAP = 0xA33D;\nvar MAT_SXP_SELFI_DATA = 0xA328;\nvar MAT_SELFIMASK = 0xA34A;\nvar MAT_SXP_SELFIMASK_DATA = 0xA336;\nvar MAT_REFLMAP = 0xA220;\nvar MAT_REFLMASK = 0xA34C;\nvar MAT_SXP_REFLMASK_DATA = 0xA338;\nvar MAT_ACUBIC = 0xA310;\nvar MAT_MAPNAME = 0xA300;\nvar MAT_MAP_TILING = 0xA351;\nvar MAT_MAP_TEXBLUR = 0xA353;\nvar MAT_MAP_USCALE = 0xA354;\nvar MAT_MAP_VSCALE = 0xA356;\nvar MAT_MAP_UOFFSET = 0xA358;\nvar MAT_MAP_VOFFSET = 0xA35A;\nvar MAT_MAP_ANG = 0xA35C;\nvar MAT_MAP_COL1 = 0xA360;\nvar MAT_MAP_COL2 = 0xA362;\nvar MAT_MAP_RCOL = 0xA364;\nvar MAT_MAP_GCOL = 0xA366;\nvar MAT_MAP_BCOL = 0xA368;\nvar NAMED_OBJECT = 0x4000;\nvar N_DIRECT_LIGHT = 0x4600;\nvar DL_OFF = 0x4620;\nvar DL_OUTER_RANGE = 0x465A;\nvar DL_INNER_RANGE = 0x4659;\nvar DL_MULTIPLIER = 0x465B;\nvar DL_EXCLUDE = 0x4654;\nvar DL_ATTENUATE = 0x4625;\nvar DL_SPOTLIGHT = 0x4610;\nvar DL_SPOT_ROLL = 0x4656;\nvar DL_SHADOWED = 0x4630;\nvar DL_LOCAL_SHADOW2 = 0x4641;\nvar DL_SEE_CONE = 0x4650;\nvar DL_SPOT_RECTANGULAR = 0x4651;\nvar DL_SPOT_ASPECT = 0x4657;\nvar DL_SPOT_PROJECTOR = 0x4653;\nvar DL_SPOT_OVERSHOOT = 0x4652;\nvar DL_RAY_BIAS = 0x4658;\nvar DL_RAYSHAD = 0x4627;\nvar N_CAMERA = 0x4700;\nvar CAM_SEE_CONE = 0x4710;\nvar CAM_RANGES = 0x4720;\nvar OBJ_HIDDEN = 0x4010;\nvar OBJ_VIS_LOFTER = 0x4011;\nvar OBJ_DOESNT_CAST = 0x4012;\nvar OBJ_DONT_RECVSHADOW = 0x4017;\nvar OBJ_MATTE = 0x4013;\nvar OBJ_FAST = 0x4014;\nvar OBJ_PROCEDURAL = 0x4015;\nvar OBJ_FROZEN = 0x4016;\nvar N_TRI_OBJECT = 0x4100;\nvar POINT_ARRAY = 0x4110;\nvar POINT_FLAG_ARRAY = 0x4111;\nvar FACE_ARRAY = 0x4120;\nvar MSH_MAT_GROUP = 0x4130;\nvar SMOOTH_GROUP = 0x4150;\nvar MSH_BOXMAP = 0x4190;\nvar TEX_VERTS = 0x4140;\nvar MESH_MATRIX = 0x4160;\nvar MESH_COLOR = 0x4165;\nvar MESH_TEXTURE_INFO = 0x4170;\nvar KFDATA = 0xB000;\nvar KFHDR = 0xB00A;\nvar KFSEG = 0xB008;\nvar KFCURTIME = 0xB009;\nvar AMBIENT_NODE_TAG = 0xB001;\nvar OBJECT_NODE_TAG = 0xB002;\nvar CAMERA_NODE_TAG = 0xB003;\nvar TARGET_NODE_TAG = 0xB004;\nvar LIGHT_NODE_TAG = 0xB005;\nvar L_TARGET_NODE_TAG = 0xB006;\nvar SPOTLIGHT_NODE_TAG = 0xB007;\nvar NODE_ID = 0xB030;\nvar NODE_HDR = 0xB010;\nvar PIVOT = 0xB013;\nvar INSTANCE_NAME = 0xB011;\nvar MORPH_SMOOTH = 0xB015;\nvar BOUNDBOX = 0xB014;\nvar POS_TRACK_TAG = 0xB020;\nvar COL_TRACK_TAG = 0xB025;\nvar ROT_TRACK_TAG = 0xB021;\nvar SCL_TRACK_TAG = 0xB022;\nvar MORPH_TRACK_TAG = 0xB026;\nvar FOV_TRACK_TAG = 0xB023;\nvar ROLL_TRACK_TAG = 0xB024;\nvar HOT_TRACK_TAG = 0xB027;\nvar FALL_TRACK_TAG = 0xB028;\nvar HIDE_TRACK_TAG = 0xB029;\nvar POLY_2D = 0x5000;\nvar SHAPE_OK = 0x5010;\nvar SHAPE_NOT_OK = 0x5011;\nvar SHAPE_HOOK = 0x5020;\nvar PATH_3D = 0x6000;\nvar PATH_MATRIX = 0x6005;\nvar SHAPE_2D = 0x6010;\nvar M_SCALE = 0x6020;\nvar M_TWIST = 0x6030;\nvar M_TEETER = 0x6040;\nvar M_FIT = 0x6050;\nvar M_BEVEL = 0x6060;\nvar XZ_CURVE = 0x6070;\nvar YZ_CURVE = 0x6080;\nvar INTERPCT = 0x6090;\nvar DEFORM_LIMIT = 0x60A0;\nvar USE_CONTOUR = 0x6100;\nvar USE_TWEEN = 0x6110;\nvar USE_SCALE = 0x6120;\nvar USE_TWIST = 0x6130;\nvar USE_TEETER = 0x6140;\nvar USE_FIT = 0x6150;\nvar USE_BEVEL = 0x6160;\nvar DEFAULT_VIEW = 0x3000;\nvar VIEW_TOP = 0x3010;\nvar VIEW_BOTTOM = 0x3020;\nvar VIEW_LEFT = 0x3030;\nvar VIEW_RIGHT = 0x3040;\nvar VIEW_FRONT = 0x3050;\nvar VIEW_BACK = 0x3060;\nvar VIEW_USER = 0x3070;\nvar VIEW_CAMERA = 0x3080;\nvar VIEW_WINDOW = 0x3090;\nvar VIEWPORT_LAYOUT_OLD = 0x7000;\nvar VIEWPORT_DATA_OLD = 0x7010;\nvar VIEWPORT_LAYOUT = 0x7001;\nvar VIEWPORT_DATA = 0x7011;\nvar VIEWPORT_DATA_3 = 0x7012;\nvar VIEWPORT_SIZE = 0x7020;\nvar NETWORK_VIEW = 0x7030;\n\nexport default THREE.TDSLoader;\n","export default 'data:text/plain;base64,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';\n","import Car from \"../physics/Car.js\";\nimport TDSLoader from \"./TDSLoader.js\";\nimport suvModel from \"../../models/suv.js\";\n\nconst CAR_COLOR = 0x0088ff;\nconst WHEEL_COLOR = 0xff8800;\n\nexport default class CarObject extends THREE.Object3D {\n  constructor(car) {\n    super();\n\n    this.car = car;\n\n    this.buildCar2D();\n    this.buildCar3D();\n  }\n\n  buildCar2D() {\n    const carMesh = new THREE.Mesh(\n      new THREE.PlaneGeometry(Car.HALF_CAR_LENGTH * 2, Car.HALF_CAR_WIDTH * 2),\n      new THREE.MeshBasicMaterial({ color: CAR_COLOR, depthTest: false, transparent: true, opacity: 0.7 })\n    );\n    carMesh.rotation.x = -Math.PI / 2;\n    carMesh.layers.set(2);\n    this.add(carMesh);\n\n    const wheelGeometry = new THREE.PlaneGeometry(Car.HALF_WHEEL_LENGTH * 2, Car.HALF_WHEEL_WIDTH * 2);\n    const wheelMaterial = new THREE.MeshBasicMaterial({ color: WHEEL_COLOR, depthTest: false, transparent: true, opacity: 0.7 })\n\n    this.lfWheel2D = new THREE.Mesh(wheelGeometry, wheelMaterial);\n    this.lfWheel2D.renderOrder = 1;\n    this.lfWheel2D.position.set(Car.FRONT_AXLE_POS, 0, Car.WHEEL_LATERAL_POS);\n    this.lfWheel2D.rotation.x = -Math.PI / 2;\n    this.lfWheel2D.layers.set(2);\n    this.add(this.lfWheel2D);\n\n    this.rfWheel2D = new THREE.Mesh(wheelGeometry, wheelMaterial);\n    this.rfWheel2D.renderOrder = 1;\n    this.rfWheel2D.position.set(Car.FRONT_AXLE_POS, 0, -Car.WHEEL_LATERAL_POS);\n    this.rfWheel2D.rotation.x = -Math.PI / 2;\n    this.rfWheel2D.layers.set(2);\n    this.add(this.rfWheel2D);\n\n    const lrWheel = new THREE.Mesh(wheelGeometry, wheelMaterial);\n    lrWheel.renderOrder = 1;\n    lrWheel.position.set(Car.REAR_AXLE_POS, 0, Car.WHEEL_LATERAL_POS);\n    lrWheel.rotation.x = -Math.PI / 2;\n    lrWheel.layers.set(2);\n    this.add(lrWheel);\n\n    const rrWheel = new THREE.Mesh(wheelGeometry, wheelMaterial);\n    rrWheel.renderOrder = 1;\n    rrWheel.position.set(Car.REAR_AXLE_POS, 0, -Car.WHEEL_LATERAL_POS);\n    rrWheel.rotation.x = -Math.PI / 2;\n    rrWheel.layers.set(2);\n    this.add(rrWheel);\n  }\n\n  buildCar3D() {\n    const loader = new TDSLoader();\n    loader.skipMaps = true;\n\n    loader.load(suvModel, object => {\n      object.layers.set(3);\n      object.rotation.z = Math.PI / 2;\n      object.rotation.x = -Math.PI / 2;\n\n      const box = (new THREE.Box3()).setFromObject(object);\n      const scaleLength = Car.HALF_CAR_LENGTH * 2 / (box.max.x - box.min.x);\n      const scaleWidth = Car.HALF_CAR_WIDTH * 2 / (box.max.z - box.min.z);\n      object.scale.set(scaleWidth, scaleLength, (scaleWidth + scaleLength) / 2);\n\n      box.setFromObject(object);\n      object.position.setX(-(box.max.x + box.min.x) / 2);\n      object.position.setY(-box.min.y);\n\n      this.add(object);\n\n      const carMaterial = new THREE.MeshToonMaterial({ color: 0x0088ff });\n      const wheelMaterial = new THREE.MeshToonMaterial({ color: 0xff8800 });\n\n      object.traverse(child => {\n        if (child instanceof THREE.Mesh) {\n          child.layers.set(3);\n          child.material = ['Toyota_RA7', 'Toyota_RA8', 'Toyota_RA9', 'Toyota_R10'].includes(child.name) ? wheelMaterial : carMaterial;\n\n          if (child.name == 'Toyota_RA7')\n            this.lfWheel3D = child;\n          else if (child.name == 'Toyota_RA8')\n            this.rfWheel3D = child;\n        }\n      });\n\n      [this.lfWheel3D, this.rfWheel3D].forEach(wheel => {\n        wheel.geometry.computeBoundingBox();\n        wheel.geometry.center();\n        wheel.position.setY(wheel.position.y - 36);\n        wheel.position.setZ(wheel.position.z + 36);\n      });\n    });\n  }\n\n  updateMatrix() {\n    this.updateCar();\n    super.updateMatrix();\n  }\n\n  updateCar() {\n    const carPosition = this.car.position;\n    this.position.set(carPosition.x, 0, carPosition.y);\n    this.rotation.y = -this.car.rotation;\n\n    const wheelAngle = this.car.wheelAngle;\n\n    // Adding the wheels to the car object can trigger this function in some browsers\n    // before the other wheels are added, so check them first.\n    if (this.lfWheel2D) this.lfWheel2D.rotation.z = -wheelAngle;\n    if (this.rfWheel2D) this.rfWheel2D.rotation.z = -wheelAngle;\n    if (this.lfWheel3D) this.lfWheel3D.rotation.y = wheelAngle;\n    if (this.rfWheel3D) this.rfWheel3D.rotation.y = wheelAngle;\n  }\n}\n","const COLOR = 0xdd0000;\nconst HEIGHT = 5;\n\nexport default class StaticObstacleObject extends THREE.Object3D {\n  constructor(staticObstacle) {\n    super();\n\n    const mesh2D = new THREE.Mesh(\n      new THREE.PlaneGeometry(staticObstacle.width, staticObstacle.height),\n      new THREE.MeshBasicMaterial({ color: COLOR, depthTest: false, transparent: true, opacity: 0.5 })\n    );\n    mesh2D.rotation.x = -Math.PI / 2;\n    mesh2D.layers.set(2);\n    this.add(mesh2D);\n\n    const stoneTexture = new THREE.TextureLoader().load('http://127.0.0.1:8008/images/stone.jpg');\n    stoneTexture.wrapS = THREE.RepeatWrapping\n    stoneTexture.wrapT = THREE.RepeatWrapping\n    stoneTexture.magFilter = THREE.NearestFilter\n\n    const mesh3D = new THREE.Mesh(\n      new THREE.BoxBufferGeometry(staticObstacle.width, HEIGHT, staticObstacle.height),\n      new THREE.MeshToonMaterial({ map: stoneTexture, transparent: true, opacity: 0.9 })\n    );\n    mesh3D.position.setY(HEIGHT / 2);\n    mesh3D.layers.set(3);\n    this.add(mesh3D);\n\n    this.rotation.y = -staticObstacle.rot;\n    this.position.set(staticObstacle.pos.x, 0, staticObstacle.pos.y);\n  }\n}\n","export default class DynamicObstacleObject extends THREE.Object3D {\n  constructor(dynamicObstacle, lanePath) {\n    super();\n\n    this.dynamicObstacle = dynamicObstacle;\n    this.lanePath = lanePath;\n    this.size = dynamicObstacle.size;\n\n    const colors = {\n      vehicle: 0xff8800,\n      cyclist: 0x00ccff,\n      pedestrian: 0xffdd00\n    };\n\n    const heights = {\n      vehicle: 2.0,\n      cyclist: 1.8,\n      pedestrian: 1.8\n    };\n\n    const mesh2D = new THREE.Mesh(\n      new THREE.PlaneGeometry(dynamicObstacle.size.w * 2, dynamicObstacle.size.h * 2),\n      new THREE.MeshBasicMaterial({ color: colors[dynamicObstacle.type] || 0xff8800, depthTest: false, transparent: true, opacity: 0.7 })\n    );\n    mesh2D.rotation.x = -Math.PI / 2;\n    mesh2D.layers.set(2);\n    this.add(mesh2D);\n\n    const mesh3D = new THREE.Mesh(\n      new THREE.BoxBufferGeometry(dynamicObstacle.size.w * 2, heights[dynamicObstacle.type] || 1.5, dynamicObstacle.size.h * 2),\n      new THREE.MeshToonMaterial({ color: colors[dynamicObstacle.type] || 0xff8800, transparent: true, opacity: 0.7 })\n    );\n    mesh3D.position.setY((heights[dynamicObstacle.type] || 1.5) / 2);\n    mesh3D.layers.set(3);\n    this.add(mesh3D);\n  }\n\n  update(time) {\n    const slPos = this.dynamicObstacle.positionAtTime(time);\n\n    // Sample just the station this dynamic obstacle is at\n    const [sample] = this.lanePath.sampleStations(slPos.x, 1, 0);\n\n    if (sample === undefined) {\n      this.visible = false;\n      return;\n    }\n\n    const rot = sample.rot;\n    const pos = THREE.Vector2.fromAngle(rot + Math.PI / 2).multiplyScalar(slPos.y).add(sample.pos);\n\n    this.position.set(pos.x, 0, pos.y);\n    this.rotation.y = -rot;\n\n    super.updateMatrix();\n\n    this.visible = slPos.x >= 0;\n  }\n}\n","const halfLaneWidth = 3.7;\n\nconst centerlineGeometry = new THREE.Geometry();\nconst leftBoundaryGeometry = new THREE.Geometry();\nconst rightBoundaryGeometry = new THREE.Geometry();\n\nexport default class LanePath {\n  static hydrate(obj) {\n    Object.setPrototypeOf(obj, LanePath.prototype);\n  }\n\n  constructor() {\n    this.anchors = [];\n    this.centerlines = [];\n    this.sampleLengths = [];\n    this.arcLengths = [];\n    this.leftBoundaries = [];\n    this.rightBoundaries = [];\n  }\n\n  get centerline() {\n    return [].concat(...this.centerlines);\n  }\n\n  get leftBoundary() {\n    return [].concat(...this.leftBoundaries);\n  }\n\n  get rightBoundary() {\n    return [].concat(...this.rightBoundaries);\n  }\n\n  get arcLength() {\n    return this.arcLengths.reduce((sum, l) => sum + l, 0);\n  }\n\n  sampleStations(startStation, num, interval) {\n    const samples = [];\n    let anchorIndex = 0;\n    let sampleIndex = 0;\n    let totalLength = 0;\n    let nextStation = startStation;\n\n    while (totalLength + this.arcLengths[anchorIndex] < nextStation) {\n      totalLength += this.arcLengths[anchorIndex];\n\n      if (++anchorIndex >= this.arcLengths.length)\n        return samples;\n    }\n\n    for (let i = 0; i < num; i++) {\n      let length = this.sampleLengths[anchorIndex][sampleIndex];\n      while (totalLength + length < nextStation) {\n        totalLength += length;\n\n        if (++sampleIndex >= this.sampleLengths[anchorIndex].length) {\n          sampleIndex = 0;\n\n          if (++anchorIndex >= this.sampleLengths.length)\n            return samples;\n        }\n\n        length = this.sampleLengths[anchorIndex][sampleIndex];\n      }\n\n      const [p0, p1, p2, p3] = this.anchorsForSplineIndex(anchorIndex);\n      const weight = (sampleIndex + (nextStation - totalLength) / length) / this.sampleLengths[anchorIndex].length;\n      const pos = catmullRomVec(weight, p0, p1, p2, p3);\n      const tangent = tangentAt(weight, p0, p1, p2, p3);\n      const rot = Math.atan2(tangent.y, tangent.x);\n      const curv = curvatureAt(weight, p0, p1, p2, p3);\n\n      samples.push({ pos, rot, curv });\n      nextStation += interval;\n    }\n\n    return samples;\n  }\n\n  stationLatitudeFromPosition(position, aroundAnchorIndex = null) {\n    const [anchorIndex, sampleIndex, sampleStation, prevSampleStation] = this._findClosestSample(position, aroundAnchorIndex);\n\n    if (anchorIndex === undefined) return [0, 0, 0];\n\n    let prevPoint;\n    let nextPoint;\n    let prevStation;\n    let nextStation;\n\n    if (anchorIndex == 0 && sampleIndex == 0) {\n      prevPoint = this.centerlines[anchorIndex][sampleIndex];\n      nextPoint = this.centerlines[anchorIndex][sampleIndex + 1];\n      prevStation = 0;\n      nextStation = this.sampleLengths[anchorIndex][sampleIndex];\n    } else if (anchorIndex == this.centerlines.length - 1 && sampleIndex == this.centerlines[anchorIndex].length - 1) {\n      prevPoint = this.centerlines[anchorIndex][sampleIndex - 1];\n      nextPoint = this.centerlines[anchorIndex][sampleIndex];\n      prevStation = prevSampleStation;\n      nextStation = sampleStation;\n    } else {\n      prevPoint = sampleIndex == 0 ? this.centerlines[anchorIndex - 1][this.centerlines[anchorIndex - 1].length - 1] : this.centerlines[anchorIndex][sampleIndex - 1];\n      nextPoint = sampleIndex == this.centerlines[anchorIndex].length - 1 ? this.centerlines[anchorIndex + 1][0] : this.centerlines[anchorIndex][sampleIndex + 1];\n\n      const possibleNext = this.centerlines[anchorIndex][sampleIndex];\n      const possibleProgress = position.clone().sub(prevPoint).dot(possibleNext.clone().sub(prevPoint)) / prevPoint.distanceToSquared(possibleNext);\n\n      if (possibleProgress < 1) {\n        nextPoint = possibleNext;\n        prevStation = prevSampleStation;\n        nextStation = sampleStation;\n      } else {\n        prevPoint = possibleNext;\n        prevStation = sampleStation;\n        nextStation = sampleStation + this.sampleLengths[anchorIndex][sampleIndex];\n      }\n    }\n\n    const progress = Math.clamp(position.clone().sub(prevPoint).dot(nextPoint.clone().sub(prevPoint)) / prevPoint.distanceToSquared(nextPoint), 0, 1);\n    const projectedPosition = nextPoint.clone().sub(prevPoint).multiplyScalar(progress).add(prevPoint);\n\n    const station = prevStation + (nextStation - prevStation) * progress;\n    const latitude = Math.sign((nextPoint.x - prevPoint.x) * (position.y - prevPoint.y) - (nextPoint.y - prevPoint.y) * (position.x - prevPoint.x)) * position.distanceTo(projectedPosition);\n\n    return [station, latitude, anchorIndex];\n  }\n\n  _findClosestSample(position, aroundAnchorIndex = null) {\n    let closest = Number.POSITIVE_INFINITY;\n    let bestAnchorIndex;\n    let bestSampleIndex;\n    let bestStation;\n    let bestPrevStation;\n\n    let currStation = 0;\n    let prevStation = 0;\n\n    let startAnchorIndex = 0;\n    let endAnchorIndex = this.centerlines.length - 1;\n\n    if (aroundAnchorIndex !== null) {\n      startAnchorIndex = Math.max(0, aroundAnchorIndex - 2);\n      endAnchorIndex = Math.min(this.centerlines.length - 1, aroundAnchorIndex + 2);\n    }\n\n    if (startAnchorIndex > 0) {\n      for (let anchorIndex = 0; anchorIndex < startAnchorIndex; anchorIndex++) {\n        currStation += this.arcLengths[anchorIndex];\n      }\n\n      prevStation = currStation - this.sampleLengths[startAnchorIndex - 1][this.sampleLengths[startAnchorIndex - 1].length - 1];\n    }\n\n    for (let anchorIndex = startAnchorIndex; anchorIndex <= endAnchorIndex; anchorIndex++) {\n      const centerline = this.centerlines[anchorIndex];\n      for (let sampleIndex = 0; sampleIndex < centerline.length; sampleIndex++) {\n        const distSq = position.distanceToSquared(centerline[sampleIndex]);\n        if (distSq < closest) {\n          closest = distSq;\n          bestAnchorIndex = anchorIndex;\n          bestSampleIndex = sampleIndex;\n          bestStation = currStation;\n          bestPrevStation = prevStation;\n        }\n\n        prevStation = currStation;\n        currStation += this.sampleLengths[anchorIndex][sampleIndex];\n      }\n    }\n\n    return [bestAnchorIndex, bestSampleIndex, bestStation, bestPrevStation];\n  }\n\n  addAnchor(position, resample = true) {\n    const index = this.anchors.push(position) - 1;\n\n    if (resample) {\n      for (let i = index - 2; i < index; i++)\n        this.resample(i);\n    }\n  }\n\n  updateAnchor(index, position) {\n    this.anchors[index] = position;\n\n    for (let i = index - 2; i <= index + 1; i++)\n      this.resample(i);\n  }\n\n  removeAnchor(index) {\n    if (index < 0 || index >= this.anchors.length) return;\n\n    this.anchors.splice(index, 1);\n\n    const segmentIndex = index < this.anchors.length ? index : index - 1;\n    this.centerlines.splice(segmentIndex, 1);\n    this.sampleLengths.splice(segmentIndex, 1);\n    this.leftBoundaries.splice(segmentIndex, 1);\n    this.rightBoundaries.splice(segmentIndex, 1);\n    this.arcLengths.splice(segmentIndex, 1);\n\n    for (let i = segmentIndex - 2; i <= segmentIndex; i++)\n      this.resample(i);\n  }\n\n  resample(index) {\n    if (index < 0 || index > this.anchors.length - 2) return;\n\n    const [p0, p1, p2, p3] = this.anchorsForSplineIndex(index);\n    const points = [];\n    const lengths = [];\n    const leftBoundary = [];\n    const rightBoundary = [];\n    let prevPoint = null;\n\n    const pointsPerSegment = Math.max(10, Math.ceil(p1.distanceTo(p2) / 1));\n    const numPoints = index == this.anchors.length - 2 ? pointsPerSegment + 1 : pointsPerSegment;\n\n    for (let i = 0; i < numPoints; i++) {\n      const t = i / pointsPerSegment;\n      const point = catmullRomVec(t, p0, p1, p2, p3);\n      points.push(point);\n\n      if (prevPoint != null)\n        lengths.push(prevPoint.distanceTo(point));\n      prevPoint = point;\n\n      const tangent = tangentAt(t, p0, p1, p2, p3);\n      const normal = new THREE.Vector2(-tangent.y, tangent.x);\n\n      leftBoundary.push(normal.clone().multiplyScalar(-halfLaneWidth).add(point));\n      rightBoundary.push(normal.clone().multiplyScalar(halfLaneWidth).add(point));\n    }\n\n    lengths.push(prevPoint.distanceTo(p2));\n\n    this.centerlines[index] = points;\n    this.sampleLengths[index] = lengths;\n    this.leftBoundaries[index] = leftBoundary;\n    this.rightBoundaries[index] = rightBoundary;\n    this.arcLengths[index] = lengths.reduce((sum, l) => sum + l, 0);\n  }\n\n  resampleAll() {\n    for (let i = 0; i < this.anchors.length; i++)\n      this.resample(i);\n  }\n\n  anchorsForSplineIndex(index) {\n    let p;\n    if (index == 0)\n      p = [this.anchors[0]].concat(this.anchors.slice(0, 3));\n    else\n      p = this.anchors.slice(index - 1, index + 3);\n\n    if (p[3] === undefined)\n      p[3] = p[2];\n\n    return p;\n  }\n}\n\nfunction catmullRom(t, p0, p1, p2, p3) {\n  const v0 = (p2 - p0) * 0.5;\n  const v1 = (p3 - p1) * 0.5;\n  const t2 = t * t;\n  const t3 = t * t2;\n  return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;\n}\n\nfunction catmullRomVec(t, p0, p1, p2, p3) {\n  return new THREE.Vector2(catmullRom(t, p0.x, p1.x, p2.x, p3.x), catmullRom(t, p0.y, p1.y, p2.y, p3.y));\n}\n\nfunction tangentAt(t, p0, p1, p2, p3) {\n  const delta = 0.0001;\n  let t1 = t - delta;\n  let t2 = t + delta;\n\n  if (t1 < 0) t1 = 0;\n  if (t2 > 1) t2 = 1;\n\n  const prev = catmullRomVec(t1, p0, p1, p2, p3);\n  const next = catmullRomVec(t2, p0, p1, p2, p3);\n\n  return next.sub(prev).normalize();\n}\n\nfunction curvatureAt(t2, p0, p1, p2, p3) {\n  const delta = 0.0001;\n\n  // If we're estimating curvature at one of the endpoints of the spline,\n  // slightly shift it inwards to avoid infinite curvature.\n  if (t2 == 0) t2 = delta;\n  if (t2 == 1) t2 = 1 - delta;\n\n  let t1 = t2 - delta;\n  let t3 = t2 + delta;\n\n  if (t1 < 0) t1 = 0;\n  if (t3 > 1) t3 = 1;\n\n  const pt1 = catmullRomVec(t1, p0, p1, p2, p3);\n  const pt2 = catmullRomVec(t2, p0, p1, p2, p3);\n  const pt3 = catmullRomVec(t3, p0, p1, p2, p3);\n\n  return (Math.atan2(pt3.y - pt2.y, pt3.x - pt2.x) - Math.atan2(pt2.y - pt1.y, pt2.x - pt1.x)) / pt2.distanceTo(pt1);\n}\n","export default class StaticObstacle {\n  static hydrate(obj) {\n    Object.setPrototypeOf(obj, StaticObstacle.prototype);\n    Object.setPrototypeOf(obj.pos, THREE.Vector2.prototype);\n  }\n\n  static fromJSON(json) {\n    return new StaticObstacle(new THREE.Vector2(json.p[0], json.p[1]), json.r, json.w, json.h);\n  }\n\n  constructor(pos, rot, width, height) {\n    this.pos = pos;\n    this.rot = rot;\n    this.width = width;\n    this.height = height;\n\n    this.updateVertices();\n  }\n\n  toJSON() {\n    const trunc = n => +n.toFixed(5);\n\n    return {\n      p: [trunc(this.pos.x), trunc(this.pos.y)],\n      r: trunc(this.rot),\n      w: trunc(this.width),\n      h: trunc(this.height)\n    };\n  }\n\n  updateVertices() {\n    this.vertices = [];\n\n    const cosRot = Math.cos(this.rot);\n    const sinRot = Math.sin(this.rot);\n    const halfWidth = this.width / 2;\n    const halfHeight = this.height / 2;\n\n    const hWcR = halfWidth * cosRot;\n    const hWsR = halfWidth * sinRot;\n    const hHcR = halfHeight * cosRot;\n    const hHsR = halfHeight * sinRot;\n\n    const v1 = [-hWcR - hHsR + this.pos.x, -hWsR + hHcR + this.pos.y];\n    const v2 = [-hWcR + hHsR + this.pos.x, -hWsR - hHcR + this.pos.y];\n    const v3 = [hWcR + hHsR + this.pos.x, hWsR - hHcR + this.pos.y];\n    const v4 = [hWcR - hHsR + this.pos.x, hWsR + hHcR + this.pos.y];\n\n    this.vertices = [\n      v1[0], v1[1],\n      v2[0], v2[1],\n      v3[0], v3[1],\n      v3[0], v3[1],\n      v4[0], v4[1],\n      v1[0], v1[1]\n    ];\n  }\n}\n","// Half width and half height\nconst VEHICLE_SIZE = { w: 2.5, h: 1 };\nconst CYCLIST_SIZE = { w: 1.2, h: 0.6 };\nconst PEDESTRIAN_SIZE = { w: 0.6, h: 0.6 };\n\nexport default class DynamicObstacle {\n  static hydrate(obj) {\n    Object.setPrototypeOf(obj, DynamicObstacle.prototype);\n    Object.setPrototypeOf(obj.startPos, THREE.Vector2.prototype);\n    Object.setPrototypeOf(obj.velocity, THREE.Vector2.prototype);\n  }\n\n  constructor(type, startPos, velocity, parallel) {\n    this.type = type;\n    this.startPos = startPos;\n    this.velocity = velocity;\n    this.parallel = parallel;\n\n    switch (type) {\n        case 'cyclist':\n          this.size = Object.assign({}, CYCLIST_SIZE);\n          break;\n\n        case 'pedestrian':\n          this.size = Object.assign({}, PEDESTRIAN_SIZE);\n          break;\n\n        default:\n          this.size = Object.assign({}, VEHICLE_SIZE);\n    }\n\n    if (!parallel)\n      [this.size.w, this.size.h] = [this.size.h, this.size.w];\n  }\n\n  positionAtTime(time) {\n    return this.velocity.clone().multiplyScalar(time).add(this.startPos);\n  }\n\n  positionsInTimeRange(startTime, endTime, numFrames) {\n    const dt = (endTime - startTime) / numFrames;\n    const positions = [];\n    let time = startTime;\n\n    for (let i = 0; i <= numFrames; i++) {\n      positions.push(this.positionAtTime(time));\n      time += dt;\n    }\n\n    return positions;\n  }\n\n  verticesInTimeRange(startTime, endTime, config) {\n    const positions = this.positionsInTimeRange(startTime, endTime, config.numDynamicSubframes);\n    const vertices = [];\n\n    // Hazard dilation (drawn behind, z = 0.75)\n    const hazardHalfWidth = this.size.w + config.dynamicHazardDilationS + config.collisionDilationS;\n    const hazardHalfHeight = this.size.h + config.dynamicHazardDilationL + config.collisionDilationL;\n\n    positions.forEach(p => {\n      const v1 = [-hazardHalfWidth + p.x, hazardHalfHeight + p.y];\n      const v2 = [hazardHalfWidth + p.x, hazardHalfHeight + p.y];\n      const v3 = [hazardHalfWidth + p.x, -hazardHalfHeight + p.y];\n      const v4 = [-hazardHalfWidth + p.x, -hazardHalfHeight + p.y];\n\n      vertices.push(\n        v1[0], v1[1], 0.75,\n        v2[0], v2[1], 0.75,\n        v3[0], v3[1], 0.75,\n        v3[0], v3[1], 0.75,\n        v4[0], v4[1], 0.75,\n        v1[0], v1[1], 0.75\n      );\n    });\n\n    // Collision dilation (drawn in front, z = 0.25)\n    const collisionHalfWidth = this.size.w + config.collisionDilationS;\n    const collisionHalfHeight = this.size.h + config.collisionDilationL;\n\n    positions.forEach(p => {\n      const v1 = [-collisionHalfWidth + p.x, collisionHalfHeight + p.y];\n      const v2 = [collisionHalfWidth + p.x, collisionHalfHeight + p.y];\n      const v3 = [collisionHalfWidth + p.x, -collisionHalfHeight + p.y];\n      const v4 = [-collisionHalfWidth + p.x, -collisionHalfHeight + p.y];\n\n      vertices.push(\n        v1[0], v1[1], 0.25,\n        v2[0], v2[1], 0.25,\n        v3[0], v3[1], 0.25,\n        v3[0], v3[1], 0.25,\n        v4[0], v4[1], 0.25,\n        v1[0], v1[1], 0.25\n      );\n    });\n\n    return vertices;\n  }\n}\n","import Car from \"../physics/Car.js\";\n\nconst LOCAL_STORAGE_KEY = 'dash_PathPlannerConfig';\n\nconst internalConfig = {\n  lattice: {\n    numStations: 8,\n    numLatitudes: 17,\n    stationConnectivity: 3,\n    latitudeConnectivity: 7\n  },\n\n  roadWidth: 3.7 * 2, // meters\n\n  numDynamicFrames: 20,\n  numDynamicSubframes: 4,\n\n  dCurvatureMax: Car.MAX_STEER_SPEED / Car.WHEEL_BASE,\n  rearAxleToCenter: -Car.REAR_AXLE_POS\n};\n\nconst defaultConfig = {\n  spatialHorizon: 120, // meters\n  centerlineStationInterval: 0.5, // meters\n\n  xyGridCellSize: 0.3, // meters\n  slGridCellSize: 0.15, // meters\n  gridMargin: 20, // meters\n  pathSamplingStep: 1, // meters\n\n  cubicPathPenalty: 0,\n\n  collisionDilationS: Car.HALF_CAR_LENGTH + 2, // meters\n  hazardDilationS: 8, // meters\n  collisionDilationL: Car.HALF_CAR_WIDTH + 0.5, //meters\n  hazardDilationL: 0.5, // meters\n\n  dynamicHazardDilationS: 16,\n  dynamicHazardDilationL: 0.5,\n\n  obstacleHazardCost: 200,\n\n  laneCenterLatitude: internalConfig.roadWidth / 4,\n  laneShoulderLatitude: internalConfig.roadWidth / 2 * 1.1 - Car.HALF_CAR_WIDTH,\n  laneCostSlope: 20, // cost / meter\n  lanePreferenceDiscount: 55,\n\n  stationReachDiscount: 400,\n  extraTimePenalty: 1000,\n\n  hysteresisDiscount: 50,\n\n  speedLimitPenalty: 200,\n\n  hardAccelerationPenalty: 70,\n  hardDecelerationPenalty: 50,\n\n  softLateralAccelerationLimit: 4, // m/s^2\n  softLateralAccelerationPenalty: 100,\n  linearLateralAccelerationPenalty: 10,\n\n  accelerationChangePenalty: 10\n};\n\nexport default class PathPlannerConfigEditor {\n  constructor() {\n    this._config = Object.assign({}, defaultConfig);\n\n    this.showConfigBox = document.getElementById('show-config-box');\n    this.configBox = document.getElementById('config-box-content');\n    this.configForm = document.getElementById('config-form');\n\n    this._setUpButtons();\n\n    let storedConfig = {};\n    try {\n      storedConfig = JSON.parse(window.localStorage.getItem(LOCAL_STORAGE_KEY)) || {};\n    } catch (e) {}\n\n    for (const key of Object.keys(this._config).sort()) {\n      if (storedConfig[key] !== undefined) this._config[key] = storedConfig[key];\n      this.configForm.appendChild(this._createConfigField(key, this._config[key]));\n    }\n  }\n\n  get config() {\n    return Object.assign({}, this._config, internalConfig);\n  }\n\n  _setUpButtons() {\n    document.getElementById('show-config-button').addEventListener('click', e => {\n      this.showConfigBox.classList.add('is-hidden');\n      this.configBox.classList.remove('is-hidden');\n    });\n\n    document.getElementById('hide-config-button').addEventListener('click', e => {\n      this.showConfigBox.classList.remove('is-hidden');\n      this.configBox.classList.add('is-hidden');\n    });\n\n    document.getElementById('save-config-button').addEventListener('click', this._saveConfigFields.bind(this));\n    document.getElementById('restore-defaults-config-button').addEventListener('click', this._restoreDefaults.bind(this));\n  }\n\n  _createConfigField(key, value) {\n    const html =\n      `<div class=\"field is-horizontal\">\n          <div class=\"field-label is-small\" style=\"flex-grow: 100;\">\n              <label class=\"label has-text-grey-light\" for=\"config-field-${key}\">${key}</label>\n          </div>\n          <div class=\"field-body\">\n              <div class=\"field\">\n                  <div class=\"control\" style=\"margin-right: 16px;\">\n                      <input id=\"config-field-${key}\" name=\"${key}\" class=\"input is-small ${value !== defaultConfig[key] ? 'is-danger' : ''}\" type=\"text\" style=\"width: 60px; border-width: 2px;\" value=\"${value}\" />\n                  </div>\n              </div>\n          </div>\n      </div>`;\n\n    const template = document.createElement('template');\n    template.innerHTML = html;\n    return template.content.firstChild;\n  }\n\n  _saveConfigFields() {\n    const formData = new FormData(this.configForm);\n\n    for (const [k, v] of formData.entries()) {\n      const parsedValue = Number.parseFloat(v);\n      this._config[k] = parsedValue\n\n      const fieldDom = document.getElementById(`config-field-${k}`);\n      if (parsedValue === defaultConfig[k])\n        fieldDom.classList.remove('is-danger');\n      else\n        fieldDom.classList.add('is-danger');\n    }\n\n    try {\n      window.localStorage.setItem(LOCAL_STORAGE_KEY, JSON.stringify(this._config));\n    } catch (e) {}\n  }\n\n  _restoreDefaults() {\n    this._config = Object.assign({}, defaultConfig);\n\n    try {\n      window.localStorage.removeItem(LOCAL_STORAGE_KEY);\n    } catch (e) {}\n\n    while (this.configForm.firstChild)\n      this.configForm.removeChild(this.configForm.firstChild);\n\n    for (const key of Object.keys(this._config).sort())\n      this.configForm.appendChild(this._createConfigField(key, this._config[key]));\n  }\n}\n\nPathPlannerConfigEditor.internalConfig = internalConfig;\n","import DynamicObstacle from \"../autonomy/DynamicObstacle.js\";\nimport PathPlannerConfigEditor from \"./PathPlannerConfigEditor.js\";\n\nexport default class DynamicObstacleEditor {\n  constructor() {\n    this.editorDom = document.getElementById('editor-dynamic-obstacles-box');\n    this.formsContainer = document.getElementById('editor-dynamic-obstacle-forms');\n    this.statsDynamicObstacles = document.getElementById('editor-stats-dynamic-obstacles');\n\n    document.getElementById('editor-add-dynamic-obstacle').addEventListener('click', this.addDynamicObstacle.bind(this));\n  }\n\n  enable() {\n    this.editorDom.classList.remove('is-hidden');\n  }\n\n  disable() {\n    this.editorDom.classList.add('is-hidden');\n  }\n\n  toJSON() {\n    const forms = this.formsContainer.getElementsByTagName('form');\n    const obstacles = [];\n\n    for (let i = 0; i < forms.length; i++) {\n      const formData = new FormData(forms[i]);\n      const params = { parallel: false };\n\n      for (const [k, v] of formData.entries())\n        params[k] = v;\n\n      let type = 0;\n      if (params.type == 'cyclist')\n        type = 1;\n      else if (params.type == 'pedestrian')\n        type = 2;\n\n      obstacles.push({\n        p: [params.sPos, params.lPos],\n        v: [params.sVel, params.lVel],\n        l: !!params.parallel ? 1 : 0,\n        t: type\n      });\n    }\n\n    return obstacles;\n  }\n\n  loadJSON(json) {\n    this.clearDynamicObstacles();\n\n    json.forEach(o => {\n      const form = this.addDynamicObstacle();\n\n      form['sPos'].value = o.p[0];\n      form['lPos'].value = o.p[1];\n      form['sVel'].value = o.v[0];\n      form['lVel'].value = o.v[1];\n      form['parallel'].checked = !!o.l;\n      form['type'].selectedIndex = o.t;\n    });\n  }\n\n  collectDynamicObstacles() {\n    const forms = this.formsContainer.getElementsByTagName('form');\n    const obstacles = [];\n\n    for (let i = 0; i < forms.length; i++) {\n      const formData = new FormData(forms[i]);\n      const params = { parallel: false };\n\n      for (const [k, v] of formData.entries())\n        params[k] = v;\n\n      const pos = new THREE.Vector2(Number(params.sPos) || 0, (Number(params.lPos) || 0) * PathPlannerConfigEditor.internalConfig.roadWidth / 2);\n      const vel = new THREE.Vector2(Number(params.sVel) || 0, Number(params.lVel) || 0);\n      const parallel = !!params.parallel;\n\n      obstacles.push(new DynamicObstacle(params.type, pos, vel, parallel));\n    }\n\n    return obstacles;\n  }\n\n  addDynamicObstacle() {\n    const index = this.formsContainer.getElementsByTagName('form').length + 1;\n    const form = this.buildForm(index);\n\n    this.formsContainer.appendChild(form);\n    this.statsDynamicObstacles.textContent = this.formsContainer.getElementsByTagName('form').length;\n\n    return form;\n  }\n\n  removeDynamicObstacle(form) {\n    this.formsContainer.removeChild(form);\n    this.reindexForms();\n    this.statsDynamicObstacles.textContent = this.formsContainer.getElementsByTagName('form').length;\n  }\n\n  clearDynamicObstacles() {\n    this.formsContainer.innerHTML = '';\n    this.statsDynamicObstacles.textContent = 0;\n  }\n\n  reindexForms() {\n    const forms = this.formsContainer.getElementsByTagName('form');\n\n    for (let i = 0; i < forms.length; i++) {\n      forms[i].getElementsByClassName('dynamic-obstacle-index')[0].textContent = i + 1;\n    }\n  }\n\n  buildForm(index) {\n    const html =\n      `<form class=\"editor-dynamic-obstacle-form\">\n          <div class=\"columns is-gapless\">\n              <div class=\"column is-1\">\n                  <div class=\"field\">\n                      <div class=\"field-label is-normal is-size-7 has-text-grey-lighter has-text-weight-bold dynamic-obstacle-index\">${index}</div>\n                  </div>\n              </div>\n              <div class=\"column is-3\">\n                  <div class=\"field\">\n                      <div class=\"control\">\n                          <div class=\"select is-small\">\n                              <select name=\"type\">\n                                  <option value=\"vehicle\">Vehicle</option>\n                                  <option value=\"cyclist\">Cyclist</option>\n                                  <option value=\"pedestrian\">Pedestrian</option>\n                              </select>\n                          </div>\n                      </div>\n                  </div>\n              </div>\n              <div class=\"column is-1\">\n                  <div class=\"field\">\n                      <div class=\"control has-text-centered\">\n                          <label class=\"checkbox\">\n                              <input type=\"checkbox\" name=\"parallel\" checked />&nbsp;\n                          </label>\n                      </div>\n                  </div>\n              </div>\n              <div class=\"column is-3\">\n                  <div class=\"field has-addons editor-field-center\">\n                      <div class=\"control\">\n                          <input class=\"input is-small\" type=\"text\" name=\"sPos\" style=\"width: 50px;\" value=\"0\" />\n                      </div>\n                      <div class=\"control\">\n                          <input class=\"input is-small\" type=\"text\" name=\"lPos\" style=\"width: 50px;\" value=\"0\" />\n                      </div>\n                  </div>\n              </div>\n              <div class=\"column is-3\">\n                  <div class=\"field has-addons editor-field-center\">\n                      <div class=\"control\">\n                          <input class=\"input is-small\" type=\"text\" name=\"sVel\" style=\"width: 50px;\" value=\"0\" />\n                      </div>\n                      <div class=\"control\">\n                          <input class=\"input is-small\" type=\"text\" name=\"lVel\" style=\"width: 50px;\" value=\"0\" />\n                      </div>\n                  </div>\n              </div>\n              <div class=\"column is-1\">\n                  <div class=\"field has-text-right\">\n                      <div class=\"button is-small is-danger editor-remove-dynamic-obstacle\" title=\"Remove Dynamic Obstacle\">\n                          <span class=\"icon is-small\">\n                              <i class=\"fas fa-lg fa-trash-alt\"></i>\n                          </span>\n                      </div>\n                  </div>\n              </div>\n          </div>\n      </form>`;\n\n    const template = document.createElement('template');\n    template.innerHTML = html;\n    const form = template.content.firstChild;\n\n    form.getElementsByClassName('editor-remove-dynamic-obstacle')[0].addEventListener('click', e => this.removeDynamicObstacle(form));\n\n    return form;\n  }\n}\n","function formatDate(date) {\n  return date && date.toLocaleDateString(undefined, {month: 'short', day: 'numeric', year: 'numeric', hour: 'numeric', minute: 'numeric', hour12: true});\n}\n\nexport { formatDate };\n","export default [\n  { name: \"One-car overtake\", data: {\"p\":[-298.12979,357.51057,7.55497,136.89255,255.45446,-186.65063,586.66288,-494.5808],\"s\":[],\"d\":[{\"p\":[\"150\",\"0.5\"],\"v\":[\"15\",\"0\"],\"l\":1,\"t\":0}],\"l\":1238.129,\"c\":{\"s\":\"25\",\"sl\":\"25\",\"lp\":1},\"v\":1} },\n\n  { name: \"Two-car overtake\", data: {\"p\":[-276.4674,303.00865,44.88593,120.86712,305.10729,-435.99728],\"s\":[],\"d\":[{\"p\":[\"100\",\"0.5\"],\"v\":[\"5\",\"0\"],\"l\":1,\"t\":0},{\"p\":[\"100\",\"-0.5\"],\"v\":[\"6\",\"0\"],\"l\":1,\"t\":0}],\"l\":990.576,\"c\":{\"s\":\"20\",\"sl\":\"20\",\"lp\":1},\"v\":1} },\n\n  { name: \"Rough road\", data: {\"p\":[-102.46078,26.38513,-68.69821,25.79776,-55.94913,19.50427,-25.32284,12.6183,-16.6024,10.7739,-6.708,11.78013,31.36054,12.11554,47.04057,14.7988,56.85048,23.26776,56.84979,35.25828,46.95511,43.89463,25.48979,43.55924,8.13326,52.2799,-15.34437,64.10242],\"s\":[{\"p\":[-54.96429,21.2553],\"r\":-0.27612,\"w\":2.7671,\"h\":1.67703},{\"p\":[-36.09254,12.36963],\"r\":0.14726,\"w\":3.43791,\"h\":1.84475},{\"p\":[-13.41625,14.2537],\"r\":0.11658,\"w\":4.69568,\"h\":1.42549},{\"p\":[44.00931,18.38166],\"r\":0.25771,\"w\":4.94713,\"h\":4.27642},{\"p\":[62.74669,29.41331],\"r\":0,\"w\":4.10855,\"h\":5.86952},{\"p\":[46.71119,38.74469],\"r\":1.14742,\"w\":4.52775,\"h\":6.70794},{\"p\":[-14.26275,63.60006],\"r\":2.67526,\"w\":10.14584,\"h\":12.24173},{\"p\":[19.7351,9.40621],\"r\":0.65041,\"w\":1.97177,\"h\":1.07553},{\"p\":[28.99679,9.71727],\"r\":0.20862,\"w\":1.97175,\"h\":1.03072},{\"p\":[24.15205,9.93872],\"r\":-0.31907,\"w\":1.25476,\"h\":0.9859}],\"d\":[],\"l\":259.088,\"c\":{\"s\":\"10\",\"sl\":\"10\",\"lp\":1},\"v\":1} },\n\n  { name: \"Dodging a speeder\", data: {\"p\":[-226.14066,275.34941,21.32194,-6.2654,266.99958,-174.39559,466.42449,-427.95124],\"s\":[],\"d\":[{\"p\":[\"-250\",\"-0.5\"],\"v\":[\"40\",\"0\"],\"l\":1,\"t\":0}],\"l\":996.572,\"c\":{\"s\":\"25\",\"sl\":\"25\",\"lp\":-1},\"v\":1} },\n\n  { name: \"Lane blockage with oncoming traffic\", data: {\"p\":[-84.96318,-14.94973,374.91044,-14.7168],\"s\":[{\"p\":[-34.91024,-12.51359],\"r\":0,\"w\":2.76711,\"h\":2.68324}],\"d\":[{\"p\":[\"40\",\"-0.5\"],\"v\":[\"-10\",\"0\"],\"l\":1,\"t\":0},{\"p\":[\"150\",\"-0.5\"],\"v\":[\"-10\",\"0\"],\"l\":1,\"t\":0}],\"l\":459.874,\"c\":{\"s\":\"20\",\"sl\":\"20\",\"lp\":1},\"v\":1} },\n\n  { name: \"Merging into slower traffic\", data: {\"p\":[-629.09464,16.31589,281.97162,14.81565],\"s\":[{\"p\":[-440.00152,11.62602],\"r\":0,\"w\":3.1379,\"h\":3.13801},{\"p\":[-259.74036,11.98013],\"r\":0,\"w\":2.51556,\"h\":4.4441},{\"p\":[93.71013,11.27032],\"r\":0,\"w\":4.07947,\"h\":7.84501},{\"p\":[-94.72208,11.28172],\"r\":0,\"w\":3.76609,\"h\":7.53122}],\"d\":[{\"p\":[\"320\",\"0.5\"],\"v\":[\"12\",\"0\"],\"l\":1,\"t\":0},{\"p\":[\"280\",\"0.5\"],\"v\":[\"12\",\"0\"],\"l\":1,\"t\":0},{\"p\":[\"240\",\"0.5\"],\"v\":[\"12\",\"0\"],\"l\":1,\"t\":0},{\"p\":[\"200\",\"0.5\"],\"v\":[\"12\",\"0\"],\"l\":1,\"t\":0},{\"p\":[\"160\",\"0.5\"],\"v\":[\"12\",\"0\"],\"l\":1,\"t\":0},{\"p\":[\"120\",\"0.5\"],\"v\":[\"12\",\"0\"],\"l\":1,\"t\":0},{\"p\":[\"80\",\"0.5\"],\"v\":[\"12\",\"0\"],\"l\":1,\"t\":0},{\"p\":[\"40\",\"0.5\"],\"v\":[\"12\",\"0\"],\"l\":1,\"t\":0},{\"p\":[\"0\",\"0.5\"],\"v\":[\"12\",\"0\"],\"l\":1,\"t\":0},{\"p\":[\"-40\",\"0.5\"],\"v\":[\"12\",\"0\"],\"l\":1,\"t\":0},{\"p\":[\"-80\",\"0.5\"],\"v\":[\"12\",\"0\"],\"l\":1,\"t\":0},{\"p\":[\"-120\",\"0.5\"],\"v\":[\"12\",\"0\"],\"l\":1,\"t\":0},{\"p\":[\"-160\",\"0.5\"],\"v\":[\"12\",\"0\"],\"l\":1,\"t\":0},{\"p\":[\"-200\",\"0.5\"],\"v\":[\"12\",\"0\"],\"l\":1,\"t\":0}],\"l\":911.067,\"c\":{\"s\":\"25\",\"sl\":\"25\",\"lp\":-1},\"v\":1} },\n\n  { name: \"Negotiating crosswalks\", data: {\"p\":[-144.73574,55.4495,-104.89441,31.62755,-33.87479,61.57811,54.60631,46.34858,152.3728,-41.4335,219.90258,-113.95225],\"s\":[],\"d\":[{\"p\":[\"51\",\"-2\"],\"v\":[\"0\",\"1.5\"],\"l\":1,\"t\":2},{\"p\":[\"52\",\"+2\"],\"v\":[\"0\",\"-1.6\"],\"l\":1,\"t\":2},{\"p\":[\"53\",\"-2\"],\"v\":[\"0\",\"1.5\"],\"l\":1,\"t\":2},{\"p\":[\"54\",\"+2\"],\"v\":[\"0\",\"-1.4\"],\"l\":1,\"t\":2},{\"p\":[\"55\",\"-2\"],\"v\":[\"0\",\"1.5\"],\"l\":1,\"t\":2},{\"p\":[\"50\",\"+3\"],\"v\":[\"0\",\"-1.5\"],\"l\":1,\"t\":2},{\"p\":[\"51\",\"-3\"],\"v\":[\"0\",\"1.7\"],\"l\":1,\"t\":2},{\"p\":[\"52\",\"+3\"],\"v\":[\"0\",\"-1.5\"],\"l\":1,\"t\":2},{\"p\":[\"53\",\"-3\"],\"v\":[\"0\",\"1.3\"],\"l\":1,\"t\":2},{\"p\":[\"50\",\"-4\"],\"v\":[\"0\",\"1.6\"],\"l\":1,\"t\":2},{\"p\":[\"51\",\"-4\"],\"v\":[\"0\",\"1.2\"],\"l\":1,\"t\":2},{\"p\":[\"52\",\"-5\"],\"v\":[\"0\",\"1.5\"],\"l\":1,\"t\":2},{\"p\":[\"53\",\"-5\"],\"v\":[\"0\",\"1.4\"],\"l\":1,\"t\":2},{\"p\":[\"50\",\"4.5\"],\"v\":[\"0\",\"-1.6\"],\"l\":1,\"t\":2},{\"p\":[\"51\",\"5\"],\"v\":[\"0\",\"-1.4\"],\"l\":1,\"t\":2},{\"p\":[\"52\",\"4\"],\"v\":[\"0\",\"-1.5\"],\"l\":1,\"t\":2},{\"p\":[\"53\",\"4.5\"],\"v\":[\"0\",\"-1.4\"],\"l\":1,\"t\":2},{\"p\":[\"49\",\"5.5\"],\"v\":[\"0\",\"-1.2\"],\"l\":1,\"t\":2},{\"p\":[\"50\",\"6\"],\"v\":[\"0\",\"-1.6\"],\"l\":1,\"t\":2},{\"p\":[\"51\",\"5.75\"],\"v\":[\"0\",\"-1.5\"],\"l\":1,\"t\":2},{\"p\":[\"52\",\"5\"],\"v\":[\"0\",\"-1.5\"],\"l\":1,\"t\":2},{\"p\":[\"49\",\"-6\"],\"v\":[\"0\",\"1.5\"],\"l\":1,\"t\":2},{\"p\":[\"50\",\"-5.5\"],\"v\":[\"0\",\"1.7\"],\"l\":1,\"t\":2},{\"p\":[\"51\",\"-5\"],\"v\":[\"0\",\"0.9\"],\"l\":1,\"t\":2},{\"p\":[\"52\",\"-5.75\"],\"v\":[\"0\",\"1.2\"],\"l\":1,\"t\":2},{\"p\":[\"150\",\"-75\"],\"v\":[\"0\",\"9\"],\"l\":0,\"t\":1},{\"p\":[\"152\",\"-80\"],\"v\":[\"0\",\"10\"],\"l\":0,\"t\":1},{\"p\":[\"154\",\"-85\"],\"v\":[\"0\",\"9.5\"],\"l\":0,\"t\":1},{\"p\":[\"150\",\"75\"],\"v\":[\"0\",\"-10\"],\"l\":0,\"t\":1},{\"p\":[\"152\",\"80\"],\"v\":[\"0\",\"-9\"],\"l\":0,\"t\":1},{\"p\":[\"154\",\"85\"],\"v\":[\"0\",\"-9.5\"],\"l\":0,\"t\":1}],\"l\":447.535,\"c\":{\"s\":\"5\",\"sl\":\"20\",\"lp\":1},\"v\":1} },\n\n  { name: \"Chasing the peloton\", data: {\"p\":[-708.1093,561.67222,-657.73649,701.46772,-531.30212,736.41613,-332.91517,708.663,-201.34176,611.01215,-80.04523,477.38232,22.75082,341.69385,147.66174,176.73622,253.02371,-15.01574,448.31828,-335.71836,495.60932,-544.40048],\"s\":[],\"d\":[{\"p\":[\"50\",\"0.4\"],\"v\":[\"15.5\",\"-0.1\"],\"l\":1,\"t\":1},{\"p\":[\"52\",\"0.6\"],\"v\":[\"15.7\",\"-0.15\"],\"l\":1,\"t\":1},{\"p\":[\"54\",\"0.3\"],\"v\":[\"15.3\",\"-0.13\"],\"l\":1,\"t\":1},{\"p\":[\"56\",\"0.7\"],\"v\":[\"15.2\",\"-0.1\"],\"l\":1,\"t\":1},{\"p\":[\"58\",\"0.3\"],\"v\":[\"15.8\",\"-0.12\"],\"l\":1,\"t\":1},{\"p\":[\"60\",\"0.7\"],\"v\":[\"15.6\",\"-0.17\"],\"l\":1,\"t\":1},{\"p\":[\"62\",\"0.1\"],\"v\":[\"15.4\",\"-0.14\"],\"l\":1,\"t\":1},{\"p\":[\"64\",\"-0.1\"],\"v\":[\"15.5\",\"0.13\"],\"l\":1,\"t\":1},{\"p\":[\"66\",\"0.3\"],\"v\":[\"15.3\",\"-0.13\"],\"l\":1,\"t\":1},{\"p\":[\"68\",\"0\"],\"v\":[\"15.6\",\"0.15\"],\"l\":1,\"t\":1},{\"p\":[\"70\",\"-0.3\"],\"v\":[\"15.8\",\"0.17\"],\"l\":1,\"t\":1},{\"p\":[\"72\",\"-0.7\"],\"v\":[\"15.7\",\"0.12\"],\"l\":1,\"t\":1},{\"p\":[\"74\",\"-0.5\"],\"v\":[\"15.1\",\"0.15\"],\"l\":1,\"t\":1},{\"p\":[\"76\",\"-0.7\"],\"v\":[\"15.9\",\"0.11\"],\"l\":1,\"t\":1},{\"p\":[\"78\",\"-0.3\"],\"v\":[\"15.5\",\"0.16\"],\"l\":1,\"t\":1},{\"p\":[\"80\",\"-0.5\"],\"v\":[\"15.6\",\"0.13\"],\"l\":1,\"t\":1}],\"l\":2018.213,\"c\":{\"s\":\"15\",\"sl\":\"25\",\"lp\":1},\"v\":1} }\n];\n","import { formatDate } from \"../Helpers.js\";\nimport EXAMPLES from \"./examples.js\";\n\nconst LOCAL_STORAGE_KEY = 'dash_Scenarios';\n\nexport default class ScenarioManager {\n  constructor(editor) {\n    this.editor = editor;\n    this.modal = document.getElementById('scenarios-modal');\n\n    document.getElementById('scenarios-modal-background').addEventListener('click', this._closeModal.bind(this));\n    document.getElementById('scenarios-modal-close').addEventListener('click', this._closeModal.bind(this));\n\n    this.examplesTab = document.getElementById('scenarios-modal-examples-tab');\n    this.savedTab = document.getElementById('scenarios-modal-saved-tab');\n    this.importTab = document.getElementById('scenarios-modal-import-tab');\n\n    this.examplesTabButton = document.getElementById('scenarios-modal-examples-tab-button');\n    this.savedTabButton = document.getElementById('scenarios-modal-saved-tab-button');\n    this.importTabButton = document.getElementById('scenarios-modal-import-tab-button');\n    this.examplesTabButton.addEventListener('click', e => this.switchTab(this.examplesTab));\n    this.savedTabButton.addEventListener('click', e => this.switchTab(this.savedTab));\n    this.importTabButton.addEventListener('click', e => this.switchTab(this.importTab));\n\n    this.itemsContainer = document.getElementById('scenarios-modal-items');\n\n    this.sortName = document.getElementById('scenarios-sort-name');\n    this.sortName.addEventListener('click', e => this._buildScenarioItems('name'));\n    this.sortSavedAt = document.getElementById('scenarios-sort-saved-at');\n    this.sortSavedAt.addEventListener('click', e => this._buildScenarioItems('savedAt'));\n\n    this.importBox = document.getElementById('scenario-import-box');\n    this.importInfo = document.getElementById('scenario-import-info');\n\n    this.importBox.addEventListener('input', this._importBoxChanged.bind(this));\n\n    for (let i = 0; i < EXAMPLES.length; i++)\n      document.getElementById(`example-${i}`).addEventListener('click', e => this._loadScenario(EXAMPLES[i]));\n  }\n\n  switchTab(tab) {\n    this.examplesTab.classList.add('is-hidden')\n    this.savedTab.classList.add('is-hidden')\n    this.importTab.classList.add('is-hidden')\n    this.examplesTabButton.classList.remove('is-active');\n    this.savedTabButton.classList.remove('is-active');\n    this.importTabButton.classList.remove('is-active');\n\n    let button = this.savedTabButton;\n    if (tab == this.examplesTab)\n      button = this.examplesTabButton;\n    else if (tab == this.importTab)\n      button = this.importTabButton;\n\n    tab.classList.remove('is-hidden');\n    button.classList.add('is-active');\n\n    if (tab == this.importTab)\n      this.importBox.focus();\n  }\n\n  saveScenario(name, data, force = false) {\n    const scenarios = this.fetchScenarios();\n    let scenario = scenarios[name];\n    const now = new Date();\n\n    if (scenario) {\n      if (!force) return [false, scenario.savedAt];\n\n      scenario.data = data;\n      scenario.savedAt = now;\n    } else {\n       scenario = {\n        name: name,\n        data: data,\n        savedAt: now\n      };\n      \n      scenarios[name] = scenario;\n    }\n\n    const json = JSON.stringify(scenarios);\n    window.localStorage.setItem(LOCAL_STORAGE_KEY, json);\n\n    return [true, scenario.savedAt];\n  }\n\n  fetchScenarios() {\n    const scenarios = JSON.parse(window.localStorage.getItem(LOCAL_STORAGE_KEY)) || {};\n\n    for (const k in scenarios)\n      scenarios[k].savedAt = new Date(scenarios[k].savedAt);\n\n    return scenarios;\n  }\n\n  showModal(onLoadScenario = null) {\n    this.onLoadScenario = onLoadScenario;\n\n    this.modal.classList.add('is-active');\n    this.switchTab(this.savedTab);\n\n    this._buildScenarioItems();\n    this.itemsContainer.scrollTop = 0;\n    \n    this.importBox.value = '';\n    this.importBox.dispatchEvent(new Event('input'));\n  }\n\n  _closeModal() {\n    this.onLoadScenario = null;\n    this.modal.classList.remove('is-active');\n  }\n\n  _buildScenarioItems(sort = 'savedAt') {\n    this.itemsContainer.innerHTML = '';\n\n    this.sortName.classList.remove('is-underlined');\n    this.sortSavedAt.classList.remove('is-underlined');\n    if (sort == 'name')\n      this.sortName.classList.add('is-underlined');\n    else if (sort == 'savedAt')\n      this.sortSavedAt.classList.add('is-underlined');\n\n    const scenarios = Object.values(this.fetchScenarios());\n\n    if (scenarios.length == 0) {\n      this._showEmptyMessage();\n    } else {\n      scenarios.sort((a, b) => {\n        if (sort == 'savedAt') {\n          if (a.savedAt < b.savedAt) return +1;\n          else if (b.savedAt < a.savedAt) return -1;\n        }\n\n        const nameA = a.name.toLowerCase();\n        const nameB = b.name.toLowerCase();\n\n        if (nameA < nameB) return -1;\n        if (nameB < nameA) return +1;\n        return 0;\n      });\n\n      scenarios.forEach(s => this._addScenarioItem(s));\n    }\n  }\n\n  _showEmptyMessage() {\n    this.itemsContainer.innerHTML = \"<i>You don't have any saved scenarios.</i>\";\n  }\n\n  _addScenarioItem(scenario) {\n    const html =\n      `<div class=\"columns\">\n          <div class=\"column is-7 scenario-item-name scenario-item-load\" title=\"\"></div>\n          <div class=\"column is-4 scenario-item-saved-at\"></div>\n          <div class=\"column is-1\">\n              <div class=\"field is-grouped is-pulled-right\">\n                  <p class=\"control\" style=\"margin-right: 8px;\">\n                      <span class=\"button is-small is-danger scenario-item-delete\" title=\"Delete\">\n                          <span class=\"icon is-small\">\n                              <i class=\"fas fa-lg fa-trash-alt\"></i>\n                          </span>\n                      </span>\n                  </p>\n              </div>\n          </div>\n      </div>`;\n\n    const template = document.createElement('template');\n    template.innerHTML = html;\n    const item = template.content.firstChild;\n\n    const nameDom = item.getElementsByClassName('scenario-item-name')[0];\n    nameDom.textContent = scenario.name;\n    nameDom.title = scenario.name;\n\n    item.getElementsByClassName('scenario-item-saved-at')[0].textContent = formatDate(scenario.savedAt);\n\n    item.getElementsByClassName('scenario-item-load')[0].addEventListener('click', e => this._loadScenario(scenario));\n\n    item.getElementsByClassName('scenario-item-delete')[0].addEventListener('click', e => {\n      if (window.confirm(`Are you sure you want to delete the scenario \"${scenario.name}\"?`)) {\n        this._deleteScenario(scenario);\n        this.itemsContainer.removeChild(item);\n\n        if (this.itemsContainer.children.length == 0)\n          this._showEmptyMessage();\n      }\n    });\n\n    this.itemsContainer.appendChild(item);\n  }\n\n  _loadScenario(scenario) {\n    this.editor.loadJSON(scenario.data);\n    this.editor.updateSavedInfo(scenario.name, formatDate(scenario.savedAt));\n\n    if (this.onLoadScenario) this.onLoadScenario();\n\n    this._closeModal();\n  }\n\n  _deleteScenario(scenario) {\n    const scenarios = this.fetchScenarios();\n    delete scenarios[scenario.name];\n\n    const json = JSON.stringify(scenarios);\n    window.localStorage.setItem(LOCAL_STORAGE_KEY, json);\n  }\n\n  _importBoxChanged() {\n    this.importBox.classList.remove('is-danger');\n    this.importInfo.classList.add('is-hidden');\n\n    const encoded = this.importBox.value;\n\n    if (encoded != '') {\n      try {\n        const json = JSON.parse(atob(this.importBox.value));\n\n        if (json.s === undefined || json.d === undefined || json.p === undefined || json.p.length % 2 != 0)\n          throw new Error();\n\n        this.importInfo.innerHTML = `\n          <div class=\"button is-small is-static has-text-grey-light is-paddingless\" style=\"background: transparent; border: none;\">\n              Road Length:&nbsp;<b>${json.l.toLocaleString(undefined, { minimumFractionDigits: 1, maximumFractionDigits: 1 })}</b>m\n          </div>\n          &nbsp;\n          <div class=\"button is-small is-static has-text-grey-light is-paddingless\" style=\"background: transparent; border: none;\">\n              Static Obstacles:&nbsp;<b>${json.s.length}</b>\n          </div>\n          &nbsp;\n          <div class=\"button is-small is-static has-text-grey-light is-paddingless\" style=\"background: transparent; border: none;\">\n              Dynamic Obstacles:&nbsp;<b>${json.d.length}</b>\n          </div>\n          <div class=\"button is-small is-success is-pulled-right scenario-import-button\">\n            <span class=\"icon\">\n              <i class=\"fas fa-check\"></i>\n            </span>\n            <span>Import</span>\n          </div>\n        `;\n\n        this.importInfo.getElementsByClassName('scenario-import-button')[0].addEventListener('click', e => this._loadScenario({ data: json }));\n        this.importInfo.classList.remove('is-hidden');\n      } catch (e) {\n        this.importBox.classList.add('is-danger');\n      }\n    }\n  }\n}\n","export default class ShareManager {\n  constructor() {\n    this.modal = document.getElementById('scenario-share-modal');\n    this.linkDom = document.getElementById('scenario-share-link');\n    this.boxDom = document.getElementById('scenario-share-box');\n    this.clipboardButton = document.getElementById('scenario-share-clipboard');\n    this.clipboardIcon = document.getElementById('scenario-share-clipboard-icon');\n    this.clipboardSuccessIcon = document.getElementById('scenario-share-clipboard-success-icon');\n\n    document.getElementById('scenario-share-modal-background').addEventListener('click', this._closeModal.bind(this));\n    document.getElementById('scenario-share-modal-close').addEventListener('click', this._closeModal.bind(this));\n    this.clipboardButton.addEventListener('click', this._copyLinkToClipboard.bind(this));\n\n    this.linkDom.addEventListener('focus', e => this.linkDom.select());\n    this.boxDom.addEventListener('focus', e => this.boxDom.select());\n  }\n\n  showModal(scenario) {\n    this.modal.classList.add('is-active');\n\n    this.clipboardIcon.classList.remove('is-hidden');\n    this.clipboardSuccessIcon.classList.add('is-hidden');\n    this.clipboardButton.classList.remove('is-success');\n\n    const code = btoa(JSON.stringify(scenario));\n\n    const url = new URL(window.location);\n    url.search = '';\n    url.hash = '/s/' + encodeURIComponent(code);\n\n    this.linkDom.value = url.href;\n    this.boxDom.value = code;\n  }\n\n  _closeModal() {\n    this.modal.classList.remove('is-active');\n  }\n\n  _copyLinkToClipboard() {\n    this.linkDom.focus();\n    this.linkDom.select();\n\n    if (document.execCommand('copy', false, null)) {\n      this.clipboardIcon.classList.add('is-hidden');\n      this.clipboardSuccessIcon.classList.remove('is-hidden');\n      this.clipboardButton.classList.add('is-success');\n    }\n  }\n}\n","import LanePath from \"../autonomy/LanePath.js\";\nimport StaticObstacle from \"../autonomy/StaticObstacle.js\";\nimport DynamicObstacleEditor from \"./DynamicObstacleEditor.js\";\nimport ScenarioManager from \"./ScenarioManager.js\";\nimport ShareManager from \"./ShareManager.js\";\nimport { formatDate } from \"../Helpers.js\";\n\nconst GROUND_PLANE = new THREE.Plane(new THREE.Vector3(0, 1, 0));\n\nconst NORMAL_OPACITY = 0.7;\nconst HOVER_OPACITY = 1;\nconst NORMAL_POINT_COLOR = 0x0088ff;\nconst HOVER_POINT_COLOR = 0x33ccff;\nconst NORMAL_STATIC_OBSTACLE_COLOR = 0xdd0000;\nconst HOVER_STATIC_OBSTACLE_COLOR = 0xdd3333;\nconst NORMAL_DYNAMIC_OBSTACLE_COLOR = 0xff8800;\nconst HOVER_DYNAMIC_OBSTACLE_COLOR = 0xffcc33;\n\nconst INITIAL_SPEED_FALLBACK = 20;\nconst SPEED_LIMIT_FALLBACK = 20;\nconst LANE_PREFERENCE_FALLBACK = +1;\n\nexport default class Editor {\n  constructor(canvas, camera, scene) {\n    this.canvas = canvas;\n    this.camera = camera;\n\n    this.isEnabled = false;\n    this.raycaster = new THREE.Raycaster();\n    this.mouse = new THREE.Vector2();\n    this.dragOffset = new THREE.Vector3();\n    this.draggingPoint = null;\n    this.pointIndex = 0;\n    this.obstacleIndex = 0;\n    this.previousSavedName = null;\n    this.scenarioManager = new ScenarioManager(this);\n    this.shareManager = new ShareManager();\n\n    this.centerlineGeometry = new THREE.Geometry();\n    this.leftBoundaryGeometry = new THREE.Geometry();\n    this.rightBoundaryGeometry = new THREE.Geometry();\n    this.draggingObstaclePreview = null;\n\n    this.group = new THREE.Group();\n    this.group.renderOrder = 1;\n    this.pointGroup = new THREE.Group();\n    this.pointGroup.renderOrder = 2;\n    this.obstacleGroup = new THREE.Group();\n    this.obstacleGroup.renderOrder = 1;\n    this.group.add(this.obstacleGroup);\n    this.group.add(this.pointGroup);\n    scene.add(this.group);\n\n    this.lanePath = new LanePath();\n    this.dynamicObstacleEditor = new DynamicObstacleEditor();\n\n    this.editorPathButton = document.getElementById('editor-path');\n    this.editorPathButton.addEventListener('click', e => this.changeEditMode('path'));\n    this.editorObstaclesButton = document.getElementById('editor-obstacles');\n    this.editorObstaclesButton.addEventListener('click', e => this.changeEditMode('staticObstacles'));\n    this.editorDynamicObstaclesButton = document.getElementById('editor-dynamic-obstacles');\n    this.editorDynamicObstaclesButton.addEventListener('click', e => this.changeEditMode('dynamicObstacles'));\n\n    this.editorRoadBox = document.getElementById('editor-road-box');\n    this.initialSpeedDom = document.getElementById('editor-initial-speed');\n    this.speedLimitDom = document.getElementById('editor-speed-limit');\n    this.laneLeftDom = document.getElementById('editor-lane-left');\n    this.laneRightDom = document.getElementById('editor-lane-right');\n\n    this.laneLeftDom.addEventListener('click', e => this._changeLanePreference(-1));\n    this.laneRightDom.addEventListener('click', e => this._changeLanePreference(+1));\n\n    this.initialSpeedDom.value = INITIAL_SPEED_FALLBACK;\n    this.speedLimitDom.value = SPEED_LIMIT_FALLBACK;\n    this._changeLanePreference(LANE_PREFERENCE_FALLBACK);\n\n    this.statsRoadLength = document.getElementById('editor-stats-road-length');\n    this.statsStaticObstacles = document.getElementById('editor-stats-static-obstacles');\n    this.statsStation = document.getElementById('editor-stats-station');\n    this.statsLatitude = document.getElementById('editor-stats-latitude');\n    this.scenarioNameDom = document.getElementById('editor-scenario-name');\n    this.scenarioSavedAtDom = document.getElementById('editor-scenario-saved-at');\n\n    this.helpPath = document.getElementById('editor-help-path');\n    this.helpStaticObstacles = document.getElementById('editor-help-static-obstacles');\n    this.helpDynamicObstacles = document.getElementById('editor-help-dynamic-obstacles');\n\n    this.changeEditMode('path');\n    this.removeMode = false;\n\n    canvas.addEventListener('mousedown', this.mouseDown.bind(this));\n    canvas.addEventListener('mousemove', this.mouseMove.bind(this));\n    canvas.addEventListener('mouseup', this.mouseUp.bind(this));\n    canvas.addEventListener('contextmenu', e => this.isEnabled && e.preventDefault());\n\n    const editorClearOptions = document.getElementById('editor-clear-options');\n    document.getElementById('editor-clear').addEventListener('click', event => {\n      event.stopPropagation();\n      editorClearOptions.classList.toggle('is-hidden');\n    });\n    document.addEventListener('click', () => editorClearOptions.classList.add('is-hidden'));\n\n    document.getElementById('editor-clear-obstacles').addEventListener('click', this.clearStaticObstacles.bind(this));\n    document.getElementById('editor-clear-dynamic-obstacles').addEventListener('click', this.dynamicObstacleEditor.clearDynamicObstacles.bind(this.dynamicObstacleEditor));\n    document.getElementById('editor-clear-path').addEventListener('click', this.clearPath.bind(this));\n    document.getElementById('editor-clear-all').addEventListener('click', this.clearAll.bind(this));\n\n    document.getElementById('editor-save').addEventListener('click', this.saveClicked.bind(this));\n    document.getElementById('editor-load').addEventListener('click', this.loadClicked.bind(this));\n    document.getElementById('editor-share').addEventListener('click', this.shareClicked.bind(this));\n\n    document.addEventListener('keydown', this.keyDown.bind(this));\n    document.addEventListener('keyup', this.keyUp.bind(this));\n\n    const resolution = new THREE.Vector2(this.canvas.clientWidth, this.canvas.clientHeight);\n    this.centerlineObject = new THREE.Mesh(\n      new THREE.Geometry(),\n      new MeshLineMaterial({\n        color: new THREE.Color(0x004488),\n        lineWidth: 8,\n        resolution: resolution,\n        sizeAttenuation: false,\n        near: camera.near,\n        far: camera.far,\n        depthWrite: false\n      })\n    );\n    this.centerlineObject.rotation.x = Math.PI / 2;\n    this.centerlineObject.renderOrder = 1;\n    this.group.add(this.centerlineObject);\n\n    this.leftBoundaryObject = new THREE.Mesh(\n      new THREE.Geometry(),\n      new MeshLineMaterial({\n        color: new THREE.Color(0xff40ff),\n        lineWidth: 0.15,\n        resolution: resolution,\n        transparent: true,\n        opacity: 0.7\n      })\n    );\n    this.leftBoundaryObject.rotation.x = Math.PI / 2;\n    this.leftBoundaryObject.renderOrder = 1;\n    this.group.add(this.leftBoundaryObject);\n\n    this.rightBoundaryObject = new THREE.Mesh(\n      new THREE.Geometry(),\n      new MeshLineMaterial({\n        color: new THREE.Color(0xff40ff),\n        lineWidth: 0.15,\n        resolution: resolution,\n        transparent: true,\n        opacity: 0.7\n      })\n    );\n    this.rightBoundaryObject.rotation.x = Math.PI / 2;\n    this.rightBoundaryObject.renderOrder = 1;\n    this.group.add(this.rightBoundaryObject);\n\n    window.addEventListener('resize', () => {\n      // Use setTimeout to queue the resolution update after the canvas is reflowed.\n      // This gets around some weirdness noticed when opening and closing Chrome Developer Tools.\n      setTimeout(() => {\n        const resolution = new THREE.Vector2(this.canvas.clientWidth, this.canvas.clientHeight);\n        this.centerlineObject.material.uniforms.resolution.value = resolution;\n        this.leftBoundaryObject.material.uniforms.resolution.value = resolution;\n        this.rightBoundaryObject.material.uniforms.resolution.value = resolution;\n      }, 0);\n    });\n  }\n\n  get enabled() {\n    return this.isEnabled;\n  }\n\n  set enabled(e) {\n    this.isEnabled = e;\n    this.pointGroup.visible = this.obstacleGroup.visible = !!this.isEnabled\n  }\n\n  get staticObstacles() {\n    return this.obstacleGroup.children.map(o => new StaticObstacle(new THREE.Vector2(o.position.x, o.position.z), -o.rotation.z, o.userData.width, o.userData.height));\n  }\n\n  get dynamicObstacles() {\n    return this.dynamicObstacleEditor.collectDynamicObstacles();\n  }\n\n  get initialSpeed() {\n    let speed = parseFloat(this.initialSpeedDom.value);\n    if (Number.isNaN(speed) || speed < 0)\n      speed = 0;\n\n    return Number.isNaN(speed) || speed < 0 ? INITIAL_SPEED_FALLBACK : speed;\n  }\n\n  get speedLimit() {\n    let limit = parseFloat(this.speedLimitDom.value);\n    if (Number.isNaN(limit) || limit < 0)\n      limit = 0;\n\n    return Number.isNaN(limit) || limit < 0 ? SPEED_LIMIT_FALLBACK : limit;\n  }\n\n  scenarioToJSON() {\n    const trunc = n => +n.toFixed(5);\n\n    const json = {\n      p: Array.prototype.concat.apply([], this.lanePath.anchors.map(a => [trunc(a.x), trunc(a.y)])),\n      s: this.staticObstacles.map(o => o.toJSON()),\n      d: this.dynamicObstacleEditor.toJSON(),\n      l: Number(this.lanePath.arcLength.toFixed(3)),\n      c: {\n        s: this.initialSpeedDom.value,\n        sl: this.speedLimitDom.value,\n        lp: this.lanePreference\n      },\n      v: 1\n    };\n\n    return json;\n  }\n\n  loadJSON(json) {\n    if (json.p === undefined || json.p.length % 2 != 0) {\n      throw new Error('Incomplete lane path.');\n    }\n\n    this.clearAll();\n\n    this.lanePath = new LanePath();\n    for (let i = 0; i < json.p.length; i += 2) {\n      this.addPoint(new THREE.Vector2(json.p[i], json.p[i + 1]), false);\n    }\n    this.lanePath.resampleAll();\n    this.rebuildPathGeometry();\n\n    json.s.forEach(o => {\n      const staticObstacle = StaticObstacle.fromJSON(o);\n      this.addStaticObstacle(new THREE.Vector3(staticObstacle.pos.x, 0, staticObstacle.pos.y), staticObstacle.width, staticObstacle.height, staticObstacle.rot)\n    });\n\n    this.dynamicObstacleEditor.loadJSON(json.d);\n\n    let initialSpeed = INITIAL_SPEED_FALLBACK;\n    let speedLimit = SPEED_LIMIT_FALLBACK;\n    try { initialSpeed = json.c.s; } catch (e) { }\n    try { speedLimit = json.c.sl; } catch (e) { }\n\n    this.initialSpeedDom.value = initialSpeed;\n    this.speedLimitDom.value = speedLimit;\n\n    let lanePreference = LANE_PREFERENCE_FALLBACK;\n    try {\n      if (typeof(json.c.lp) === 'number')\n        lanePreference = Math.sign(json.c.lp) || LANE_PREFERENCE_FALLBACK;\n    } catch (e) { }\n\n    this._changeLanePreference(lanePreference);\n  }\n\n  update() {\n    if (!this.isEnabled) return;\n\n    this.raycaster.setFromCamera(this.mouse, this.camera);\n    const intersection = this.raycaster.ray.intersectPlane(GROUND_PLANE);\n\n    const [station, latitude, _around] = this.lanePath.stationLatitudeFromPosition(new THREE.Vector2(intersection.x, intersection.z));\n    this.statsStation.textContent = (station || 0).toFixed(1);\n    this.statsLatitude.textContent = (latitude || 0).toFixed(1);\n\n    if (this.draggingPoint) {\n      if (intersection != null) {\n        this.updatePoint(this.draggingPoint, intersection.clone().add(this.dragOffset));\n        this.rebuildPathGeometry();\n      }\n    } else if (this.draggingObstacle) {\n      if (intersection !== null) {\n        if (this.draggingObstacle === true) {\n          if (this.draggingObstaclePreview) this.group.remove(this.draggingObstaclePreview);\n\n          const [center, width, height] = this._dimensionsFromRect(this.dragOffset, intersection);\n\n          this.draggingObstaclePreview = new THREE.Mesh(\n            new THREE.PlaneGeometry(width, height),\n            new THREE.MeshBasicMaterial({ color: NORMAL_STATIC_OBSTACLE_COLOR, depthTest: false, transparent: true, opacity: 0.4 })\n          );\n          this.draggingObstaclePreview.rotation.x = -Math.PI / 2;\n          this.draggingObstaclePreview.position.copy(center);\n          this.group.add(this.draggingObstaclePreview);\n        } else {\n          this.draggingObstacle.position.copy(intersection.clone().add(this.dragOffset));\n        }\n      }\n    } else if (this.rotatingObstacle) {\n      const rotation = (this.dragOffset.x - this.mouse.x) * 2 *  Math.PI;\n      this.rotatingObstacle.rotation.z = Math.wrapAngle(rotation + this.initialObstacleRotation);\n    } else {\n      this.pointGroup.children.forEach(p => {\n        p.material.color.set(NORMAL_POINT_COLOR)\n        p.material.opacity = NORMAL_OPACITY;\n      });\n\n      this.obstacleGroup.children.forEach(o => {\n        o.material.color.set(NORMAL_STATIC_OBSTACLE_COLOR)\n        o.material.opacity = NORMAL_OPACITY;\n      });\n\n      this.canvas.classList.remove('editor-grab', 'editor-grabbing', 'editor-removing');\n\n      if (this.editMode == 'path' && this.pointGroup.children.length > 0) {\n        let picked = null;\n        this.raycaster.intersectObjects(this.pointGroup.children).forEach(p => {\n          if (picked === null || p.object.userData.index > picked.object.userData.index) picked = p;\n        });\n\n        if (picked) {\n          picked.object.material.color.set(HOVER_POINT_COLOR);\n          picked.object.material.opacity = HOVER_OPACITY;\n\n          if (this.removeMode)\n            this.canvas.classList.add('editor-removing');\n          else\n            this.canvas.classList.add('editor-grab');\n        }\n      } else if (this.editMode == 'staticObstacles' && this.obstacleGroup.children.length > 0) {\n        let picked = null;\n        this.raycaster.intersectObjects(this.obstacleGroup.children).forEach(o => {\n          if (picked === null || o.object.userData.index > picked.object.userData.index) picked = o;\n        });\n\n        if (picked) {\n          picked.object.material.color.set(HOVER_STATIC_OBSTACLE_COLOR);\n          picked.object.material.opacity = HOVER_OPACITY;\n\n          if (this.removeMode)\n            this.canvas.classList.add('editor-removing');\n          else\n            this.canvas.classList.add('editor-grab');\n        }\n      }\n    }\n  }\n\n  changeEditMode(mode) {\n    this.editorPathButton.classList.add('is-outlined');\n    this.editorObstaclesButton.classList.add('is-outlined');\n    this.editorDynamicObstaclesButton.classList.add('is-outlined');\n    this.editorPathButton.classList.remove('is-selected');\n    this.editorObstaclesButton.classList.remove('is-selected');\n    this.editorDynamicObstaclesButton.classList.remove('is-selected');\n    this.editorRoadBox.classList.add('is-hidden');\n    this.helpPath.classList.add('is-hidden');\n    this.helpStaticObstacles.classList.add('is-hidden');\n    this.helpDynamicObstacles.classList.add('is-hidden');\n\n    if (mode == 'path') {\n      this.editMode = 'path';\n      this.editorPathButton.classList.remove('is-outlined');\n      this.editorPathButton.classList.add('is-selected');\n      this.editorRoadBox.classList.remove('is-hidden');\n      this.helpPath.classList.remove('is-hidden');\n      this.dynamicObstacleEditor.disable();\n    } else if (mode == 'staticObstacles') {\n      this.editMode = 'staticObstacles';\n      this.editorObstaclesButton.classList.remove('is-outlined');\n      this.editorObstaclesButton.classList.add('is-selected');\n      this.helpStaticObstacles.classList.remove('is-hidden');\n      this.dynamicObstacleEditor.disable();\n    } else {\n      this.editMode = 'dynamicObstacles';\n      this.editorDynamicObstaclesButton.classList.remove('is-outlined');\n      this.editorDynamicObstaclesButton.classList.add('is-selected');\n      this.helpDynamicObstacles.classList.remove('is-hidden');\n      this.dynamicObstacleEditor.enable();\n    }\n  }\n\n  addStaticObstacle(center, width, height, rotation = 0) {\n    const obstacle = new THREE.Mesh(\n      new THREE.PlaneGeometry(width, height),\n      new THREE.MeshBasicMaterial({ color: NORMAL_STATIC_OBSTACLE_COLOR, depthTest: false, transparent: true, opacity: NORMAL_OPACITY })\n    );\n    obstacle.rotation.x = -Math.PI / 2;\n    obstacle.rotation.z = -Math.wrapAngle(rotation);\n    obstacle.position.copy(center);\n    obstacle.userData = { index: this.obstacleIndex++, width: width, height: height };\n\n    this.obstacleGroup.add(obstacle);\n    this.statsStaticObstacles.textContent = this.obstacleGroup.children.length;\n  }\n\n  removeStaticObstacle(obstacle) {\n    this.obstacleGroup.remove(obstacle);\n    this.statsStaticObstacles.textContent = this.obstacleGroup.children.length;\n  }\n\n  clearStaticObstacles() {\n    this.group.remove(this.obstacleGroup);\n    this.obstacleGroup = new THREE.Group();\n    this.obstacleGroup.renderOrder = 1;\n    this.group.add(this.obstacleGroup);\n    this.obstacleIndex = 0;\n    this.statsStaticObstacles.textContent = 0;\n  }\n\n  clearAll() {\n    this.clearPath();\n    this.clearStaticObstacles();\n    this.dynamicObstacleEditor.clearDynamicObstacles();\n  }\n\n  rebuildPathGeometry() {\n    if (this.lanePath.anchors.length > 1) {\n      this.centerlineGeometry.setFromPoints(this.lanePath.centerline);\n      const centerline = new MeshLine();\n      centerline.setGeometry(this.centerlineGeometry);\n      this.centerlineObject.geometry = centerline.geometry;\n\n      this.leftBoundaryGeometry.setFromPoints(this.lanePath.leftBoundary);\n      const leftBoundary = new MeshLine();\n      leftBoundary.setGeometry(this.leftBoundaryGeometry);\n      this.leftBoundaryObject.geometry = leftBoundary.geometry;\n\n      this.rightBoundaryGeometry.setFromPoints(this.lanePath.rightBoundary);\n      const rightBoundary = new MeshLine();\n      rightBoundary.setGeometry(this.rightBoundaryGeometry);\n      this.rightBoundaryObject.geometry = rightBoundary.geometry;\n    } else {\n      this.centerlineObject.geometry.dispose();\n      this.centerlineObject.geometry = new THREE.Geometry();\n\n      this.leftBoundaryObject.geometry.dispose();\n      this.leftBoundaryObject.geometry = new THREE.Geometry();\n\n      this.rightBoundaryObject.geometry.dispose();\n      this.rightBoundaryObject.geometry = new THREE.Geometry();\n    }\n\n    this.statsRoadLength.textContent = this.lanePath.arcLength.toLocaleString(undefined, { minimumFractionDigits: 1, maximumFractionDigits: 1 });\n  }\n\n  addPoint(pos, resample = true) {\n    const point = new THREE.Mesh(\n      new THREE.CircleGeometry(1, 32),\n      new THREE.MeshBasicMaterial({\n        color: NORMAL_POINT_COLOR,\n        depthTest: false,\n        transparent: true,\n        opacity: NORMAL_OPACITY\n      })\n    );\n    point.rotation.x = -Math.PI / 2;\n    point.position.set(pos.x, 0, pos.y);\n    point.userData = { index: this.pointIndex++ };\n\n    this.lanePath.addAnchor(pos, resample);\n    this.pointGroup.add(point);\n\n    return point;\n  }\n\n  updatePoint(object, pos) {\n    object.position.copy(pos);\n    this.lanePath.updateAnchor(object.userData.index, new THREE.Vector2(pos.x, pos.z));\n  }\n\n  removePoint(object) {\n    const index = object.userData.index;\n\n    this.pointGroup.remove(object);\n    this.pointGroup.children.forEach(p => {\n      if (p.userData.index > index) p.userData.index--;\n    });\n    this.pointIndex--;\n\n    this.lanePath.removeAnchor(index);\n  }\n\n  clearPath() {\n    this.group.remove(this.pointGroup);\n    this.pointGroup = new THREE.Group();\n    this.pointGroup.renderOrder = 2;\n    this.group.add(this.pointGroup);\n    this.pointIndex = 0;\n\n    this.lanePath = new LanePath();\n    this.rebuildPathGeometry();\n\n    this.initialSpeedDom.value = INITIAL_SPEED_FALLBACK;\n    this.speedLimitDom.value = SPEED_LIMIT_FALLBACK;\n  }\n\n  keyDown(event) {\n    if (event.repeat || this.editMode != 'path' && this.editMode != 'staticObstacles') return;\n\n    if (event.key == 'Shift') {\n      this.removeMode = true;\n      this.canvas.classList.add('editor-pointing');\n      event.preventDefault();\n    } else if (event.key == 'Control' && this.editMode == 'staticObstacles') {\n      this.rotateMode = true;\n      this.canvas.classList.add('editor-pointing');\n      event.preventDefault();\n    }\n  }\n\n  keyUp(event) {\n    if (event.key == 'Shift') {\n      this.removeMode = false;\n      this.canvas.classList.remove('editor-pointing', 'editor-removing');\n    } else if (event.key == 'Control') {\n      this.rotateMode = false;\n      this.canvas.classList.remove('editor-pointing', 'editor-grabbing');\n    }\n  }\n\n  mouseDown(event) {\n    if (!this.isEnabled || event.button != 0) return;\n\n    this.mouse.x = (event.offsetX / this.canvas.clientWidth) * 2 - 1;\n    this.mouse.y = -(event.offsetY / this.canvas.clientHeight) * 2 + 1;\n\n    this.raycaster.setFromCamera(this.mouse, this.camera);\n\n    if (this.editMode == 'path') {\n      let picked = null;\n      this.raycaster.intersectObjects(this.pointGroup.children).forEach(p => {\n        if (picked === null || p.object.userData.index > picked.object.userData.index) picked = p;\n      });\n\n      if (picked) {\n        if (this.removeMode) {\n          this.removePoint(picked.object);\n          this.rebuildPathGeometry();\n        } else {\n          this.canvas.classList.remove('editor-grab');\n          this.canvas.classList.add('editor-grabbing');\n\n          this.draggingPoint = picked.object;\n          this.dragOffset.copy(picked.object.position).sub(picked.point);\n        }\n      } else if (!this.removeMode) {\n        const intersection = this.raycaster.ray.intersectPlane(GROUND_PLANE);\n        if (intersection != null) {\n          this.addPoint(new THREE.Vector2(intersection.x, intersection.z));\n          this.rebuildPathGeometry();\n        }\n      }\n    } else if (this.editMode == 'staticObstacles') {\n      let picked = null;\n      this.raycaster.intersectObjects(this.obstacleGroup.children).forEach(o => {\n        if (picked === null || o.object.userData.index > picked.object.userData.index) picked = o;\n      });\n\n      if (picked) {\n        if (this.removeMode) {\n          this.removeStaticObstacle(picked.object);\n        } else {\n          this.canvas.classList.remove('editor-grab');\n          this.canvas.classList.add('editor-grabbing');\n\n          if (this.rotateMode) {\n            this.rotatingObstacle = picked.object;\n            this.initialObstacleRotation = picked.object.rotation.z;\n            this.dragOffset.set(this.mouse.x, this.mouse.y, 0);\n          } else {\n            this.draggingObstacle = picked.object;\n            this.dragOffset.copy(picked.object.position).sub(picked.point);\n          }\n        }\n      } else if (!this.removeMode && !this.rotateMode) {\n        const intersection = this.raycaster.ray.intersectPlane(GROUND_PLANE);\n        if (intersection != null) {\n          this.draggingObstacle = true;\n          this.dragOffset.copy(intersection);\n        }\n      }\n    }\n  }\n\n  mouseMove(event) {\n    this.mouse.x = (event.offsetX / this.canvas.clientWidth) * 2 - 1;\n    this.mouse.y = -(event.offsetY / this.canvas.clientHeight) * 2 + 1;\n  }\n\n  mouseUp(event) {\n    if (!this.isEnabled || event.button != 0) return;\n\n    if (this.draggingObstacle === true) {\n      this.group.remove(this.draggingObstaclePreview);\n      this.draggingObstaclePreview = null;\n\n      this.mouse.x = (event.offsetX / this.canvas.clientWidth) * 2 - 1;\n      this.mouse.y = -(event.offsetY / this.canvas.clientHeight) * 2 + 1;\n\n      this.raycaster.setFromCamera(this.mouse, this.camera);\n\n      const intersection = this.raycaster.ray.intersectPlane(GROUND_PLANE);\n      if (intersection != null) {\n        const [center, width, height] = this._dimensionsFromRect(this.dragOffset, intersection);\n        this.addStaticObstacle(center, width, height);\n      }\n    }\n\n    this.draggingPoint = null;\n    this.draggingObstacle = null;\n    this.rotatingObstacle = null;\n    this.canvas.classList.remove('editor-grab', 'editor-grabbing');\n  }\n\n  updateSavedInfo(name, savedAt) {\n    this.previousSavedName = name || null;\n\n    name = name || 'Untitled';\n    savedAt = savedAt || 'Unsaved';\n\n    this.scenarioNameDom.textContent = name;\n    this.scenarioNameDom.title = name;\n    this.scenarioSavedAtDom.textContent = savedAt;\n  }\n\n  _changeLanePreference(pref) {\n    this.lanePreference = pref;\n\n    if (pref > 0) {\n      this.laneLeftDom.classList.add('is-outlined');\n      this.laneLeftDom.classList.remove('is-selected');\n      this.laneRightDom.classList.remove('is-outlined');\n      this.laneRightDom.classList.add('is-selected');\n    } else {\n      this.laneRightDom.classList.add('is-outlined');\n      this.laneRightDom.classList.remove('is-selected');\n      this.laneLeftDom.classList.remove('is-outlined');\n      this.laneLeftDom.classList.add('is-selected');\n    }\n  }\n\n  saveClicked() {\n    const name = window.prompt('Name your scenario:', this.previousSavedName || '');\n    if (name === null) return;\n    if (name === '') {\n      window.alert('The scenario name cannot be blank.');\n      return;\n    }\n\n    let [success, savedAt] = this.scenarioManager.saveScenario(name, this.scenarioToJSON(), name === this.previousSavedName);\n    const formattedSavedAt = formatDate(savedAt);\n\n    if (success) {\n      this.updateSavedInfo(name, formattedSavedAt);\n    } else if (confirm(`A scenario named \"${name}\" already exists, last saved ${formattedSavedAt}. Do you want to overwrite it?`)) {\n      [success, savedAt] = this.scenarioManager.saveScenario(name, this.scenarioToJSON(), true);\n      this.updateSavedInfo(name, formatDate(savedAt));\n    }\n  }\n\n  loadClicked() {\n    this.scenarioManager.showModal();\n  }\n\n  shareClicked() {\n    this.shareManager.showModal(this.scenarioToJSON());\n  }\n\n  _dimensionsFromRect(from, to) {\n    const center = from.clone().add(to).divideScalar(2);\n    const width = Math.max(0.5, Math.abs(from.x - to.x));\n    const height = Math.max(0.5, Math.abs(from.z - to.z));\n    return [center, width, height];\n  }\n}\n","/**\n * @author qiao / https://github.com/qiao\n * @author mrdoob / http://mrdoob.com\n * @author alteredq / http://alteredqualia.com/\n * @author WestLangley / http://github.com/WestLangley\n * @author erich666 / http://erichaines.com\n */\n\n// This set of controls performs orbiting, dollying (zooming), and panning.\n// Unlike TrackballControls, it maintains the \"up\" direction object.up (+Y by default).\n//\n//    Orbit - left mouse / touch: one finger move\n//    Zoom - middle mouse, or mousewheel / touch: two finger spread or squish\n//    Pan - right mouse, or arrow keys / touch: three finger swipe\n\nconst OrbitControls = function ( object, domElement ) {\n\n\tthis.object = object;\n\n\tthis.domElement = ( domElement !== undefined ) ? domElement : document;\n\n\t// Set to false to disable this control\n\tthis.enabled = true;\n\n\t// \"target\" sets the location of focus, where the object orbits around\n\tthis.target = new THREE.Vector3();\n\n\t// How far you can dolly in and out ( PerspectiveCamera only )\n\tthis.minDistance = 0;\n\tthis.maxDistance = Infinity;\n\n\t// How far you can zoom in and out ( OrthographicCamera only )\n\tthis.minZoom = 0;\n\tthis.maxZoom = Infinity;\n\n\t// How far you can orbit vertically, upper and lower limits.\n\t// Range is 0 to Math.PI radians.\n\tthis.minPolarAngle = 0; // radians\n\tthis.maxPolarAngle = Math.PI; // radians\n\n\t// How far you can orbit horizontally, upper and lower limits.\n\t// If set, must be a sub-interval of the interval [ - Math.PI, Math.PI ].\n\tthis.minAzimuthAngle = - Infinity; // radians\n\tthis.maxAzimuthAngle = Infinity; // radians\n\n\t// Set to true to enable damping (inertia)\n\t// If damping is enabled, you must call controls.update() in your animation loop\n\tthis.enableDamping = false;\n\tthis.dampingFactor = 0.25;\n\n\t// This option actually enables dollying in and out; left as \"zoom\" for backwards compatibility.\n\t// Set to false to disable zooming\n\tthis.enableZoom = true;\n\tthis.zoomSpeed = 1.0;\n\n\t// Set to false to disable rotating\n\tthis.enableRotate = true;\n\tthis.rotateSpeed = 1.0;\n\n\t// Set to false to disable panning\n\tthis.enablePan = true;\n\tthis.keyPanSpeed = 7.0;\t// pixels moved per arrow key push\n\n\t// Set to true to automatically rotate around the target\n\t// If auto-rotate is enabled, you must call controls.update() in your animation loop\n\tthis.autoRotate = false;\n\tthis.autoRotateSpeed = 2.0; // 30 seconds per round when fps is 60\n\n\t// Set to false to disable use of the keys\n\tthis.enableKeys = true;\n\n\t// The four arrow keys\n\tthis.keys = { LEFT: 37, UP: 38, RIGHT: 39, BOTTOM: 40 };\n\n\t// Mouse buttons\n\tthis.mouseButtons = { ORBIT: THREE.MOUSE.LEFT, ZOOM: THREE.MOUSE.MIDDLE, PAN: THREE.MOUSE.RIGHT };\n\n\t// for reset\n\tthis.target0 = this.target.clone();\n\tthis.position0 = this.object.position.clone();\n\tthis.zoom0 = this.object.zoom;\n\n\t//\n\t// public methods\n\t//\n\n\tthis.getPolarAngle = function () {\n\n\t\treturn spherical.phi;\n\n\t};\n\n\tthis.getAzimuthalAngle = function () {\n\n\t\treturn spherical.theta;\n\n\t};\n\n\tthis.saveState = function () {\n\n\t\tscope.target0.copy( scope.target );\n\t\tscope.position0.copy( scope.object.position );\n\t\tscope.zoom0 = scope.object.zoom;\n\n\t};\n\n\tthis.reset = function () {\n\n\t\tscope.target.copy( scope.target0 );\n\t\tscope.object.position.copy( scope.position0 );\n\t\tscope.object.zoom = scope.zoom0;\n\n\t\tscope.object.updateProjectionMatrix();\n\t\tscope.dispatchEvent( changeEvent );\n\n\t\tscope.update();\n\n\t\tstate = STATE.NONE;\n\n\t};\n\n  this.rotateLeft = function(angle) {\n    rotateLeft(angle);\n  }\n\n\t// this method is exposed, but perhaps it would be better if we can make it private...\n\tthis.update = function () {\n\n\t\tvar offset = new THREE.Vector3();\n\n\t\t// so camera.up is the orbit axis\n\t\tvar quat = new THREE.Quaternion().setFromUnitVectors( object.up, new THREE.Vector3( 0, 1, 0 ) );\n\t\tvar quatInverse = quat.clone().inverse();\n\n\t\tvar lastPosition = new THREE.Vector3();\n\t\tvar lastQuaternion = new THREE.Quaternion();\n\n\t\treturn function update() {\n\n\t\t\tvar position = scope.object.position;\n\n\t\t\toffset.copy( position ).sub( scope.target );\n\n\t\t\t// rotate offset to \"y-axis-is-up\" space\n\t\t\toffset.applyQuaternion( quat );\n\n\t\t\t// angle from z-axis around y-axis\n\t\t\tspherical.setFromVector3( offset );\n\n\t\t\tif ( scope.autoRotate && state === STATE.NONE ) {\n\n\t\t\t\trotateLeft( getAutoRotationAngle() );\n\n\t\t\t}\n\n\t\t\tspherical.theta += sphericalDelta.theta;\n\t\t\tspherical.phi += sphericalDelta.phi;\n\n\t\t\t// restrict theta to be between desired limits\n\t\t\tspherical.theta = Math.max( scope.minAzimuthAngle, Math.min( scope.maxAzimuthAngle, spherical.theta ) );\n\n\t\t\t// restrict phi to be between desired limits\n\t\t\tspherical.phi = Math.max( scope.minPolarAngle, Math.min( scope.maxPolarAngle, spherical.phi ) );\n\n\t\t\tspherical.makeSafe();\n\n\n\t\t\tspherical.radius *= scale;\n\n\t\t\t// restrict radius to be between desired limits\n\t\t\tspherical.radius = Math.max( scope.minDistance, Math.min( scope.maxDistance, spherical.radius ) );\n\n\t\t\t// move target to panned location\n\t\t\tscope.target.add( panOffset );\n\n\t\t\toffset.setFromSpherical( spherical );\n\n\t\t\t// rotate offset back to \"camera-up-vector-is-up\" space\n\t\t\toffset.applyQuaternion( quatInverse );\n\n\t\t\tposition.copy( scope.target ).add( offset );\n\n\t\t\tscope.object.lookAt( scope.target );\n\n\t\t\tif ( scope.enableDamping === true ) {\n\n\t\t\t\tsphericalDelta.theta *= ( 1 - scope.dampingFactor );\n\t\t\t\tsphericalDelta.phi *= ( 1 - scope.dampingFactor );\n\n\t\t\t} else {\n\n\t\t\t\tsphericalDelta.set( 0, 0, 0 );\n\n\t\t\t}\n\n\t\t\tscale = 1;\n\t\t\tpanOffset.set( 0, 0, 0 );\n\n\t\t\t// update condition is:\n\t\t\t// min(camera displacement, camera rotation in radians)^2 > EPS\n\t\t\t// using small-angle approximation cos(x/2) = 1 - x^2 / 8\n\n\t\t\tif ( zoomChanged ||\n\t\t\t\tlastPosition.distanceToSquared( scope.object.position ) > EPS ||\n\t\t\t\t8 * ( 1 - lastQuaternion.dot( scope.object.quaternion ) ) > EPS ) {\n\n\t\t\t\tscope.dispatchEvent( changeEvent );\n\n\t\t\t\tlastPosition.copy( scope.object.position );\n\t\t\t\tlastQuaternion.copy( scope.object.quaternion );\n\t\t\t\tzoomChanged = false;\n\n\t\t\t\treturn true;\n\n\t\t\t}\n\n\t\t\treturn false;\n\n\t\t};\n\n\t}();\n\n\tthis.dispose = function () {\n\n\t\tscope.domElement.removeEventListener( 'contextmenu', onContextMenu, false );\n\t\tscope.domElement.removeEventListener( 'mousedown', onMouseDown, false );\n\t\tscope.domElement.removeEventListener( 'wheel', onMouseWheel, false );\n\n\t\tscope.domElement.removeEventListener( 'touchstart', onTouchStart, false );\n\t\tscope.domElement.removeEventListener( 'touchend', onTouchEnd, false );\n\t\tscope.domElement.removeEventListener( 'touchmove', onTouchMove, false );\n\n\t\tdocument.removeEventListener( 'mousemove', onMouseMove, false );\n\t\tdocument.removeEventListener( 'mouseup', onMouseUp, false );\n\n\t\twindow.removeEventListener( 'keydown', onKeyDown, false );\n\n\t\t//scope.dispatchEvent( { type: 'dispose' } ); // should this be added here?\n\n\t};\n\n\t//\n\t// internals\n\t//\n\n\tvar scope = this;\n\n\tvar changeEvent = { type: 'change' };\n\tvar startEvent = { type: 'start' };\n\tvar endEvent = { type: 'end' };\n\n\tvar STATE = { NONE: - 1, ROTATE: 0, DOLLY: 1, PAN: 2, TOUCH_ROTATE: 3, TOUCH_DOLLY: 4, TOUCH_PAN: 5 };\n\n\tvar state = STATE.NONE;\n\n\tvar EPS = 0.000001;\n\n\t// current position in spherical coordinates\n\tvar spherical = new THREE.Spherical();\n\tvar sphericalDelta = new THREE.Spherical();\n\n\tvar scale = 1;\n\tvar panOffset = new THREE.Vector3();\n\tvar zoomChanged = false;\n\n\tvar rotateStart = new THREE.Vector2();\n\tvar rotateEnd = new THREE.Vector2();\n\tvar rotateDelta = new THREE.Vector2();\n\n\tvar panStart = new THREE.Vector2();\n\tvar panEnd = new THREE.Vector2();\n\tvar panDelta = new THREE.Vector2();\n\n\tvar dollyStart = new THREE.Vector2();\n\tvar dollyEnd = new THREE.Vector2();\n\tvar dollyDelta = new THREE.Vector2();\n\n\tfunction getAutoRotationAngle() {\n\n\t\treturn 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;\n\n\t}\n\n\tfunction getZoomScale() {\n\n\t\treturn Math.pow( 0.95, scope.zoomSpeed );\n\n\t}\n\n\tfunction rotateLeft( angle ) {\n\n\t\tsphericalDelta.theta -= angle;\n\n\t}\n\n\tfunction rotateUp( angle ) {\n\n\t\tsphericalDelta.phi -= angle;\n\n\t}\n\n\tvar panLeft = function () {\n\n\t\tvar v = new THREE.Vector3();\n\n\t\treturn function panLeft( distance, objectMatrix ) {\n\n\t\t\tv.setFromMatrixColumn( objectMatrix, 0 ); // get X column of objectMatrix\n\t\t\tv.multiplyScalar( - distance );\n\n\t\t\tpanOffset.add( v );\n\n\t\t};\n\n\t}();\n\n\tvar panUp = function () {\n\n\t\tvar v = new THREE.Vector3();\n\n\t\treturn function panUp( distance, objectMatrix ) {\n\n\t\t\tv.setFromMatrixColumn( objectMatrix, 1 ); // get Y column of objectMatrix\n\t\t\tv.multiplyScalar( distance );\n\n\t\t\tpanOffset.add( v );\n\n\t\t};\n\n\t}();\n\n\t// deltaX and deltaY are in pixels; right and down are positive\n\tvar pan = function () {\n\n\t\tvar offset = new THREE.Vector3();\n\n\t\treturn function pan( deltaX, deltaY ) {\n\n\t\t\tvar element = scope.domElement === document ? scope.domElement.body : scope.domElement;\n\n\t\t\tif ( scope.object.isPerspectiveCamera ) {\n\n\t\t\t\t// perspective\n\t\t\t\tvar position = scope.object.position;\n\t\t\t\toffset.copy( position ).sub( scope.target );\n\t\t\t\tvar targetDistance = offset.length();\n\n\t\t\t\t// half of the fov is center to top of screen\n\t\t\t\ttargetDistance *= Math.tan( ( scope.object.fov / 2 ) * Math.PI / 180.0 );\n\n\t\t\t\t// we actually don't use screenWidth, since perspective camera is fixed to screen height\n\t\t\t\tpanLeft( 2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix );\n\t\t\t\tpanUp( 2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix );\n\n\t\t\t} else if ( scope.object.isOrthographicCamera ) {\n\n\t\t\t\t// orthographic\n\t\t\t\tpanLeft( deltaX * ( scope.object.right - scope.object.left ) / scope.object.zoom / element.clientWidth, scope.object.matrix );\n\t\t\t\tpanUp( deltaY * ( scope.object.top - scope.object.bottom ) / scope.object.zoom / element.clientHeight, scope.object.matrix );\n\n\t\t\t} else {\n\n\t\t\t\t// camera neither orthographic nor perspective\n\t\t\t\tconsole.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.' );\n\t\t\t\tscope.enablePan = false;\n\n\t\t\t}\n\n\t\t};\n\n\t}();\n\n\tfunction dollyIn( dollyScale ) {\n\n\t\tif ( scope.object.isPerspectiveCamera ) {\n\n\t\t\tscale /= dollyScale;\n\n\t\t} else if ( scope.object.isOrthographicCamera ) {\n\n\t\t\tscope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom * dollyScale ) );\n\t\t\tscope.object.updateProjectionMatrix();\n\t\t\tzoomChanged = true;\n\n\t\t} else {\n\n\t\t\tconsole.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' );\n\t\t\tscope.enableZoom = false;\n\n\t\t}\n\n\t}\n\n\tfunction dollyOut( dollyScale ) {\n\n\t\tif ( scope.object.isPerspectiveCamera ) {\n\n\t\t\tscale *= dollyScale;\n\n\t\t} else if ( scope.object.isOrthographicCamera ) {\n\n\t\t\tscope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom / dollyScale ) );\n\t\t\tscope.object.updateProjectionMatrix();\n\t\t\tzoomChanged = true;\n\n\t\t} else {\n\n\t\t\tconsole.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' );\n\t\t\tscope.enableZoom = false;\n\n\t\t}\n\n\t}\n\n\t//\n\t// event callbacks - update the object state\n\t//\n\n\tfunction handleMouseDownRotate( event ) {\n\n\t\t//console.log( 'handleMouseDownRotate' );\n\n\t\trotateStart.set( event.clientX, event.clientY );\n\n\t}\n\n\tfunction handleMouseDownDolly( event ) {\n\n\t\t//console.log( 'handleMouseDownDolly' );\n\n\t\tdollyStart.set( event.clientX, event.clientY );\n\n\t}\n\n\tfunction handleMouseDownPan( event ) {\n\n\t\t//console.log( 'handleMouseDownPan' );\n\n\t\tpanStart.set( event.clientX, event.clientY );\n\n\t}\n\n\tfunction handleMouseMoveRotate( event ) {\n\n\t\t//console.log( 'handleMouseMoveRotate' );\n\n\t\trotateEnd.set( event.clientX, event.clientY );\n\t\trotateDelta.subVectors( rotateEnd, rotateStart );\n\n\t\tvar element = scope.domElement === document ? scope.domElement.body : scope.domElement;\n\n\t\t// rotating across whole screen goes 360 degrees around\n\t\trotateLeft( 2 * Math.PI * rotateDelta.x / element.clientWidth * scope.rotateSpeed );\n\n\t\t// rotating up and down along whole screen attempts to go 360, but limited to 180\n\t\trotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight * scope.rotateSpeed );\n\n\t\trotateStart.copy( rotateEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleMouseMoveDolly( event ) {\n\n\t\t//console.log( 'handleMouseMoveDolly' );\n\n\t\tdollyEnd.set( event.clientX, event.clientY );\n\n\t\tdollyDelta.subVectors( dollyEnd, dollyStart );\n\n\t\tif ( dollyDelta.y > 0 ) {\n\n\t\t\tdollyIn( getZoomScale() );\n\n\t\t} else if ( dollyDelta.y < 0 ) {\n\n\t\t\tdollyOut( getZoomScale() );\n\n\t\t}\n\n\t\tdollyStart.copy( dollyEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleMouseMovePan( event ) {\n\n\t\t//console.log( 'handleMouseMovePan' );\n\n\t\tpanEnd.set( event.clientX, event.clientY );\n\n\t\tpanDelta.subVectors( panEnd, panStart );\n\n\t\tpan( panDelta.x, panDelta.y );\n\n\t\tpanStart.copy( panEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleMouseUp( event ) {\n\n\t\t// console.log( 'handleMouseUp' );\n\n\t}\n\n\tfunction handleMouseWheel( event ) {\n\n\t\t// console.log( 'handleMouseWheel' );\n\n\t\tif ( event.deltaY < 0 ) {\n\n\t\t\tdollyOut( getZoomScale() );\n\n\t\t} else if ( event.deltaY > 0 ) {\n\n\t\t\tdollyIn( getZoomScale() );\n\n\t\t}\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleKeyDown( event ) {\n\n\t\t//console.log( 'handleKeyDown' );\n\n\t\tswitch ( event.keyCode ) {\n\n\t\t\tcase scope.keys.UP:\n\t\t\t\tpan( 0, scope.keyPanSpeed );\n\t\t\t\tscope.update();\n\t\t\t\tbreak;\n\n\t\t\tcase scope.keys.BOTTOM:\n\t\t\t\tpan( 0, - scope.keyPanSpeed );\n\t\t\t\tscope.update();\n\t\t\t\tbreak;\n\n\t\t\tcase scope.keys.LEFT:\n\t\t\t\tpan( scope.keyPanSpeed, 0 );\n\t\t\t\tscope.update();\n\t\t\t\tbreak;\n\n\t\t\tcase scope.keys.RIGHT:\n\t\t\t\tpan( - scope.keyPanSpeed, 0 );\n\t\t\t\tscope.update();\n\t\t\t\tbreak;\n\n\t\t}\n\n\t}\n\n\tfunction handleTouchStartRotate( event ) {\n\n\t\t//console.log( 'handleTouchStartRotate' );\n\n\t\trotateStart.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );\n\n\t}\n\n\tfunction handleTouchStartDolly( event ) {\n\n\t\t//console.log( 'handleTouchStartDolly' );\n\n\t\tvar dx = event.touches[ 0 ].pageX - event.touches[ 1 ].pageX;\n\t\tvar dy = event.touches[ 0 ].pageY - event.touches[ 1 ].pageY;\n\n\t\tvar distance = Math.sqrt( dx * dx + dy * dy );\n\n\t\tdollyStart.set( 0, distance );\n\n\t}\n\n\tfunction handleTouchStartPan( event ) {\n\n\t\t//console.log( 'handleTouchStartPan' );\n\n\t\tpanStart.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );\n\n\t}\n\n\tfunction handleTouchMoveRotate( event ) {\n\n\t\t//console.log( 'handleTouchMoveRotate' );\n\n\t\trotateEnd.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );\n\t\trotateDelta.subVectors( rotateEnd, rotateStart );\n\n\t\tvar element = scope.domElement === document ? scope.domElement.body : scope.domElement;\n\n\t\t// rotating across whole screen goes 360 degrees around\n\t\trotateLeft( 2 * Math.PI * rotateDelta.x / element.clientWidth * scope.rotateSpeed );\n\n\t\t// rotating up and down along whole screen attempts to go 360, but limited to 180\n\t\trotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight * scope.rotateSpeed );\n\n\t\trotateStart.copy( rotateEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleTouchMoveDolly( event ) {\n\n\t\t//console.log( 'handleTouchMoveDolly' );\n\n\t\tvar dx = event.touches[ 0 ].pageX - event.touches[ 1 ].pageX;\n\t\tvar dy = event.touches[ 0 ].pageY - event.touches[ 1 ].pageY;\n\n\t\tvar distance = Math.sqrt( dx * dx + dy * dy );\n\n\t\tdollyEnd.set( 0, distance );\n\n\t\tdollyDelta.subVectors( dollyEnd, dollyStart );\n\n\t\tif ( dollyDelta.y > 0 ) {\n\n\t\t\tdollyOut( getZoomScale() );\n\n\t\t} else if ( dollyDelta.y < 0 ) {\n\n\t\t\tdollyIn( getZoomScale() );\n\n\t\t}\n\n\t\tdollyStart.copy( dollyEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleTouchMovePan( event ) {\n\n\t\t//console.log( 'handleTouchMovePan' );\n\n\t\tpanEnd.set( event.touches[ 0 ].pageX, event.touches[ 0 ].pageY );\n\n\t\tpanDelta.subVectors( panEnd, panStart );\n\n\t\tpan( panDelta.x, panDelta.y );\n\n\t\tpanStart.copy( panEnd );\n\n\t\tscope.update();\n\n\t}\n\n\tfunction handleTouchEnd( event ) {\n\n\t\t//console.log( 'handleTouchEnd' );\n\n\t}\n\n\t//\n\t// event handlers - FSM: listen for events and reset state\n\t//\n\n\tfunction onMouseDown( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\tevent.preventDefault();\n\n\t\tswitch ( event.button ) {\n\n\t\t\tcase scope.mouseButtons.ORBIT:\n\n\t\t\t\tif ( scope.enableRotate === false ) return;\n\n\t\t\t\thandleMouseDownRotate( event );\n\n\t\t\t\tstate = STATE.ROTATE;\n\n\t\t\t\tbreak;\n\n\t\t\tcase scope.mouseButtons.ZOOM:\n\n\t\t\t\tif ( scope.enableZoom === false ) return;\n\n\t\t\t\thandleMouseDownDolly( event );\n\n\t\t\t\tstate = STATE.DOLLY;\n\n\t\t\t\tbreak;\n\n\t\t\tcase scope.mouseButtons.PAN:\n\n\t\t\t\tif ( scope.enablePan === false ) return;\n\n\t\t\t\thandleMouseDownPan( event );\n\n\t\t\t\tstate = STATE.PAN;\n\n\t\t\t\tbreak;\n\n\t\t}\n\n\t\tif ( state !== STATE.NONE ) {\n\n\t\t\tdocument.addEventListener( 'mousemove', onMouseMove, false );\n\t\t\tdocument.addEventListener( 'mouseup', onMouseUp, false );\n\n\t\t\tscope.dispatchEvent( startEvent );\n\n\t\t}\n\n\t}\n\n\tfunction onMouseMove( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\tevent.preventDefault();\n\n\t\tswitch ( state ) {\n\n\t\t\tcase STATE.ROTATE:\n\n\t\t\t\tif ( scope.enableRotate === false ) return;\n\n\t\t\t\thandleMouseMoveRotate( event );\n\n\t\t\t\tbreak;\n\n\t\t\tcase STATE.DOLLY:\n\n\t\t\t\tif ( scope.enableZoom === false ) return;\n\n\t\t\t\thandleMouseMoveDolly( event );\n\n\t\t\t\tbreak;\n\n\t\t\tcase STATE.PAN:\n\n\t\t\t\tif ( scope.enablePan === false ) return;\n\n\t\t\t\thandleMouseMovePan( event );\n\n\t\t\t\tbreak;\n\n\t\t}\n\n\t}\n\n\tfunction onMouseUp( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\thandleMouseUp( event );\n\n\t\tdocument.removeEventListener( 'mousemove', onMouseMove, false );\n\t\tdocument.removeEventListener( 'mouseup', onMouseUp, false );\n\n\t\tscope.dispatchEvent( endEvent );\n\n\t\tstate = STATE.NONE;\n\n\t}\n\n\tfunction onMouseWheel( event ) {\n\n\t\tif ( scope.enabled === false || scope.enableZoom === false || ( state !== STATE.NONE && state !== STATE.ROTATE ) ) return;\n\n\t\tevent.preventDefault();\n\t\tevent.stopPropagation();\n\n\t\thandleMouseWheel( event );\n\n\t\tscope.dispatchEvent( startEvent ); // not sure why these are here...\n\t\tscope.dispatchEvent( endEvent );\n\n\t}\n\n\tfunction onKeyDown( event ) {\n\n\t\tif ( scope.enabled === false || scope.enableKeys === false || scope.enablePan === false ) return;\n\n\t\thandleKeyDown( event );\n\n\t}\n\n\tfunction onTouchStart( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\tswitch ( event.touches.length ) {\n\n\t\t\tcase 1:\t// one-fingered touch: rotate\n\n\t\t\t\tif ( scope.enableRotate === false ) return;\n\n\t\t\t\thandleTouchStartRotate( event );\n\n\t\t\t\tstate = STATE.TOUCH_ROTATE;\n\n\t\t\t\tbreak;\n\n\t\t\tcase 2:\t// two-fingered touch: dolly\n\n\t\t\t\tif ( scope.enableZoom === false ) return;\n\n\t\t\t\thandleTouchStartDolly( event );\n\n\t\t\t\tstate = STATE.TOUCH_DOLLY;\n\n\t\t\t\tbreak;\n\n\t\t\tcase 3: // three-fingered touch: pan\n\n\t\t\t\tif ( scope.enablePan === false ) return;\n\n\t\t\t\thandleTouchStartPan( event );\n\n\t\t\t\tstate = STATE.TOUCH_PAN;\n\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\n\t\t\t\tstate = STATE.NONE;\n\n\t\t}\n\n\t\tif ( state !== STATE.NONE ) {\n\n\t\t\tscope.dispatchEvent( startEvent );\n\n\t\t}\n\n\t}\n\n\tfunction onTouchMove( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\tevent.preventDefault();\n\t\tevent.stopPropagation();\n\n\t\tswitch ( event.touches.length ) {\n\n\t\t\tcase 1: // one-fingered touch: rotate\n\n\t\t\t\tif ( scope.enableRotate === false ) return;\n\t\t\t\tif ( state !== STATE.TOUCH_ROTATE ) return; // is this needed?...\n\n\t\t\t\thandleTouchMoveRotate( event );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 2: // two-fingered touch: dolly\n\n\t\t\t\tif ( scope.enableZoom === false ) return;\n\t\t\t\tif ( state !== STATE.TOUCH_DOLLY ) return; // is this needed?...\n\n\t\t\t\thandleTouchMoveDolly( event );\n\n\t\t\t\tbreak;\n\n\t\t\tcase 3: // three-fingered touch: pan\n\n\t\t\t\tif ( scope.enablePan === false ) return;\n\t\t\t\tif ( state !== STATE.TOUCH_PAN ) return; // is this needed?...\n\n\t\t\t\thandleTouchMovePan( event );\n\n\t\t\t\tbreak;\n\n\t\t\tdefault:\n\n\t\t\t\tstate = STATE.NONE;\n\n\t\t}\n\n\t}\n\n\tfunction onTouchEnd( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\thandleTouchEnd( event );\n\n\t\tscope.dispatchEvent( endEvent );\n\n\t\tstate = STATE.NONE;\n\n\t}\n\n\tfunction onContextMenu( event ) {\n\n\t\tif ( scope.enabled === false ) return;\n\n\t\tevent.preventDefault();\n\n\t}\n\n\t//\n\n\tscope.domElement.addEventListener( 'contextmenu', onContextMenu, false );\n\n\tscope.domElement.addEventListener( 'mousedown', onMouseDown, false );\n\tscope.domElement.addEventListener( 'wheel', onMouseWheel, false );\n\n\tscope.domElement.addEventListener( 'touchstart', onTouchStart, false );\n\tscope.domElement.addEventListener( 'touchend', onTouchEnd, false );\n\tscope.domElement.addEventListener( 'touchmove', onTouchMove, false );\n\n\twindow.addEventListener( 'keydown', onKeyDown, false );\n\n\t// force an update at start\n\n\tthis.update();\n\n};\n\nOrbitControls.prototype = Object.create( THREE.EventDispatcher.prototype );\nOrbitControls.prototype.constructor = OrbitControls;\n\nObject.defineProperties( OrbitControls.prototype, {\n\n\tcenter: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( 'OrbitControls: .center has been renamed to .target' );\n\t\t\treturn this.target;\n\n\t\t}\n\n\t},\n\n\t// backward compatibility\n\n\tnoZoom: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( 'OrbitControls: .noZoom has been deprecated. Use .enableZoom instead.' );\n\t\t\treturn ! this.enableZoom;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( 'OrbitControls: .noZoom has been deprecated. Use .enableZoom instead.' );\n\t\t\tthis.enableZoom = ! value;\n\n\t\t}\n\n\t},\n\n\tnoRotate: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( 'OrbitControls: .noRotate has been deprecated. Use .enableRotate instead.' );\n\t\t\treturn ! this.enableRotate;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( 'OrbitControls: .noRotate has been deprecated. Use .enableRotate instead.' );\n\t\t\tthis.enableRotate = ! value;\n\n\t\t}\n\n\t},\n\n\tnoPan: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( 'OrbitControls: .noPan has been deprecated. Use .enablePan instead.' );\n\t\t\treturn ! this.enablePan;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( 'OrbitControls: .noPan has been deprecated. Use .enablePan instead.' );\n\t\t\tthis.enablePan = ! value;\n\n\t\t}\n\n\t},\n\n\tnoKeys: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( 'OrbitControls: .noKeys has been deprecated. Use .enableKeys instead.' );\n\t\t\treturn ! this.enableKeys;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( 'OrbitControls: .noKeys has been deprecated. Use .enableKeys instead.' );\n\t\t\tthis.enableKeys = ! value;\n\n\t\t}\n\n\t},\n\n\tstaticMoving: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( 'OrbitControls: .staticMoving has been deprecated. Use .enableDamping instead.' );\n\t\t\treturn ! this.enableDamping;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( 'OrbitControls: .staticMoving has been deprecated. Use .enableDamping instead.' );\n\t\t\tthis.enableDamping = ! value;\n\n\t\t}\n\n\t},\n\n\tdynamicDampingFactor: {\n\n\t\tget: function () {\n\n\t\t\tconsole.warn( 'OrbitControls: .dynamicDampingFactor has been renamed. Use .dampingFactor instead.' );\n\t\t\treturn this.dampingFactor;\n\n\t\t},\n\n\t\tset: function ( value ) {\n\n\t\t\tconsole.warn( 'OrbitControls: .dynamicDampingFactor has been renamed. Use .dampingFactor instead.' );\n\t\t\tthis.dampingFactor = value;\n\n\t\t}\n\n\t}\n\n} );\n\nexport default OrbitControls;\n","const groundPlane = new THREE.Plane(new THREE.Vector3(0, 1, 0));\nlet panning = false;\n\nexport default class TopDownCameraControls {\n  constructor(domElement, camera) {\n    this.domElement = domElement;\n    this.camera = camera;\n    this.enablePanning = false;\n    this.enabled = true;\n\n    this.minAltitude = Number.NEGATIVE_INFINITY;\n    this.maxAltitude = Number.POSITIVE_INFINITY;\n\n    this.mouseDown = this.mouseDown.bind(this);\n    this.mouseMove = this.mouseMove.bind(this);\n    this.mouseUp = this.mouseUp.bind(this);\n    this.wheel = this.wheel.bind(this);\n\n    this.domElement.addEventListener('mousedown', this.mouseDown);\n    this.domElement.addEventListener('mousemove', this.mouseMove);\n    this.domElement.addEventListener('mouseup', this.mouseUp);\n    this.domElement.addEventListener('wheel', this.wheel);\n  }\n\n  reset(prevCamera) {\n    const lookAt = new THREE.Vector3(0, 0, -1);\n    lookAt.applyQuaternion(prevCamera.quaternion);\n\n    const ray = new THREE.Ray(prevCamera.position, lookAt);\n    const intersection = ray.intersectPlane(groundPlane);\n\n    if (intersection) {\n      this.camera.position.set(intersection.x, 50, intersection.z);\n    } else {\n      this.camera.position.y = 50;\n    }\n\n    this.camera.rotation.set(-Math.PI / 2, 0, 0);\n  }\n\n  mouseDown(event) {\n    if (!this.enabled || !this.enablePanning || event.button != 2) return;\n    panning = true;\n  }\n\n  mouseMove(event) {\n    if (panning) {\n      const distance = 2 * this.camera.position.y * Math.tan((this.camera.fov / 2) * Math.PI / 180) / this.domElement.clientHeight;\n      this.camera.position.x -= distance * event.movementX;\n      this.camera.position.z -= distance * event.movementY;\n    }\n  }\n\n  mouseUp(event) {\n    if (event.button != 2) return;\n    panning = false;\n  }\n\n  wheel(event) {\n    if (!this.enabled) return;\n\n    event.preventDefault();\n\n    this.camera.position.y = Math.max(this.minAltitude, Math.min(this.maxAltitude, this.camera.position.y * Math.pow(0.995, -event.deltaY)));\n  }\n}\n","import Car from \"../physics/Car.js\";\n\nconst MPS_TO_MPH = 2.23694;\nconst METERS_TO_FEET = 3.28084;\n\nexport default class Dashboard {\n  constructor(car) {\n    this.car = car;\n    this.units = 'metric';\n\n    if (document.readyState == 'complete') {\n      this.fetchDomElements.call(this);\n    } else {\n      document.addEventListener('readystatechange', event => {\n        if (event.target.readyState == 'complete')\n          this.fetchDomElements.call(this);\n      });\n    }\n  }\n\n  fetchDomElements() {\n    this.wheelDom = document.getElementById('wheel');\n    this.wheelPieDom = document.getElementById('wheel-pie');\n    this.wheelPieLeftDom = document.getElementById('wheel-pie-left');\n    this.wheelPieRightDom = document.getElementById('wheel-pie-right');\n    this.gearDom = document.getElementById('gear');\n    this.gasDom = document.getElementById('gas');\n    this.brakeDom = document.getElementById('brake');\n    this.speedDom = document.getElementById('speed');\n    this.stationDom = document.getElementById('station');\n    this.latitudeDom = document.getElementById('latitude');\n    this.planTimeDom = document.getElementById('plan-time');\n    this.elapsedTimeDom = document.getElementById('elapsed-time');\n\n    this.speedUnitsDom = document.getElementById('speed-units');\n    this.stationUnitsDom = document.getElementById('station-units');\n    this.latitudeUnitsDom = document.getElementById('latitude-units');\n\n    [this.speedUnitsDom, this.stationUnitsDom, this.latitudeUnitsDom].forEach(el => {\n      el.addEventListener('click', event => {\n        this.toggleUnits();\n      });\n    });\n  }\n\n  toggleUnits() {\n    let speedUnits;\n    let distanceUnits;\n\n    if (this.units == 'metric') {\n      this.units = 'imperial';\n      speedUnits = 'mph';\n      distanceUnits = 'feet';\n    } else {\n      this.units = 'metric';\n      speedUnits = 'm/s';\n      distanceUnits = 'meters';\n    }\n\n    this.speedUnitsDom.textContent = speedUnits;\n    this.stationUnitsDom.textContent = distanceUnits;\n    this.latitudeUnitsDom.textContent = distanceUnits;\n  }\n\n  updatePlanTime(planTime) {\n    if (!this.wheelDom) return;\n\n    this.planTimeDom.textContent = planTime !== null ? (planTime).toLocaleString(undefined, { maximumFractionDigits: 3 }) : '—';\n  }\n\n  update(controls, speed, station, latitude, elapsedTime, planTime) {\n    if (!this.wheelDom) return;\n\n    const wheelTurn = Math.clamp(this.car.wheelAngle / Car.MAX_WHEEL_ANGLE * 0.95, -1, +1);\n\n    this.wheelDom.style.transform = `rotate(${wheelTurn}turn)`;\n\n    if (wheelTurn >= 0) {\n      this.wheelPieRightDom.style.transform = `rotate(${wheelTurn}turn)`;\n\n      if (wheelTurn <= 0.5) {\n        this.wheelPieDom.style.clipPath = \"inset(0 0 0 50%)\";\n        this.wheelPieLeftDom.style.transform = \"rotate(0)\";\n      } else {\n        this.wheelPieDom.style.clipPath = \"inset(0 0 0 0)\";\n        this.wheelPieLeftDom.style.transform = \"rotate(0.5turn)\";\n      }\n    } else {\n      this.wheelPieRightDom.style.transform = `rotate(${0.5 + wheelTurn}turn)`;\n\n      if (wheelTurn >= -0.5) {\n        this.wheelPieDom.style.clipPath = \"inset(0 50% 0 0)\";\n        this.wheelPieLeftDom.style.transform = \"rotate(0.5turn)\";\n      } else {\n        this.wheelPieDom.style.clipPath = \"inset(0 0 0 0)\";\n        this.wheelPieLeftDom.style.transform = \"rotate(0)\";\n      }\n    }\n\n    this.gearDom.innerText = controls.gas < 0 ? 'R' : 'D';\n    this.brakeDom.style.clipPath = `inset(50% 50% 0 ${50 - controls.brake * 25}%)`;\n    this.gasDom.style.clipPath = `inset(50% ${50 - Math.abs(controls.gas) * 25}% 0 50%)`;\n\n    if (this.units == 'imperial') {\n      speed *= MPS_TO_MPH;\n      station = station !== null ? station * METERS_TO_FEET : null;\n      latitude = latitude !== null ? latitude * METERS_TO_FEET : null;\n    }\n\n    let latitudeText = latitude !== null ? latitude.toFixed(2) : '—';\n    if (latitudeText == '-0.00') latitudeText = '0.00';\n\n    this.speedDom.textContent = speed.toFixed(1);\n    this.stationDom.textContent = station !== null ? station.toLocaleString(undefined, { minimumFractionDigits: 1, maximumFractionDigits: 1 }) : '—';\n    this.latitudeDom.textContent = latitudeText;\n    this.updatePlanTime(planTime);\n\n    let mins = Math.floor(elapsedTime / 60);\n    let seconds = elapsedTime % 60;\n\n    if (mins == 0) {\n      this.elapsedTimeDom.textContent = seconds.toFixed(1);\n    } else {\n      if (seconds < 10)\n        seconds = '0' + seconds.toFixed(1);\n      else\n        seconds = seconds.toFixed(1);\n\n      this.elapsedTimeDom.textContent = `${mins}:${seconds}`;\n    }\n  }\n}\n","export default class RoadLattice {\n  constructor(lanePath, latticeStartStation, config) {\n    const stationInterval = config.spatialHorizon / config.lattice.numStations;\n    const centerline = lanePath.sampleStations(latticeStartStation, config.lattice.numStations, stationInterval);\n    const lattice = new Array(centerline.length);\n    const offset = Math.floor(config.lattice.numLatitudes / 2);\n\n    for (let s = 0; s < centerline.length; s++) {\n      const sample = centerline[s];\n      const latitudes = lattice[s] = new Array(config.lattice.numLatitudes);\n\n      for (let l = 0; l < config.lattice.numLatitudes; l++) {\n        const latitude = (l - offset) / offset * config.roadWidth / 2;\n        const rot = sample.rot;\n        const pos = THREE.Vector2.fromAngle(rot + Math.PI / 2).multiplyScalar(latitude).add(sample.pos);\n        const curv = sample.curv == 0 ? 0 : 1 / (1 / sample.curv - latitude);\n\n        latitudes[l] = { pos, rot, curv };\n      }\n    }\n\n    this.lattice = lattice;\n  }\n}\n","const OBSTACLE_VERTEX_SHADER = `#version 300 es\nuniform mat3 xform;\nin vec2 position;\n\nvoid main(void) {\n  gl_Position = vec4((xform * vec3(position, 1)).xy, 0, 1);\n}\n`;\n\nconst OBSTACLE_KERNEL = `\n  vec4 kernel() {\n    return vec4(1, 0, 0, 1);\n  }\n`;\n\nlet obstacleVertices;\nlet obstacleXform;\n\n// Draw obstacle triangles to XY-space obstacle grid\nexport default {\n  setUp() {\n    return {\n      kernel: OBSTACLE_KERNEL,\n      vertexShader: OBSTACLE_VERTEX_SHADER,\n      output: { name: 'xyObstacleGrid' },\n      draw: (gpgpu, program) => {\n        const gl = gpgpu.gl;\n\n        gl.clearColor(0, 0, 0, 0);\n        gl.clear(gl.COLOR_BUFFER_BIT);\n\n        if (obstacleVertices.length > 0) {\n          const buf = gl.createBuffer();\n\n          gl.bindBuffer(gl.ARRAY_BUFFER, buf);\n          gl.bufferData(gl.ARRAY_BUFFER, obstacleVertices, gl.STATIC_DRAW);\n          gl.enableVertexAttribArray(program.positionLocation);\n          gl.vertexAttribPointer(program.positionLocation, 2, gl.FLOAT, false, 0, 0);\n\n          const xformLocation = gl.getUniformLocation(program.glProgram, 'xform');\n          gl.uniformMatrix3fv(xformLocation, false, obstacleXform.elements);\n\n          gl.drawArrays(gl.TRIANGLES, 0, obstacleVertices.length / 2);\n\n          gl.deleteBuffer(buf);\n        }\n      }\n    };\n  },\n\n  update(config, xyWidth, xyHeight, xyCenterPoint, vehicleXform, obstacles) {\n    obstacleVertices = new Float32Array(Array.prototype.concat.apply([], obstacles.map(o => o.vertices)));\n\n    const translate = new THREE.Matrix3();\n    translate.set(\n      1, 0, -xyCenterPoint.x,\n      0, 1, -xyCenterPoint.y,\n      0, 0, 1\n    );\n\n    const scale = new THREE.Matrix3();\n    scale.set(\n      2 / (xyWidth * config.xyGridCellSize), 0, 0,\n      0, 2 / (xyHeight * config.xyGridCellSize), 0,\n      0, 0, 1\n    );\n\n    obstacleXform = scale.multiply(translate).multiply(vehicleXform);\n\n    return {\n      width: xyWidth,\n      height: xyHeight\n    }\n  }\n}\n","const SL_OBSTACLE_KERNEL = `\n\nvec4 kernel() {\n  float centerlineWidth = float(textureSize(centerline, 0).x);\n\n  vec2 sl = (kernelPosition - 0.5) * vec2(kernelSize) * vec2(slGridCellSize) + slCenterPoint;\n  float centerlineCoord = sl.x / centerlineStationInterval / centerlineWidth * (centerlineWidth - 1.0) / centerlineWidth + (0.5 / centerlineWidth);\n  if (centerlineCoord < 0.0 || centerlineCoord > 1.0) return vec4(0);\n\n  vec3 centerlineSample = texture(centerline, vec2(centerlineCoord, 0)).xyz;\n  float perpindicular = centerlineSample.z + radians(90.0);\n  vec2 xy = centerlineSample.xy + sl.yy * vec2(cos(perpindicular), sin(perpindicular));\n\n  vec2 xyTexCoords = (xy - xyCenterPoint) / vec2(textureSize(xyObstacleGrid, 0)) / vec2(xyGridCellSize) + 0.5;\n  return texture(xyObstacleGrid, xyTexCoords);\n}\n\n`;\n\n// Convert XY-space obstacle grid to SL-space obstacle grid\nexport default {\n  setUp() {\n    return {\n      kernel: SL_OBSTACLE_KERNEL,\n      output: { name: 'slObstacleGrid' },\n      uniforms: {\n        xyObstacleGrid: { type: 'outputTexture' },\n        slGridCellSize: { type: 'float' },\n        xyGridCellSize: { type: 'float' },\n        slCenterPoint: { type: 'vec2' },\n        xyCenterPoint: { type: 'vec2' },\n        centerlineStationInterval: { type: 'float' },\n        centerline: { type: 'sharedTexture' }\n      }\n    }\n  },\n\n  update(config, slWidth, slHeight, slCenterPoint, xyCenterPoint) {\n    return {\n      width: slWidth,\n      height: slHeight,\n      uniforms: {\n        slGridCellSize: config.slGridCellSize,\n        xyGridCellSize: config.xyGridCellSize,\n        slCenterPoint: [slCenterPoint.x, slCenterPoint.y],\n        xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y],\n        centerlineStationInterval: config.centerlineStationInterval\n      }\n    }\n  }\n}\n","const SL_OBSTACLE_DILATION_KERNEL = `\n\n// TODO: test performance of returning early if non-zero pixel found\nvec4 kernel() {\n  float val = 0.0;\n\n  for (int d = 0; d <= collisionDilation; d++) {\n    val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(d)).r);\n    val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(-d)).r);\n  }\n\n  for (int d = collisionDilation + 1; d <= collisionDilation + hazardDilation; d++) {\n    val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(d)).r * 0.5);\n    val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(-d)).r * 0.5);\n  }\n\n  val = max(val, step(0.1, val) * 0.5);\n\n  return vec4(val, 0, 0, 1);\n}\n\n`;\n\nexport default {\n  setUp() {\n    return [\n      { // SL-space obstacle grid S dilation\n        kernel: SL_OBSTACLE_DILATION_KERNEL,\n        output: { name: 'slObstacleGridStationDilated' },\n        uniforms: {\n          slObstacleGrid: { type: 'outputTexture' },\n          delta: { type: 'vec2' },\n          collisionDilation: { type: 'int' },\n          hazardDilation: { type: 'int' }\n        }\n      },\n      { // SL-space obstacle grid L dilation\n        kernel: SL_OBSTACLE_DILATION_KERNEL,\n        output: { name: 'slObstacleGridDilated' },\n        uniforms: {\n          slObstacleGrid: { type: 'outputTexture', name: 'slObstacleGridStationDilated' },\n          delta: { type: 'vec2' },\n          collisionDilation: { type: 'int' },\n          hazardDilation: { type: 'int' }\n        }\n      }\n    ];\n  },\n\n  update(config, slWidth, slHeight) {\n    return [\n      { // SL-space obstacle grid S dilation\n        width: slWidth,\n        height: slHeight,\n        uniforms: {\n          delta: [1 / slWidth, 0],\n          collisionDilation: Math.ceil(config.collisionDilationS / config.slGridCellSize),\n          hazardDilation: Math.ceil(config.hazardDilationS / config.slGridCellSize)\n        }\n      },\n      { // SL-space obstacle grid L dilation\n        width: slWidth,\n        height: slHeight,\n        uniforms: {\n          delta: [0, 1 / slHeight],\n          collisionDilation: Math.ceil(config.collisionDilationL / config.slGridCellSize),\n          hazardDilation: Math.ceil(config.hazardDilationL / config.slGridCellSize)\n        }\n      }\n    ];\n  }\n}\n","const DYNAMIC_OBSTACLE_VERTEX_SHADER = `#version 300 es\nuniform mat3 xform;\nin vec3 position;\nout float color;\n\nvoid main(void) {\n  gl_Position = vec4((xform * vec3(position.xy, 1)).xy, position.z, 1);\n\n  // The z coordinate is 0.25 for collision zone and 0.75 for hazard zone,\n  // so that the collision zone is drawn on top.\n  // Convert this to 1.0 for collision zone, 0.5 for hazard zone\n  color = (1.0 - step(0.5, position.z)) * 0.5 + 0.5;\n}\n`;\n\nconst DYNAMIC_OBSTACLE_KERNEL = `\n  in float color;\n\n  vec4 kernel() {\n    return vec4(color, 0, 0, 1);\n  }\n`;\n\nlet obstacleVertices;\nlet obstacleXform;\nconst numDynamicFrames = 20;\n\n// Draw dynamic obstacle triangles to SL-space obstacle grid\nexport default {\n  setUp() {\n    return {\n      kernel: DYNAMIC_OBSTACLE_KERNEL,\n      vertexShader: DYNAMIC_OBSTACLE_VERTEX_SHADER,\n      output: { name: 'slDynamicObstacleGrid', textureType: '2DArray', depth: numDynamicFrames },\n      draw: (gpgpu, program) => {\n        const gl = gpgpu.gl;\n\n        gl.enable(gl.DEPTH_TEST);\n\n        const renderbuffer = gl.createRenderbuffer();\n        gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer);\n        gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, program.inputWidth, program.inputHeight);\n        gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, renderbuffer);\n\n        for (let frame = 0; frame < numDynamicFrames; frame++) {\n          gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, program.outputTexture, 0, frame);\n          const frameBufferStatus = (gl.checkFramebufferStatus(gl.FRAMEBUFFER) == gl.FRAMEBUFFER_COMPLETE);\n          if (!frameBufferStatus)\n            throw new Error('Error attaching float texture to framebuffer. Your device is probably incompatible.');\n\n          gl.clearColor(0, 0, 0, 0);\n          gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);\n\n          if (obstacleVertices[frame].length > 0) {\n            const buf = gl.createBuffer();\n\n            gl.bindBuffer(gl.ARRAY_BUFFER, buf);\n            gl.bufferData(gl.ARRAY_BUFFER, obstacleVertices[frame], gl.STATIC_DRAW);\n            gl.enableVertexAttribArray(program.positionLocation);\n            gl.vertexAttribPointer(program.positionLocation, 3, gl.FLOAT, false, 0, 0);\n\n            const xformLocation = gl.getUniformLocation(program.glProgram, 'xform');\n            gl.uniformMatrix3fv(xformLocation, false, obstacleXform.elements);\n\n            gl.drawArrays(gl.TRIANGLES, 0, obstacleVertices[frame].length / 3);\n\n            if (frame == 0) {\n              const obstacleGrid = new Float32Array(program.inputWidth * program.inputHeight * 4);\n              gl.readPixels(0, 0, program.inputWidth, program.inputHeight, gl.RGBA, gl.FLOAT, obstacleGrid);\n              gpgpu._dynamicObstacleGrid = obstacleGrid;\n            }\n\n            gl.deleteBuffer(buf);\n          }\n        }\n\n        gl.bindRenderbuffer(gl.RENDERBUFFER, null);\n        gl.deleteRenderbuffer(renderbuffer);\n        gl.disable(gl.DEPTH_TEST);\n      }\n    };\n  },\n\n  update(config, slWidth, slHeight, slCenterPoint, vehicleStation, startTime, dynamicFrameTime, dynamicObstacles) {\n    obstacleVertices = [];\n\n    let time = startTime;\n    for (let frame = 0; frame < numDynamicFrames; frame++) {\n      const vertices = Array.prototype.concat.apply([], dynamicObstacles.map(o => o.verticesInTimeRange(time, time + dynamicFrameTime, config)));\n      obstacleVertices.push(new Float32Array(vertices));\n      time += dynamicFrameTime;\n    }\n\n    const translate = new THREE.Matrix3();\n    translate.set(\n      1, 0, -slCenterPoint.x - vehicleStation,\n      0, 1, -slCenterPoint.y,\n      0, 0, 1\n    );\n\n    const scale = new THREE.Matrix3();\n    scale.set(\n      2 / (slWidth * config.slGridCellSize), 0, 0,\n      0, 2 / (slHeight * config.slGridCellSize), 0,\n      0, 0, 1\n    );\n\n    obstacleXform = scale.multiply(translate);\n\n    return {\n      width: slWidth,\n      height: slHeight\n    }\n  }\n}\n","const XYSL_MAP_KERNEL = `\n\nvec4 kernel() {\n  vec2 xy = (kernelPosition - 0.5) * vec2(kernelSize) * vec2(xyGridCellSize) + xyCenterPoint;\n\n  int numSamples = textureSize(centerline, 0).x;\n  int closest = 0;\n  float closestDist = distance(xy, texelFetch(centerline, ivec2(0, 0), 0).xy);\n  for (int i = 1; i < numSamples; i++) {\n    float dist = distance(xy, texelFetch(centerline, ivec2(i, 0), 0).xy);\n    if (dist < closestDist) {\n      closestDist = dist;\n      closest = i;\n    }\n  }\n\n  vec2 closestPos = texelFetch(centerline, ivec2(closest, 0), 0).xy;\n  vec2 prev, next;\n  int prevIndex, nextIndex;\n\n  if (closest == 0) {\n    prevIndex = 0;\n    nextIndex = 1;\n    prev = closestPos;\n    next = texelFetch(centerline, ivec2(1, 0), 0).xy;\n  } else if (closest == numSamples - 1) {\n    prevIndex = closest - 1;\n    nextIndex = closest;\n    prev = texelFetch(centerline, ivec2(prevIndex, 0), 0).xy;\n    next = closestPos;\n  } else {\n    vec2 before = texelFetch(centerline, ivec2(closest - 1, 0), 0).xy;\n    vec2 after = texelFetch(centerline, ivec2(closest + 1, 0), 0).xy;\n\n    if (distance(before, xy) < distance(after, xy)) {\n      prevIndex = closest - 1;\n      nextIndex = closest;\n      prev = before;\n      next = closestPos;\n    } else {\n      prevIndex = closest;\n      nextIndex = closest + 1;\n      prev = closestPos;\n      next = after;\n    }\n  }\n\n  float dist = distance(prev, next);\n  float progress = clamp(dot(xy - prev, next - prev) / dist / dist, 0.0, 1.0);\n  vec2 projectedPos = (next - prev) * vec2(progress) + prev;\n\n  return vec4(\n    (float(prevIndex) + progress) * centerlineStationInterval,\n    sign(determinant(mat2(next - prev, xy - prev))) * distance(xy, projectedPos),\n    0,\n    0\n  );\n}\n\n`;\n\n// Build XY-SL map\nexport default {\n  setUp() {\n    return {\n      kernel: XYSL_MAP_KERNEL,\n      output: { name: 'xyslMap', filter: 'linear' },\n      uniforms: {\n        centerline: { type: 'sharedTexture' },\n        xyCenterPoint: { type: 'vec2' },\n        xyGridCellSize: { type: 'float'},\n        centerlineStationInterval: { type: 'float'}\n      }\n    };\n  },\n\n  update(config, xyWidth, xyHeight, xyCenterPoint) {\n    return {\n      width: xyWidth,\n      height: xyHeight,\n      uniforms: {\n        xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y],\n        xyGridCellSize: config.xyGridCellSize,\n        centerlineStationInterval: config.centerlineStationInterval\n      }\n    };\n  }\n}\n","// Config:\n// num stations\n// num latitudes\n// station connectivity\n// latitude connectivity\n//\n// Shared:\n// lattice\n\nconst OPTIMIZE_CUBIC_SHARED = `\n\nconst int NEWTON_ITERATIONS = 16;\nconst int RELAXATION_ITERATIONS = 16;\nconst float CONVERGENCE_ERROR = 0.01;\n\n// These two consts must stay in sync.\nconst int SIMPSONS_INTERVALS = 8;\n//const float SIMPSONS_COEFFS[SIMPSONS_INTERVALS + 1] = float[](1.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 1.0);\nconst float SIMPSONS_COEFFS[SIMPSONS_INTERVALS + 1] = float[](1.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 1.0);\n\nconst float PI = 3.1415926535897932384626433832795;\nconst float TWO_PI = PI + PI;\n\nconst float RELAXATION_ITERATIONS_F = float(RELAXATION_ITERATIONS);\nconst float SIMPSONS_INTERVALS_F = float(SIMPSONS_INTERVALS);\n\nfloat wrapAngle(float angle) {\n  angle = mod(angle, TWO_PI);\n  if (angle <= -PI) return angle + TWO_PI;\n  else if (angle > PI) return angle - TWO_PI;\n  return angle;\n}\n\nvec4 iterate(vec4 goal, float p0, float p1, float p2, float p3, float sG) {\n  float ds = sG / SIMPSONS_INTERVALS_F;\n  float sG_2 = sG * sG;\n  float sG_3 = sG_2 * sG;\n\n  vec3 dX_p = vec3(0.0);\n  vec3 dY_p = vec3(0.0);\n  vec2 guess = vec2(0.0);\n  float s = 0.0;\n\n  float theta, cosTheta, sinTheta;\n  vec3 dT_p;\n\n  for (int i = 0; i <= SIMPSONS_INTERVALS; i++) {\n    float coeff = SIMPSONS_COEFFS[i];\n\n    float a = p0;\n    float b = (-5.5 * p0 + 9.0 * p1 - 4.5 * p2 + p3) / sG;\n    float c = (9.0 * p0 - 22.5 * p1 + 18.0 * p2 - 4.5 * p3) / sG_2;\n    float d = (-4.5 * (p0 - 3.0 * p1 + 3.0 * p2 - p3)) / sG_3;\n\n    theta = (((d * s / 4.0 + c / 3.0) * s + b / 2.0) * s + a) * s;\n    cosTheta = cos(theta);\n    sinTheta = sin(theta);\n\n    float s_sG = s / sG;\n\n    dT_p = vec3(\n      // p1\n      ((3.375 * s_sG - 7.5) * s_sG + 4.5) * s_sG * s,\n\n      // p2\n      ((-3.375 * s_sG + 6.0) * s_sG - 2.25) * s_sG * s,\n\n      // sG\n      ((3.375 * (p0 - 3.0 * p1 + 3.0 * p2 - p3) * s_sG - 3.0 * (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3)) * s_sG + 0.25 * (11.0 * p0 - 18.0 * p1 + 9.0 * p2 - 2.0 * p3)) * s_sG * s_sG\n    );\n\n    dX_p -= coeff * sinTheta * dT_p;\n    dY_p += coeff * cosTheta * dT_p;\n\n    guess += coeff * vec2(cosTheta, sinTheta);\n\n    s += ds;\n  }\n\n  float hOver3 = sG / SIMPSONS_INTERVALS_F / 3.0;\n\n  vec3 delta;\n  delta.xy = goal.xy - guess * hOver3;\n  delta.z = wrapAngle(goal.z - theta);\n\n  if (abs(delta.x) + abs(delta.y) + abs(delta.z) < CONVERGENCE_ERROR)\n    return vec4(p1, p2, sG, 1.0);\n\n  dX_p.xyz *= hOver3;\n  dY_p.xyz *= hOver3;\n  dX_p.z += cosTheta;\n  dY_p.z += sinTheta;\n\n  mat3 invJacobian = inverse(transpose(mat3(dX_p, dY_p, dT_p)));\n\n  vec3 deltaP = invJacobian * delta;\n  vec4 params = vec4(p1, p2, sG, 0.0);\n  params.xyz += deltaP;\n\n  return params;\n}\n\n/* Input:\n *   start: (vec4)\n *     x: x position,\n *     y: y position,\n *     z: theta rotation,\n *     w: k curvature\n *   end: (vec4)\n *     x: x position,\n *     y: y position,\n *     z: theta rotation,\n *     w: k curvature\n *\n * Output: (vec4)\n *   x: p1,\n *   y: p2,\n *   z: sG,\n *   w: 1 if converged, 0 if not\n */\n\nvec4 optimize(vec4 start, vec4 end) {\n  // Translate and rotate start and end so that start is at the origin\n  float sinRot = sin(start.z);\n  float cosRot = cos(start.z);\n\n  vec4 diff = end - start;\n  vec4 goal;\n  goal.xy = mat2(cosRot, -sinRot, sinRot, cosRot) * diff.xy;\n  goal.z = wrapAngle(diff.z);\n  goal.w = end.w;\n\n  vec4 originalGoal = goal;\n  vec4 dGoal;\n  dGoal.x = 0.0;\n  dGoal.yzw = goal.yzw / RELAXATION_ITERATIONS_F;\n  float dK0 = start.w / RELAXATION_ITERATIONS_F;\n\n  // Relax the goal to (x, 0, 0, 0)\n  goal.yzw = vec3(0, 0, 0);\n\n  // Relax the params to (0, 0, 0, 0, goal.x)\n  float p0 = 0.0;\n  float p1 = 0.0;\n  float p2 = 0.0;\n  float p3 = 0.0;\n  float sG = goal.x;\n\n  if (sG < 0.1) return vec4(0.0);\n\n  for (int i = 0; i < RELAXATION_ITERATIONS; i++) {\n    p0 += dK0;\n    p3 += dGoal.w;\n    goal += dGoal;\n    \n    vec4 result = iterate(goal, p0, p1, p2, p3, sG);\n    p1 = result.x;\n    p2 = result.y;\n    sG = result.z;\n  }\n\n  goal = originalGoal;\n\n  for (int i = 0; i < NEWTON_ITERATIONS; i++) {\n    vec4 result = iterate(goal, p0, p1, p2, p3, sG);\n    if (result.w == 1.0) {\n      result.w = step(0.0, result.z);\n      return result;\n    }\n\n    p1 = result.x;\n    p2 = result.y;\n    sG = result.z;\n  }\n\n  return vec4(p1, p2, sG, 0.0);\n}\n\n`;\n\nconst OPTIMIZE_CUBIC_KERNEL = OPTIMIZE_CUBIC_SHARED + `\n\n// width: station * latitude index\n// height: station_conn * lattice_conn\n//\n// lattice:\n// width: latitudes\n// height: stations\n\nvec4 kernel() {\n  ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize));\n\n  int endStation = indexes.x / numLatitudes;\n  int endLatitude = int(mod(float(indexes.x), float(numLatitudes)));\n\n  int startStation = endStation - stationConnectivity + indexes.y / latitudeConnectivity;\n  int startLatitude = endLatitude - latitudeConnectivity / 2 + int(mod(float(indexes.y), float(latitudeConnectivity)));\n\n  if (startStation < 0 || startStation >= numStations || startLatitude < 0 || startLatitude >= numLatitudes)\n    return vec4(0.0);\n\n  vec4 start = texelFetch(lattice, ivec2(startLatitude, startStation), 0);\n  vec4 end = texelFetch(lattice, ivec2(endLatitude, endStation), 0);\n\n  return optimize(start, end);\n}\n\n`;\n\nconst OPTIMIZE_CUBIC_FROM_VEHICLE_KERNEL = OPTIMIZE_CUBIC_SHARED + `\n\nvec4 kernel() {\n  ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize));\n\n  vec4 start = vec4(0, 0, 0, curvVehicle);\n  vec4 end = texelFetch(lattice, indexes, 0);\n\n  return optimize(start, end);\n}\n\n`;\n\nexport default {\n  setUp() {\n    return [\n      { // Cubic paths between lattice nodes\n        kernel: OPTIMIZE_CUBIC_KERNEL,\n        output: { name: 'cubicPaths', read: true },\n        uniforms: {\n          lattice: { type: 'sharedTexture' },\n          numStations: { type: 'int' },\n          numLatitudes: { type: 'int' },\n          stationConnectivity: { type: 'int' },\n          latitudeConnectivity: { type: 'int' }\n        }\n      },\n      { // Cubic paths from vehicle to lattice nodes\n        kernel: OPTIMIZE_CUBIC_FROM_VEHICLE_KERNEL,\n        output: { name: 'cubicPathsFromVehicle', read: true },\n        uniforms: {\n          lattice: { type: 'sharedTexture' },\n          curvVehicle: { type: 'float' }\n        }\n      }\n    ]\n  },\n\n  update(config, pose) {\n    return [\n      { // Cubic paths between lattice nodes\n        width: config.lattice.numStations * config.lattice.numLatitudes,\n        height: config.lattice.stationConnectivity * config.lattice.latitudeConnectivity,\n        uniforms: {\n          numStations: config.lattice.numStations,\n          numLatitudes: config.lattice.numLatitudes,\n          stationConnectivity: config.lattice.stationConnectivity,\n          latitudeConnectivity: config.lattice.latitudeConnectivity,\n        }\n      },\n      { // Cubic paths from vehicle to lattice nodes\n        width: config.lattice.numLatitudes,\n        height: config.lattice.stationConnectivity,\n        uniforms: {\n          curvVehicle: pose.curv\n        }\n      }\n    ];\n  }\n}\n","const OPTIMIZE_KERNEL = `\n\nconst int NEWTON_ITERATIONS = 32;\nconst int RELAXATION_ITERATIONS = 32;\nconst float CONVERGENCE_ERROR = 0.01;\n\n// These two consts must stay in sync.\nconst int SIMPSONS_INTERVALS = 8;\nconst float SIMPSONS_COEFFS[SIMPSONS_INTERVALS + 1] = float[](1.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 1.0);\n\nconst float PI = 3.1415926535897932384626433832795;\nconst float TWO_PI = PI + PI;\n\nconst float RELAXATION_ITERATIONS_F = float(RELAXATION_ITERATIONS);\nconst float SIMPSONS_INTERVALS_F = float(SIMPSONS_INTERVALS);\n\nfloat wrapAngle(float angle) {\n  angle = mod(angle, TWO_PI);\n  if (angle <= -PI) return angle + TWO_PI;\n  else if (angle > PI) return angle - TWO_PI;\n  return angle;\n}\n\nvec4 iterate(vec4 goal, float p0, float p1, float p2, float p3, float p4, float p5, float sG) {\n  float ds = sG / SIMPSONS_INTERVALS_F;\n  float sG_2 = sG * sG;\n  float sG_3 = sG_2 * sG;\n\n  vec3 dX_p = vec3(0.0);\n  vec3 dY_p = vec3(0.0);\n  vec2 guess = vec2(0.0);\n  float s = 0.0;\n\n  float theta, cosTheta, sinTheta;\n  vec3 dT_p;\n\n  for (int i = 0; i <= SIMPSONS_INTERVALS; i++) {\n    float coeff = SIMPSONS_COEFFS[i];\n\n    float a = p0;\n    float b = p1;\n    float c = p2 / 2.0;\n    float d = (-71.875 * p0 + 81.0 * p3 - 10.125 * p4 + p5 - 21.25 * p1 * sG - 2.75 * p2 * sG_2) / sG_3;\n    float e = (166.5 * p0 - 202.5 * p3 + 40.5 * p4 - 4.5 * p5 + 45.0 * p1 * sG + 4.5 * p2 * sG_2) / (sG_2 * sG_2);\n    float f = (-95.625 * p0 + 121.5 * p3 - 30.375 * p4 + 4.5 * p5 - 24.75 * p1 * sG - 2.25 * p2 * sG_2) / (sG_2 * sG_3);\n\n    theta = (((((f * s / 6.0 + e / 5.0) * s + d / 4.0) * s + c / 3.0) * s + b / 2.0) * s + a) * s;\n    cosTheta = cos(theta);\n    sinTheta = sin(theta);\n\n    float s_2 = s * s;\n    float s_sG = s / sG;\n    float s_sG_2 = s_sG * s_sG;\n    float s_sG_3 = s_sG_2 * s_sG;\n    float s_sG_4 = s_sG_3 * s_sG;\n    float s_sG_5 = s_sG_4 * s_sG;\n\n    dT_p = vec3(\n      // p3\n      ((20.25 * s_sG - 40.5) * s_sG + 20.25) * s_sG_3 * s,\n\n      // p4\n      ((-5.0625 * s_sG + 8.1) * s_sG - 2.53125) * s_sG_3 * s,\n\n      // sG\n      (53.90625 * p0 - 60.75 * p3 + 7.59375 * p4 - 0.75 * p5) * s_sG_4 + 10.625 * p1 * s * s_sG_3 + 0.6875 * p2 * s_2 * s_sG_2 + (-133.2 * p0 + 162.0 * p3 - 32.4 * p4 + 3.6 * p5) * s_sG_5 + (-27.0) * p1 * s * s_sG_4 - 1.8 * p2 * s_2 * s_sG_3 + (79.6875 * p0 - 101.25 * p3 + 25.3125 * p4 - 3.75 * p5) * s_sG_5 * s_sG + 16.5 * p1 * s * s_sG_5 + 1.125 * p2 * s_2 * s_sG_4\n    );\n\n    dX_p -= coeff * sinTheta * dT_p;\n    dY_p += coeff * cosTheta * dT_p;\n\n    guess += coeff * vec2(cosTheta, sinTheta);\n\n    s += ds;\n  }\n\n  float hOver3 = sG / SIMPSONS_INTERVALS_F / 3.0;\n\n  vec3 delta;\n  delta.xy = goal.xy - guess * hOver3;\n  delta.z = wrapAngle(goal.z - theta);\n\n  if (abs(delta.x) + abs(delta.y) + abs(delta.z) < CONVERGENCE_ERROR)\n    return vec4(p3, p4, sG, 1.0);\n\n  dX_p.xyz *= hOver3;\n  dY_p.xyz *= hOver3;\n  dX_p.z += cosTheta;\n  dY_p.z += sinTheta;\n\n  mat3 invJacobian = inverse(transpose(mat3(dX_p, dY_p, dT_p)));\n\n  vec3 deltaP = invJacobian * delta;\n  vec4 params = vec4(p3, p4, sG, 0.0);\n  params.xyz += deltaP;\n\n  return params;\n}\n\nvec4 optimize(vec4 start, vec4 end) {\n  // Translate and rotate start and end so that start is at the origin\n  float sinRot = sin(start.z);\n  float cosRot = cos(start.z);\n\n  vec4 diff = end - start;\n  vec4 goal;\n  goal.xy = mat2(cosRot, -sinRot, sinRot, cosRot) * diff.xy;\n  goal.z = wrapAngle(diff.z);\n  goal.w = end.w;\n\n  vec4 originalGoal = goal;\n  vec4 dGoal;\n  dGoal.x = 0.0;\n  dGoal.yzw = goal.yzw / RELAXATION_ITERATIONS_F;\n  float d_K0 = start.w / RELAXATION_ITERATIONS_F;\n  float d_dK0 = dCurvVehicle / RELAXATION_ITERATIONS_F;\n  float d_ddK0 = ddCurvVehicle / RELAXATION_ITERATIONS_F;\n\n  // Relax the goal to (x, 0, 0, 0)\n  goal.yzw = vec3(0, 0, 0);\n\n  // Relax the params to (0, 0, 0, 0, goal.x)\n  float p0 = 0.0;\n  float p1 = 0.0;\n  float p2 = 0.0;\n  float p3 = 0.0;\n  float p4 = 0.0;\n  float p5 = 0.0;\n  float sG = goal.x;\n\n  if (sG < 0.1) return vec4(0.0);\n\n  for (int i = 0; i < RELAXATION_ITERATIONS; i++) {\n    p0 += d_K0;\n    p1 += d_dK0;\n    p2 += d_ddK0;\n    p5 += dGoal.w;\n    goal += dGoal;\n    \n    vec4 result = iterate(goal, p0, p1, p2, p3, p4, p5, sG);\n    p3 = result.x;\n    p4 = result.y;\n    sG = result.z;\n  }\n\n  goal = originalGoal;\n\n  for (int i = 0; i < NEWTON_ITERATIONS; i++) {\n    vec4 result = iterate(goal, p0, p1, p2, p3, p4, p5, sG);\n    if (result.w == 1.0) {\n      result.w = step(0.0, result.z);\n      return result;\n    }\n\n    p3 = result.x;\n    p4 = result.y;\n    sG = result.z;\n  }\n\n  return vec4(p3, p4, sG, 0.0);\n}\n\nvec4 kernel() {\n  ivec2 latticeIndexes = ivec2(kernelPosition * vec2(kernelSize));\n\n  vec4 start = vec4(0, 0, 0, curvVehicle);\n  vec4 end = texelFetch(lattice, latticeIndexes, 0);\n\n  return optimize(start, end);\n}\n\n`;\n\n// Quintic spiral path optimizer\n//   * Start of paths is the vehicle pose\n//     * x-pos, y-pos, and rotation aren't needed, since the lattice origin is the vehicle pose\n//     * So assume position and rotation are 0\n//   * Ends of paths are all latitudes within the first (stationConnectivity) stations\nexport default {\n  setUp() {\n    return {\n      kernel: OPTIMIZE_KERNEL,\n      output: { name: 'quinticPathsFromVehicle', read: true },\n      uniforms: {\n        lattice: { type: 'sharedTexture' },\n        curvVehicle: { type: 'float' },\n        dCurvVehicle: { type: 'float' },\n        ddCurvVehicle: { type: 'float' }\n      }\n    };\n  },\n\n  update(config, pose) {\n    return {\n      width: config.lattice.numLatitudes,\n      height: config.lattice.stationConnectivity,\n      uniforms: {\n        curvVehicle: pose.curv,\n        dCurvVehicle: pose.dCurv,\n        ddCurvVehicle: pose.ddCurv\n      }\n    };\n  }\n}\n","const SHARED_SHADER = `\n\nconst float smallV = 0.01;\nvec4 pathSamples[128];\nfloat pathSampleCurvRates[128];\n\nfloat calculateAcceleration(int index, float initialVelocitySq, float distance) {\n  if (index <= 4) {\n    // [aMaxHard, aMinHard, aMaxSoft, aMinSoft, 0]\n    return accelerationProfiles[index];\n  } else {\n    float finalVelocity = finalVelocityProfiles[index - 5];\n    if (distance < 0.001) return 0.0;\n    return clamp((finalVelocity * finalVelocity - initialVelocitySq) / (2.0 * distance), accelerationProfiles[1], accelerationProfiles[0]);\n  }\n}\n\nvec2 xy2sl(vec4 xytk) {\n  vec2 xy = xytk.xy + rearAxleToCenter * vec2(cos(xytk.z), sin(xytk.z));\n  vec2 xyTexCoords = (xy - xyCenterPoint) / vec2(textureSize(xyslMap, 0)) / vec2(xyGridCellSize) + 0.5;\n  return texture(xyslMap, xyTexCoords).xy;\n}\n\nfloat sampleStaticCost(vec4 xytk) {\n  vec2 sl = xy2sl(xytk);\n  vec2 slTexCoords = (sl - slCenterPoint) / vec2(textureSize(slObstacleGrid, 0)) / vec2(slGridCellSize) + 0.5;\n  float obstacleCost = texture(slObstacleGrid, slTexCoords).r;\n\n  if (obstacleCost >= 0.75) return -1.0; // Infinite cost\n\n  obstacleCost = step(0.25, obstacleCost) * obstacleHazardCost;\n\n  float absLatitude = abs(sl.y);\n  if (absLatitude >= laneShoulderLatitude) return -1.0;\n\n  float laneCost = abs(absLatitude - laneCenterLatitude) * laneCostSlope + step(0.0, -sl.y * sign(lanePreference)) * lanePreferenceDiscount;\n\n  return obstacleCost + laneCost;\n}\n\nfloat sampleDynamicCost(vec4 xytk, float time, float velocity, float acceleration) {\n  vec2 sl = xy2sl(xytk);\n  vec2 slTexCoords = (sl - slCenterPoint) / vec2(textureSize(slDynamicObstacleGrid, 0).xy) / vec2(slGridCellSize) + 0.5;\n  float dynamicFrame = floor(time / dynamicFrameTime);\n\n  float obstacleCost = texture(slDynamicObstacleGrid, vec3(slTexCoords, dynamicFrame)).r;\n\n  if (obstacleCost > 0.75) return -1.0; // Infinite cost\n\n  return step(0.25, obstacleCost) * obstacleHazardCost;\n}\n\nfloat calculateAverageStaticCost(int numSamples) {\n  float averageStaticCost = 0.0;\n\n  for (int i = 0; i < numSamples; i++) {\n    float cost = sampleStaticCost(pathSamples[i]);\n\n    if (cost < 0.0) return cost;\n\n    averageStaticCost += cost;\n  }\n\n  averageStaticCost /= float(numSamples);\n\n  return averageStaticCost;\n}\n\nfloat calculateAverageDynamicCost(int numSamples, float pathLength, float initialTime, float initialVelocity, float acceleration, float abandonThreshold) {\n  float s = 0.0;\n  float ds = pathLength / float(numSamples - 1);\n  float averageDynamicCost = 0.0;\n  float maxVelocity = 0.0;\n  float maxLateralAcceleration = 0.0;\n  float numSamples_f = float(numSamples);\n\n  for (int i = 0; i < numSamples; i++) {\n    vec4 pathSample = pathSamples[i]; // vec4(x-pos, y-pos, theta (rotation), kappa (curvature))\n\n    float velocitySq = 2.0 * acceleration * s + initialVelocity * initialVelocity;\n    float velocity = max(smallV, sqrt(max(0.0, velocitySq)));\n    maxVelocity = max(maxVelocity, velocity);\n    maxLateralAcceleration = max(maxLateralAcceleration, abs(pathSample.w * velocity * velocity));\n\n    float time = 2.0 * s / (initialVelocity + velocity) + initialTime;\n\n    float dCurv = pathSampleCurvRates[i] * velocity;\n    if (dCurv > dCurvatureMax) return -1.0;\n\n    float cost = sampleDynamicCost(pathSample, time, velocity, acceleration);\n    if (cost < 0.0) return cost;\n\n    averageDynamicCost += cost;\n    if (averageDynamicCost / numSamples_f >= abandonThreshold) return -1.0;\n\n    s += ds;\n  }\n\n  averageDynamicCost /= numSamples_f;\n\n  // Apply speeding penality if any velocity along the trajectory is over the speed limit\n  averageDynamicCost += step(speedLimit, maxVelocity) * speedLimitPenalty;\n\n  // Apply hard acceleration/deceleration penalties if the acceleration/deceleration exceeds the soft limits\n  averageDynamicCost += step(accelerationProfiles[2] + 0.0001, acceleration) * hardAccelerationPenalty;\n  averageDynamicCost += (1.0 - step(accelerationProfiles[3], acceleration)) * hardDecelerationPenalty;\n\n  // Penalize lateral acceleration\n  averageDynamicCost += step(softLateralAccelerationLimit, maxLateralAcceleration) * softLateralAccelerationPenalty;\n  averageDynamicCost += linearLateralAccelerationPenalty * maxLateralAcceleration;\n\n  return averageDynamicCost;\n}\n\nvec3 calculateAVT(int accelerationIndex, float initialVelocity, float initialTime, float pathLength) {\n  float initialVelocitySq = initialVelocity * initialVelocity;\n  float acceleration = calculateAcceleration(accelerationIndex, initialVelocitySq, pathLength);\n\n  float finalVelocitySq = 2.0 * acceleration * pathLength + initialVelocitySq;\n  float finalVelocity = max(smallV, sqrt(max(0.0, finalVelocitySq)));\n\n  float finalTime = initialTime;\n\n  if (acceleration == 0.0) {\n    finalTime += pathLength / finalVelocity;\n  } else if (finalVelocitySq <= 0.0) { // Calculate final time if the vehicle stops before the end of the trajectory\n    float distanceLeft = pathLength - (smallV * smallV - initialVelocitySq) / (2.0 * acceleration);\n    finalTime += (finalVelocity - initialVelocity) / acceleration + distanceLeft / smallV;\n  } else {\n    finalTime += 2.0 * pathLength / (finalVelocity + initialVelocity);\n  }\n\n  return vec3(acceleration, finalVelocity, finalTime);\n}\n\n`;\n\nconst SAMPLE_CUBIC_PATH_FN = `\n\nint sampleCubicPath(vec4 start, vec4 end, vec4 cubicPathParams) {\n  float p0 = start.w;\n  float p1 = cubicPathParams.x;\n  float p2 = cubicPathParams.y;\n  float p3 = end.w;\n  float sG = cubicPathParams.z;\n\n  if (sG <= 0.0) return 0;\n\n  int numSamples = int(ceil(sG / pathSamplingStep)) + 1;\n\n  float sG_2 = sG * sG;\n  float sG_3 = sG_2 * sG;\n\n  float a = p0;\n  float b = (-5.5 * p0 + 9.0 * p1 - 4.5 * p2 + p3) / sG;\n  float c = (9.0 * p0 - 22.5 * p1 + 18.0 * p2 - 4.5 * p3) / sG_2;\n  float d = (-4.5 * (p0 - 3.0 * p1 + 3.0 * p2 - p3)) / sG_3;\n\n  pathSamples[0] = start;\n\n  float ds = sG / float(numSamples - 1);\n  float s = ds;\n  vec2 dxy = vec2(0);\n  vec2 prevCosSin = vec2(cos(start.z), sin(start.z));\n\n  for (int i = 1; i < numSamples; i++) {\n    float rot = (((d * s / 4.0 + c / 3.0) * s + b / 2.0) * s + a) * s + start.z;\n    float curv = ((d * s + c) * s + b) * s + a;\n\n    vec2 cosSin = vec2(cos(rot), sin(rot));\n    dxy = dxy * vec2(float(i - 1) / float(i)) + (cosSin + prevCosSin) / vec2(2 * i);\n\n    pathSamples[i] = vec4(dxy * vec2(s) + start.xy, rot, curv);\n    pathSampleCurvRates[i] = b + s * (2.0 * c + 3.0 * d * s);\n\n    s += ds;\n    prevCosSin = cosSin;\n  }\n\n  return numSamples;\n}\n\n`;\n\nconst SAMPLE_QUINTIC_PATH_FN = `\n\nint sampleQuinticPath(vec4 start, vec4 end, vec4 quinticPathParams) {\n  float p0 = start.w;\n  float p1 = dCurvVehicle;\n  float p2 = ddCurvVehicle;\n  float p3 = quinticPathParams.x;\n  float p4 = quinticPathParams.y;\n  float p5 = end.w;\n  float sG = quinticPathParams.z;\n\n  if (sG <= 0.0) return 0;\n\n  int numSamples = int(ceil(sG / pathSamplingStep)) + 1;\n\n  float sG_2 = sG * sG;\n  float sG_3 = sG_2 * sG;\n\n  float a = p0;\n  float b = p1;\n  float c = p2 / 2.0;\n  float d = (-71.875 * p0 + 81.0 * p3 - 10.125 * p4 + p5 - 21.25 * p1 * sG - 2.75 * p2 * sG_2) / sG_3;\n  float e = (166.5 * p0 - 202.5 * p3 + 40.5 * p4 - 4.5 * p5 + 45.0 * p1 * sG + 4.5 * p2 * sG_2) / (sG_2 * sG_2);\n  float f = (-95.625 * p0 + 121.5 * p3 - 30.375 * p4 + 4.5 * p5 - 24.75 * p1 * sG - 2.25 * p2 * sG_2) / (sG_2 * sG_3);\n\n  pathSamples[0] = start;\n\n  float ds = sG / float(numSamples - 1);\n  float s = ds;\n  vec2 dxy = vec2(0);\n  vec2 prevCosSin = vec2(cos(start.z), sin(start.z));\n\n  for (int i = 1; i < numSamples; i++) {\n    float rot = (((((f * s / 6.0 + e / 5.0) * s + d / 4.0) * s + c / 3.0) * s + b / 2.0) * s + a) * s + start.z;\n    float curv = ((((f * s + e) * s + d) * s + c) * s + b) * s + a;\n\n    vec2 cosSin = vec2(cos(rot), sin(rot));\n    dxy = dxy * vec2(float(i - 1) / float(i)) + (cosSin + prevCosSin) / vec2(2 * i);\n\n    pathSamples[i] = vec4(dxy * vec2(s) + start.xy, rot, curv);\n    pathSampleCurvRates[i] = b + s * (2.0 * c + s * (3.0 * d + s * (4.0 * e + 5.0 * f * s)));\n\n    s += ds;\n    prevCosSin = cosSin;\n  }\n\n  return numSamples;\n}\n\n`;\n\nconst NUM_ACCELERATION_PROFILES = 8;\nconst NUM_VELOCITY_RANGES = 4;\nconst NUM_TIME_RANGES = 2;\n\nconst SHARED_UNIFORMS = {\n  xyslMap: { type: 'outputTexture' },\n  slObstacleGrid: { type: 'outputTexture', name: 'slObstacleGridDilated' },\n  slDynamicObstacleGrid: { type: 'outputTexture', name: 'slDynamicObstacleGrid', textureType: '2DArray' },\n  accelerationProfiles: { type: 'float', length: 5 },\n  finalVelocityProfiles: { type: 'float', length: 3 },\n  xyCenterPoint: { type: 'vec2' },\n  xyGridCellSize: { type: 'float' },\n  slCenterPoint: { type: 'vec2' },\n  slGridCellSize: { type: 'float'},\n  laneCenterLatitude: { type: 'float'},\n  laneShoulderLatitude: { type: 'float'},\n  laneCostSlope: { type: 'float'},\n  lanePreference: { type: 'float' },\n  lanePreferenceDiscount: { type: 'float' },\n  obstacleHazardCost: { type: 'float' },\n  speedLimit: { type: 'float' },\n  speedLimitPenalty: { type: 'float' },\n  hardAccelerationPenalty: { type: 'float' },\n  hardDecelerationPenalty: { type: 'float' },\n  softLateralAccelerationLimit: { type: 'float' },\n  softLateralAccelerationPenalty: { type: 'float' },\n  linearLateralAccelerationPenalty: { type: 'float' },\n  dCurvatureMax: { type: 'float' },\n  pathSamplingStep: { type: 'float' },\n  rearAxleToCenter: { type: 'float' },\n  dynamicFrameTime: { type: 'float' }\n};\n\nfunction buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime) {\n  return {\n    accelerationProfiles: [3.5, -6.5, 2.0, -3.0, 0],\n    finalVelocityProfiles: [0.999 * config.speedLimit, 1.0, 0.01],\n    xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y],\n    xyGridCellSize: config.xyGridCellSize,\n    slCenterPoint: [slCenterPoint.x, slCenterPoint.y],\n    slGridCellSize: config.slGridCellSize,\n    laneCenterLatitude: config.laneCenterLatitude,\n    laneShoulderLatitude: config.laneShoulderLatitude,\n    laneCostSlope: config.laneCostSlope,\n    lanePreference: config.lanePreference,\n    lanePreferenceDiscount: config.lanePreferenceDiscount,\n    obstacleHazardCost: config.obstacleHazardCost,\n    speedLimit: config.speedLimit,\n    speedLimitPenalty: config.speedLimitPenalty,\n    hardAccelerationPenalty: config.hardAccelerationPenalty,\n    hardDecelerationPenalty: config.hardDecelerationPenalty,\n    softLateralAccelerationLimit: config.softLateralAccelerationLimit,\n    softLateralAccelerationPenalty: config.softLateralAccelerationPenalty,\n    linearLateralAccelerationPenalty: config.linearLateralAccelerationPenalty,\n    dCurvatureMax: config.dCurvatureMax,\n    pathSamplingStep: config.pathSamplingStep,\n    rearAxleToCenter: config.rearAxleToCenter,\n    dynamicFrameTime: dynamicFrameTime\n  };\n}\n\nexport {\n  SHARED_SHADER,\n  SAMPLE_CUBIC_PATH_FN,\n  SAMPLE_QUINTIC_PATH_FN,\n\n  NUM_ACCELERATION_PROFILES,\n  NUM_VELOCITY_RANGES,\n  NUM_TIME_RANGES,\n\n  SHARED_UNIFORMS,\n  buildUniformValues\n}\n","import { SHARED_SHADER, SAMPLE_CUBIC_PATH_FN, SAMPLE_QUINTIC_PATH_FN, NUM_ACCELERATION_PROFILES, SHARED_UNIFORMS, buildUniformValues } from \"./graphSearchShared.js\";\n\nfunction fromVehiclePathCostsKernel(pathType) {\n  return SHARED_SHADER + (pathType == 'cubic' ? SAMPLE_CUBIC_PATH_FN : SAMPLE_QUINTIC_PATH_FN) +\n\n`\n\n/* Calculate cost of a {cubic|quintic} path from vehicle to (stationConnectivity * numLatitudes * numAccelerations) nodes\n *   width: numLatitudes\n *   height: station * numAccelerations\n */\nvec4 kernel() {\n  ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize));\n\n  int latitude = indexes.x;\n  int station = indexes.y / numAccelerations;\n  int accelerationIndex = int(mod(float(indexes.y), float(numAccelerations)));\n\n  vec4 pathStart = vec4(0, 0, 0, curvVehicle);\n  vec4 pathEnd = texelFetch(lattice, ivec2(latitude, station), 0);\n\n  vec4 pathParams = texelFetch(pathsFromVehicle, ivec2(latitude, station), 0);\n\n  // If the path didn't converge\n  if (pathParams.w == 0.0) return vec4(-1);\n\n  int numSamples = ${pathType == 'cubic' ? 'sampleCubicPath' : 'sampleQuinticPath'}(pathStart, pathEnd, pathParams);\n  float pathLength = pathParams.z;\n\n  if (numSamples < 2) return vec4(-1);\n\n  float averageStaticCost = calculateAverageStaticCost(numSamples);\n  if (averageStaticCost < 0.0) return vec4(-1);\n\n  int slIndex = station * kernelSize.x + latitude;\n  float hysteresisAdjustment = (slIndex == firstLatticePoint || slIndex == secondLatticePoint) ?  0.0 : hysteresisDiscount;\n  averageStaticCost += hysteresisAdjustment;\n\n  vec3 avt = calculateAVT(accelerationIndex, velocityVehicle, 0.0, pathLength);\n  float acceleration = avt.x;\n  float finalVelocity = avt.y;\n  float finalTime = avt.z;\n\n  float averageDynamicCost = calculateAverageDynamicCost(numSamples, pathLength, 0.0, velocityVehicle, acceleration, 1.0 / 0.0);\n  if (averageDynamicCost < 0.0) return vec4(-1);\n\n  averageDynamicCost += accelerationChangePenalty;\n\n  // The cost of a trajectory is the average sample cost scaled by the path length\n  float totalCost = (averageStaticCost + averageDynamicCost + ${pathType == 'cubic' ? '(cubicPathPenalty * velocityVehicle * velocityVehicle)' : '0.0'}) * pathLength;\n  ${pathType != 'cubic' ? 'totalCost = -1.0;' : ''}\n\n  return vec4(totalCost, finalVelocity, finalTime, ${pathType == 'cubic' ? '-2' : '-1'});\n}\n\n`;\n}\n\nexport default {\n  setUp() {\n    return [\n      {\n        kernel: fromVehiclePathCostsKernel('cubic'),\n        output: { name: 'cubicPathFromVehicleCosts' },\n        uniforms: Object.assign({}, SHARED_UNIFORMS, {\n          lattice: { type: 'sharedTexture' },\n          pathsFromVehicle: { type: 'outputTexture', name: 'cubicPathsFromVehicle' },\n          firstLatticePoint: { type: 'int' },\n          secondLatticePoint: { type: 'int' },\n          velocityVehicle: { type: 'float' },\n          curvVehicle: { type: 'float' },\n          numAccelerations: { type: 'int' },\n          cubicPathPenalty: { type: 'float' },\n          hysteresisDiscount: { type: 'float' },\n          accelerationChangePenalty: { type: 'float' }\n        })\n      },\n      {\n        kernel: fromVehiclePathCostsKernel('quintic'),\n        output: { name: 'quinticPathFromVehicleCosts' },\n        uniforms: Object.assign({}, SHARED_UNIFORMS, {\n          lattice: { type: 'sharedTexture' },\n          pathsFromVehicle: { type: 'outputTexture', name: 'quinticPathsFromVehicle' },\n          firstLatticePoint: { type: 'int' },\n          secondLatticePoint: { type: 'int' },\n          velocityVehicle: { type: 'float' },\n          curvVehicle: { type: 'float' },\n          dCurvVehicle: { type: 'float' },\n          ddCurvVehicle: { type: 'float' },\n          numAccelerations: { type: 'int' },\n          hysteresisDiscount: { type: 'float' },\n          accelerationChangePenalty: { type: 'float' }\n        })\n      }\n    ];\n  },\n\n  update(config, pose, xyCenterPoint, slCenterPoint, firstLatticePoint, secondLatticePoint, dynamicFrameTime) {\n    return [\n      {\n        width: config.lattice.numLatitudes,\n        height: config.lattice.stationConnectivity * NUM_ACCELERATION_PROFILES,\n        uniforms: Object.assign({}, buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime), {\n          firstLatticePoint: firstLatticePoint,\n          secondLatticePoint: secondLatticePoint,\n          velocityVehicle: pose.velocity,\n          curvVehicle: pose.curv,\n          numAccelerations: NUM_ACCELERATION_PROFILES,\n          cubicPathPenalty: config.cubicPathPenalty,\n          hysteresisDiscount: config.hysteresisDiscount,\n          accelerationChangePenalty: config.accelerationChangePenalty\n        })\n      },\n      {\n        width: config.lattice.numLatitudes,\n        height: config.lattice.stationConnectivity * NUM_ACCELERATION_PROFILES,\n        uniforms: Object.assign({}, buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime), {\n          firstLatticePoint: firstLatticePoint,\n          secondLatticePoint: secondLatticePoint,\n          velocityVehicle: pose.velocity,\n          curvVehicle: pose.curv,\n          dCurvVehicle: pose.dCurv,\n          ddCurvVehicle: pose.ddCurv,\n          numAccelerations: NUM_ACCELERATION_PROFILES,\n          hysteresisDiscount: config.hysteresisDiscount,\n          accelerationChangePenalty: config.accelerationChangePenalty\n        })\n      }\n    ];\n  }\n}\n","/* State Lattice Cost Map\n * \n * 5-dimensional node: station, latitude, acceleration profile, velocity, time\n *\n * A draw call per station s\n *   * Input to kernel: latitude l, acceleration profile a, velocity range v, time range t\n *   * Find all SL vertices that can connect to this node\n *   * For each of those vertices, check if any terminate in this specific velocity and time range\n *     * Based on initial velocity, initial time, and acceleration\n *     * Each connected SL vertex should have a * v * t nodes that could possibly terminate at this node\n *   * For all valid edges, find the one with the lowest cost\n *\n * Input:\n *   * 2D texture array cost map\n *     * Height: num of latitudes (~20)\n *     * Width: num of acceleration profiles * num of time ranges * num of velocity ranges (8 * 2 * 4 = ~64)\n *       * A flattened 3D array:\n *         d1: acceleration\n *         d2: velocity\n *         d3: time\n *     * Layer: num of stations (~10)\n *   \n * Output:\n *   * 2D texture slice of the next station in the input 2D texture array cost map\n *\n * Cost Map Elements:\n *   * Traversal cost so far\n *   * Ending velocity\n *   * Ending time\n *   * Index of parent node\n *\n * Since one cubic path can be shared between multiple trajectories, they need to be pre-optimized.\n *\n * Quintic Paths:\n *   Stations 0 through (numStations - 1) correspond to the stations on the lattice; however,\n *   a new station (station -1) will be used to signifiy the single vehicle pose node. Either\n *   a cubic path or quintic path can be used to connect this single node to the lattice\n *   (depending on vehicle velocity). At station -1, latitude 0 will correspond to a cubic path,\n *   and latitude 1 will correspond to a quintic path. All other latitudes will be skipped.\n */\n\nimport { SHARED_SHADER, SAMPLE_CUBIC_PATH_FN, SAMPLE_QUINTIC_PATH_FN, NUM_ACCELERATION_PROFILES, NUM_VELOCITY_RANGES, NUM_TIME_RANGES, SHARED_UNIFORMS, buildUniformValues } from \"./graphSearchShared.js\";\n\nconst SOLVE_STATION_KERNEL =\n  SHARED_SHADER +\n  SAMPLE_CUBIC_PATH_FN +\n  SAMPLE_QUINTIC_PATH_FN +\n\n`\n\nvec4 kernel() {\n  ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize));\n\n  int latitude = indexes.y;\n\n  int numPerTime = numAccelerations * numVelocities;\n  int timeIndex = indexes.x / numPerTime;\n  indexes.x -= timeIndex * numPerTime;\n  int velocityIndex = indexes.x / numAccelerations;\n  int accelerationIndex = int(mod(float(indexes.x), float(numAccelerations)));\n\n  int minLatitude = max(latitude - latitudeConnectivity / 2, 0);\n  int maxLatitude = min(latitude + latitudeConnectivity / 2, numLatitudes - 1);\n\n  int slIndex = station * numLatitudes + latitude;\n\n  vec4 pathEnd = texelFetch(lattice, ivec2(latitude, station), 0);\n\n  float minVelocity = velocityRanges[velocityIndex];\n  float maxVelocity = velocityRanges[velocityIndex + 1];\n\n  float minTime = timeRanges[timeIndex];\n  float maxTime = timeRanges[timeIndex + 1];\n\n  vec4 bestTrajectory = vec4(-1); // -1 means infinite cost\n  float bestTerminalCost = 1.0 / 0.0;\n\n  float hysteresisAdjustment = (slIndex == firstLatticePoint || slIndex == secondLatticePoint) ?  0.0 : hysteresisDiscount;\n\n  for (int prevStation = max(station - stationConnectivity, 0); prevStation < station; prevStation++) {\n    int stationConnectivityIndex = prevStation - station + stationConnectivity;\n\n    for (int prevLatitude = minLatitude; prevLatitude <= maxLatitude; prevLatitude++) {\n      int latitudeConnectivityIndex = prevLatitude - latitude + latitudeConnectivity / 2;\n      int connectivityIndex = stationConnectivityIndex * latitudeConnectivity + latitudeConnectivityIndex;\n\n      vec4 pathStart = texelFetch(lattice, ivec2(prevLatitude, prevStation), 0);\n      vec4 cubicPathParams = texelFetch(cubicPaths, ivec2(slIndex, connectivityIndex), 0);\n\n      // If the path didn't converge\n      if (cubicPathParams.w == 0.0) continue;\n\n      int numSamples = sampleCubicPath(pathStart, pathEnd, cubicPathParams);\n      float pathLength = cubicPathParams.z;\n\n      if (numSamples < 2) continue;\n\n      float averageStaticCost = calculateAverageStaticCost(numSamples);\n      if (averageStaticCost < 0.0) continue;\n\n      averageStaticCost += hysteresisAdjustment;\n\n      if (averageStaticCost * pathLength >= bestTerminalCost) continue;\n\n      for (int prevVelocity = 0; prevVelocity < numVelocities; prevVelocity++) {\n        for (int prevTime = 0; prevTime < numTimes; prevTime++) {\n          for (int prevAccel = 0; prevAccel < numAccelerations; prevAccel++) {\n            int avtIndex = prevTime * numPerTime + prevVelocity * numAccelerations + prevAccel;\n\n            // Cost table entry:\n            //   x: cost so far\n            //   y: end velocity\n            //   z: end time\n            //   w: parent index\n            vec4 costTableEntry = texelFetch(costTable, ivec3(avtIndex, prevLatitude, prevStation), 0);\n\n            // If cost entry is infinity\n            if (costTableEntry.x < 0.0 || averageStaticCost * pathLength + costTableEntry.x >= bestTerminalCost) continue;\n\n            vec3 avt = calculateAVT(accelerationIndex, costTableEntry.y, costTableEntry.z, pathLength);\n            float acceleration = avt.x;\n            float finalVelocity = avt.y;\n            float finalTime = avt.z;\n\n            if (averageStaticCost * pathLength + costTableEntry.x + extraTimePenalty * finalTime >= bestTerminalCost) continue;\n\n            // If the calculated final velocity does not match this fragment's velocity range, then skip this trajectory\n            if (finalVelocity < minVelocity || finalVelocity >= maxVelocity) continue;\n\n            // If the calculated final time does not match this fragment's time range, then skip this trajectory\n            if (finalTime < minTime || finalTime >= maxTime) continue;\n\n            float abandonThreshold = (bestTerminalCost - extraTimePenalty * finalTime - costTableEntry.x) / pathLength - averageStaticCost;\n            float averageDynamicCost = calculateAverageDynamicCost(numSamples, pathLength, costTableEntry.z, costTableEntry.y, acceleration, abandonThreshold);\n            if (averageDynamicCost < 0.0) continue;\n\n            if (accelerationIndex != prevAccel)\n              averageDynamicCost += accelerationChangePenalty;\n\n            // The cost of a trajectory is the average sample cost scaled by the path length\n            float totalCost = (averageStaticCost + averageDynamicCost) * pathLength + costTableEntry.x;\n\n            float terminalCost = totalCost + extraTimePenalty * finalTime;\n            if (terminalCost >= bestTerminalCost) continue;\n            bestTerminalCost = terminalCost;\n\n            int incomingIndex = avtIndex + numPerTime * numTimes * (prevLatitude + numLatitudes * prevStation);\n            bestTrajectory = vec4(totalCost, finalVelocity, finalTime, incomingIndex);\n          }\n        }\n      }\n    }\n  }\n\n  if (station < stationConnectivity) {\n    ivec2 slaIndex = ivec2(latitude, station * numAccelerations + accelerationIndex);\n\n    vec4 costTableEntry = texelFetch(cubicPathFromVehicleCosts, slaIndex, 0);\n    float terminalCost;\n\n    if (costTableEntry.x >= 0.0) {\n      terminalCost = costTableEntry.x + extraTimePenalty * costTableEntry.z;\n\n      if (terminalCost < bestTerminalCost) {\n        bestTerminalCost = terminalCost;\n        bestTrajectory = costTableEntry;\n      }\n    }\n\n    costTableEntry = texelFetch(quinticPathFromVehicleCosts, slaIndex, 0);\n\n    if (costTableEntry.x >= 0.0) {\n      terminalCost = costTableEntry.x + extraTimePenalty * costTableEntry.z;\n\n      if (terminalCost < bestTerminalCost) {\n        bestTerminalCost = terminalCost;\n        bestTrajectory = costTableEntry;\n      }\n    }\n  }\n\n  return bestTrajectory;\n}\n\n`;\n\nexport default {\n  setUp() {\n    return {\n      kernel: SOLVE_STATION_KERNEL,\n      output: { name: 'graphSearch' },\n      uniforms: Object.assign({}, SHARED_UNIFORMS, {\n        lattice: { type: 'sharedTexture' },\n        costTable: { type: 'sharedTexture', textureType: '2DArray' },\n        cubicPaths: { type: 'outputTexture' },\n        cubicPathFromVehicleCosts: { type: 'outputTexture' },\n        quinticPathFromVehicleCosts: { type: 'outputTexture' },\n        firstLatticePoint: { type: 'int' },\n        secondLatticePoint: { type: 'int' },\n        velocityVehicle: { type: 'float' },\n        curvVehicle: { type: 'float' },\n        dCurvVehicle: { type: 'float' },\n        ddCurvVehicle: { type: 'float' },\n        extraTimePenalty: { type: 'float' },\n        hysteresisDiscount: { type: 'float' },\n        accelerationChangePenalty: { type: 'float' },\n        numStations: { type: 'int' },\n        numLatitudes: { type: 'int' },\n        numAccelerations: { type: 'int' },\n        numVelocities: { type: 'int' },\n        numTimes: { type: 'int' },\n        stationConnectivity: { type: 'int' },\n        latitudeConnectivity: { type: 'int' },\n        velocityRanges: { type: 'float', length: NUM_VELOCITY_RANGES + 1 },\n        timeRanges: { type: 'float', length: NUM_TIME_RANGES + 1 },\n        station: { type: 'int' } // Updated in `drawProxy`\n      }),\n      drawProxy: (gpgpu, program, draw) => {\n        const width = NUM_ACCELERATION_PROFILES * NUM_VELOCITY_RANGES * NUM_TIME_RANGES;\n        const height = program.meta.lattice.numLatitudes;\n        const costTable = new Float32Array(width * height * program.meta.lattice.numStations * 4);\n\n        for (let s = 0; s < program.meta.lattice.numStations; s++) {\n          gpgpu.updateProgramUniforms(program, { station: s });\n          draw();\n\n          gpgpu.gl.readPixels(0, 0, width, height, gpgpu.gl.RGBA, gpgpu.gl.FLOAT, costTable, s * width * height * 4);\n\n          gpgpu.gl.bindTexture(gpgpu.gl.TEXTURE_2D_ARRAY, gpgpu.sharedTextures.costTable);\n          gpgpu.gl.copyTexSubImage3D(gpgpu.gl.TEXTURE_2D_ARRAY, 0, 0, 0, s, 0, 0, width, height);\n        }\n\n        gpgpu._graphSearchCostTable = costTable;\n      }\n    };\n  },\n\n  update(config, pose, xyCenterPoint, slCenterPoint, firstLatticePoint, secondLatticePoint, dynamicFrameTime) {\n    return {\n      width: NUM_ACCELERATION_PROFILES * NUM_VELOCITY_RANGES * NUM_TIME_RANGES,\n      height: config.lattice.numLatitudes,\n      meta: {\n        lattice: config.lattice\n      },\n      uniforms: Object.assign({}, buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime), {\n        firstLatticePoint: firstLatticePoint,\n        secondLatticePoint: secondLatticePoint,\n        velocityVehicle: pose.velocity,\n        curvVehicle: pose.curv,\n        dCurvVehicle: pose.dCurv,\n        ddCurvVehicle: pose.ddCurv,\n        extraTimePenalty: config.extraTimePenalty,\n        hysteresisDiscount: config.hysteresisDiscount,\n        accelerationChangePenalty: config.accelerationChangePenalty,\n        numStations: config.lattice.numStations,\n        numLatitudes: config.lattice.numLatitudes,\n        numAccelerations: NUM_ACCELERATION_PROFILES,\n        numVelocities: NUM_VELOCITY_RANGES,\n        numTimes: NUM_TIME_RANGES,\n        stationConnectivity: config.lattice.stationConnectivity,\n        latitudeConnectivity: config.lattice.latitudeConnectivity,\n        velocityRanges: [0, config.speedLimit / 3, config.speedLimit * 2 / 3, config.speedLimit, 1000000],\n        timeRanges: [0, 10, 1000000]\n      })\n    };\n  }\n}\n","const XY_OBSTACLE_COST_KERNEL = `\n\nvec4 kernel() {\n  vec2 xy = (kernelPosition - 0.5) * vec2(kernelSize) * vec2(xyGridCellSize) + xyCenterPoint;\n\n  vec2 xyTexCoords = (xy - xyCenterPoint) / vec2(textureSize(xyslMap, 0)) / vec2(xyGridCellSize) + 0.5;\n  vec2 sl = texture(xyslMap, xyTexCoords).xy;\n\n  vec2 slTexCoords = (sl - slCenterPoint) / vec2(textureSize(slObstacleGrid, 0)) / vec2(slGridCellSize) + 0.5;\n  return texture(slObstacleGrid, slTexCoords);\n}\n\n`;\n\n// Build XY obstacle costs using XYSL map\nexport default {\n  setUp() {\n    return {\n      kernel: XY_OBSTACLE_COST_KERNEL,\n      output: { name: 'xyObstacleCostGrid', read: true },\n      uniforms: {\n        xyslMap: { type: 'outputTexture' },\n        slObstacleGrid: { type: 'outputTexture', name: 'slObstacleGridDilated' },\n        xyCenterPoint: { type: 'vec2' },\n        xyGridCellSize: { type: 'float'},\n        slCenterPoint: { type: 'vec2' },\n        slGridCellSize: { type: 'float'}\n      }\n    };\n  },\n\n  update(config, xyWidth, xyHeight, xyCenterPoint, slCenterPoint) {\n    return {\n      width: xyWidth,\n      height: xyHeight,\n      uniforms: {\n        xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y],\n        xyGridCellSize: config.xyGridCellSize,\n        slCenterPoint: [slCenterPoint.x, slCenterPoint.y],\n        slGridCellSize: config.slGridCellSize\n      }\n    };\n  }\n}\n","import GPGPU from \"../../GPGPU.js\";\nimport Car from \"../../physics/Car.js\";\nimport CubicPath from \"./CubicPath.js\";\nimport QuinticPath from \"./QuinticPath.js\";\nimport xyObstacleGrid from \"./gpgpu-programs/xyObstacleGrid.js\";\nimport slObstacleGrid from \"./gpgpu-programs/slObstacleGrid.js\";\nimport slObstacleGridDilation from \"./gpgpu-programs/slObstacleGridDilation.js\";\nimport slDynamicObstacleGrid from \"./gpgpu-programs/slDynamicObstacleGrid.js\";\nimport xyslMap from \"./gpgpu-programs/xyslMap.js\";\nimport optimizeCubicPaths from \"./gpgpu-programs/optimizeCubicPaths.js\";\nimport optimizeQuinticPaths from \"./gpgpu-programs/optimizeQuinticPaths.js\";\nimport pathFromVehicleCosts from \"./gpgpu-programs/pathFromVehicleCosts.js\";\nimport graphSearch from \"./gpgpu-programs/graphSearch.js\";\nimport xyObstacleCostGrid from \"./gpgpu-programs/xyObstacleCostGrid.js\";\n\nconst NUM_ACCELERATION_PROFILES = 8;\nconst NUM_VELOCITY_RANGES = 4;\nconst NUM_TIME_RANGES = 2;\n\n/* Obstacle cost map:\n *\n * 1. Rasterize triangles from polygonal obstacles into XY-space occupancy grid\n * 2. Convert occupancy grid to SL-space\n *    * Width is spatial horizon of the state lattice\n *    * Height is lane width\n *    * Resolution should be higher than XY-grid\n *    * Get XY position from centerline texture\n *    * Lookup XY in XY occupancy grid (nearest)\n * 3. Dilate SL-space grid using two passes (along station, then along latitude)\n *    * collision area: half car size + 0.3m\n *    * high cost area: 1 meter\n * 4. Convert back to XY-space using XYSL map\n */\n\nexport default class PathPlanner {\n  constructor() {\n    this.previousStartStation = null;\n    this.previousFirstLatticePoint = -1;\n    this.previousSecondLatticePoint = -1;\n    this.previousFirstAcceleration = -1;\n    this.previousSecondLatticePoint = -1;\n\n    let start = performance.now();\n    const programs = [\n      xyObstacleGrid.setUp(),\n      slObstacleGrid.setUp(),\n      ...slObstacleGridDilation.setUp(),\n      slDynamicObstacleGrid.setUp(),\n      xyslMap.setUp(),\n      ...optimizeCubicPaths.setUp(),\n      optimizeQuinticPaths.setUp(),\n      ...pathFromVehicleCosts.setUp(),\n      graphSearch.setUp(),\n    ].map(p => Object.assign({}, p, { width: 1, height: 1 }));\n\n    this.gpgpu = new GPGPU(programs);\n  }\n\n  reset() {\n    this.previousStartStation = null;\n    this.previousFirstLatticePoint = -1;\n    this.previousSecondLatticePoint = -1;\n    this.previousFirstAcceleration = -1;\n    this.previousSecondLatticePoint = -1;\n  }\n\n  plan(vehiclePose, vehicleStation, lanePath, startTime, staticObstacles, dynamicObstacles) {\n    const latticeStationInterval = this._latticeStationInterval();\n\n    const centerlineRaw = lanePath.sampleStations(vehicleStation, Math.ceil((this.config.spatialHorizon + latticeStationInterval) / this.config.centerlineStationInterval) + 1, this.config.centerlineStationInterval);\n\n    // Transform all centerline points into vehicle frame\n    const vehicleXform = vehicleTransform(vehiclePose);\n    const centerline = centerlineRaw.map(c => { return { pos: c.pos.clone().applyMatrix3(vehicleXform), rot: c.rot - vehiclePose.rot, curv: c.curv } });\n\n    const centerlineData = new Float32Array(centerline.length * 3);\n    const maxPoint = new THREE.Vector2(0, 0);\n    const minPoint = new THREE.Vector2(0, 0);\n\n    for (let i = 0; i < centerline.length; i++) {\n      const sample = centerline[i];\n      const pos = sample.pos;\n      centerlineData[i * 3 + 0] = pos.x;\n      centerlineData[i * 3 + 1] = pos.y;\n      centerlineData[i * 3 + 2] = sample.rot;\n\n      maxPoint.max(pos);\n      minPoint.min(pos);\n    }\n\n    const diff = maxPoint.clone().sub(minPoint);\n    const xyCenterPoint = minPoint.clone().add(maxPoint).divideScalar(2);\n\n    // Sizes of the xy grids (in pixels, not meters)\n    const xyWidth = Math.ceil((diff.x + this.config.gridMargin * 2) / this.config.xyGridCellSize);\n    const xyHeight = Math.ceil((diff.y + this.config.gridMargin * 2) / this.config.xyGridCellSize);\n\n    const stationWidth = this.config.spatialHorizon + latticeStationInterval * 2;\n    const slCenterPoint = new THREE.Vector2(this.config.spatialHorizon / 2, 0);\n\n    // Sizes of the sl grids (in pixels, not meters)\n    const slWidth = Math.ceil(stationWidth / this.config.slGridCellSize);\n    const slHeight = Math.ceil((this.config.roadWidth + this.config.gridMargin * 2) / this.config.slGridCellSize);\n\n    let startStation;\n\n    if (this.previousStartStation === null || vehicleStation + latticeStationInterval / 2 > this.previousStartStation) {\n      startStation = (this.previousStartStation === null ? vehicleStation : this.previousStartStation) + latticeStationInterval;\n      this.previousStartStation = startStation;\n      this.previousFirstLatticePoint -= this.config.lattice.numLatitudes;\n      this.previousSecondLatticePoint -= this.config.lattice.numLatitudes;\n    } else {\n      startStation = this.previousStartStation;\n    }\n\n    const lattice = this._buildLattice(lanePath, startStation, vehiclePose.rot, vehicleXform);\n\n    const temporalHorizon = this.config.spatialHorizon / this.config.speedLimit;\n    const dynamicFrameTime = temporalHorizon / this.config.numDynamicFrames;\n\n    for (const [i, p] of [\n      xyObstacleGrid.update(this.config, xyWidth, xyHeight, xyCenterPoint, vehicleXform, staticObstacles),\n      slObstacleGrid.update(this.config, slWidth, slHeight, slCenterPoint, xyCenterPoint),\n      ...slObstacleGridDilation.update(this.config, slWidth, slHeight),\n      slDynamicObstacleGrid.update(this.config, slWidth, slHeight, slCenterPoint, vehicleStation, startTime, dynamicFrameTime, dynamicObstacles),\n      xyslMap.update(this.config, xyWidth, xyHeight, xyCenterPoint),\n      ...optimizeCubicPaths.update(this.config, vehiclePose),\n      optimizeQuinticPaths.update(this.config, vehiclePose),\n      ...pathFromVehicleCosts.update(this.config, vehiclePose, xyCenterPoint, slCenterPoint, this.previousFirstLatticePoint, this.previousSecondLatticePoint, dynamicFrameTime),\n      graphSearch.update(this.config, vehiclePose, xyCenterPoint, slCenterPoint, this.previousFirstLatticePoint, this.previousSecondLatticePoint, dynamicFrameTime)\n    ].entries()) {\n      this.gpgpu.updateProgram(i, p);\n    }\n\n    this.gpgpu.updateSharedTextures({\n      centerline: {\n        width: centerline.length,\n        height: 1,\n        channels: 3,\n        filter: 'linear',\n        data: centerlineData\n      },\n      costTable: {\n        width: NUM_ACCELERATION_PROFILES * NUM_VELOCITY_RANGES * NUM_TIME_RANGES,\n        height: this.config.lattice.numLatitudes,\n        depth: this.config.lattice.numStations,\n        channels: 4,\n        textureType: '2DArray'\n      },\n      lattice: {\n        width: this.config.lattice.numLatitudes,\n        height: this.config.lattice.numStations,\n        channels: 4,\n        data: lattice\n      }\n    });\n\n    this.gpgpu._graphSearchCostTable = null;\n    this.gpgpu._dynamicObstacleGrid = null;\n\n    let start = performance.now();\n    const outputs = this.gpgpu.run();\n    const costTable = this.gpgpu._graphSearchCostTable;\n    const cubicPathParams = outputs[6];\n    const cubicPathFromVehicleParams = outputs[7];\n    const quinticPathFromVehicleParams = outputs[8];\n\n    let bestEntry = [Number.POSITIVE_INFINITY];\n    let bestEntryIndex;\n    const numEntries = costTable.length / 4;\n\n    for (let i = 0; i < numEntries; i++) {\n      const entryUnpacked = this._unpackCostTableIndex(i);\n      const entry = [\n        costTable[i * 4],\n        costTable[i * 4 + 1],\n        costTable[i * 4 + 2],\n        costTable[i * 4 + 3]\n      ];\n\n      if (entry[0] < 0) continue;\n\n      entry[0] += this._terminalCost(entryUnpacked, entry);\n\n      if (entry[0] < bestEntry[0]) {\n        bestEntryIndex = i;\n        bestEntry = entry;\n      }\n    }\n\n    const inverseVehicleXform = (new THREE.Matrix3()).getInverse(vehicleXform);\n    let bestTrajectory = null;\n    let fromVehicleSegment = null;\n    let fromVehicleParams = null;\n    let firstLatticePoint = -1;\n    let firstAcceleration = -1;\n    let secondLatticePoint = -1;\n    let secondAcceleration = -1;\n\n    if (isFinite(bestEntry[0])) {\n      [bestTrajectory, fromVehicleSegment, fromVehicleParams, firstLatticePoint, firstAcceleration, secondLatticePoint, secondAcceleration] = this._reconstructTrajectory(\n        bestEntryIndex,\n        costTable,\n        cubicPathParams,\n        cubicPathFromVehicleParams,\n        quinticPathFromVehicleParams,\n        vehiclePose,\n        lattice\n      );\n\n      fromVehicleSegment.forEach(p => {\n        p.pos = p.pos.applyMatrix3(inverseVehicleXform);\n        p.rot += vehiclePose.rot;\n      });\n\n      bestTrajectory.forEach(p => {\n        p.pos = p.pos.applyMatrix3(inverseVehicleXform);\n        p.rot += vehiclePose.rot;\n      });\n    }\n\n    this.previousFirstLatticePoint = firstLatticePoint;\n    this.previousFirstAcceleration = firstAcceleration;\n    this.previousSecondLatticePoint = secondLatticePoint;\n    this.previousSecondAcceleration = secondAcceleration;\n\n    return {\n      path: bestTrajectory,\n      fromVehicleSegment: fromVehicleSegment,\n      fromVehicleParams: fromVehicleParams,\n      latticeStartStation: this.previousStartStation,\n      dynamicObstacleGrid: { data: this.gpgpu._dynamicObstacleGrid, width: slWidth, height: slHeight }\n    };\n  }\n\n  _buildLattice(lanePath, startStation, vehicleRot, vehicleXform) {\n    const centerline = lanePath.sampleStations(startStation, this.config.lattice.numStations, this._latticeStationInterval());\n    const offset = Math.floor(this.config.lattice.numLatitudes / 2);\n    const lattice = new Float32Array(this.config.lattice.numStations * this.config.lattice.numLatitudes * 4);\n    let index = 0;\n\n    for (let s = 0; s < centerline.length; s++) {\n      const sample = centerline[s];\n\n      for (let l = 0; l < this.config.lattice.numLatitudes; l++) {\n        const latitude = (l - offset) / offset * this.config.roadWidth / 2;\n        const rot = sample.rot - vehicleRot;\n        const pos = THREE.Vector2.fromAngle(rot + Math.PI / 2).multiplyScalar(latitude).add(sample.pos.clone().applyMatrix3(vehicleXform));\n        const curv = sample.curv == 0 ? 0 : 1 / (1 / sample.curv - latitude);\n\n        lattice[index++] = pos.x;\n        lattice[index++] = pos.y;\n        lattice[index++] = rot;\n        lattice[index++] = curv;\n      }\n    }\n\n    return lattice;\n  }\n\n  _latticeStationInterval() {\n    return this.config.spatialHorizon / this.config.lattice.numStations;\n  }\n\n  _terminalCost([stationIndex, latitudeIndex, timeIndex, velocityIndex, accelerationIndex], [cost, finalVelocity, finalTime, incomingIndex]) {\n    // Only consider vertices that reach the end of the spatial or temporal horizon\n    if (stationIndex != this.config.lattice.numStations - 1 && finalVelocity > 0.05)\n      return Number.POSITIVE_INFINITY;\n\n    const station = (this.config.spatialHorizon / this.config.lattice.numStations) * (stationIndex + 1);\n\n    return station * -this.config.stationReachDiscount + finalTime * this.config.extraTimePenalty;\n  }\n\n  _unpackCostTableIndex(index) {\n    if (index < 0) return [-1, index + 2, null, null, null];\n\n    const numPerTime = NUM_ACCELERATION_PROFILES * NUM_VELOCITY_RANGES;\n    const numPerLatitude = numPerTime * NUM_TIME_RANGES;\n    const numPerStation = this.config.lattice.numLatitudes * numPerLatitude;\n\n    const stationIndex = Math.floor(index / numPerStation);\n    index -= stationIndex * numPerStation;\n\n    const latitudeIndex = Math.floor(index / numPerLatitude);\n    index -= latitudeIndex * numPerLatitude;\n\n    const timeIndex = Math.floor(index / numPerTime);\n    index -= timeIndex * numPerTime;\n\n    const velocityIndex = Math.floor(index / NUM_ACCELERATION_PROFILES);\n    const accelerationIndex = index % NUM_ACCELERATION_PROFILES;\n\n    return [stationIndex, latitudeIndex, timeIndex, velocityIndex, accelerationIndex];\n  }\n\n  _reconstructTrajectory(index, costTable, cubicPathParams, cubicPathFromVehicleParams, quinticPathFromVehicleParams, vehiclePose, lattice) {\n    let unpacked = this._unpackCostTableIndex(index);\n    unpacked.push(costTable[index * 4 + 1]);\n    const nodes = [unpacked];\n\n    let count = 0;\n    while (unpacked[0] >= 0 && count++ < 100) {\n      index = costTable[index * 4 + 3];\n      unpacked = this._unpackCostTableIndex(index);\n\n      const finalVelocity = unpacked[0] >= 0 ? costTable[index * 4 + 1] : vehiclePose.velocity;\n      unpacked.push(finalVelocity);\n\n      nodes.unshift(unpacked);\n    }\n    if (count >= 100) throw new Error('Infinite loop encountered while reconstructing trajectory.');\n\n    const points = [];\n    let fromVehicleSegment = [];\n    let fromVehicleParams = null;\n\n    for (let i = 0; i < nodes.length - 1; i++) {\n      const [prevStation, prevLatitude, _pt, _pv, _pa, prevVelocity] = nodes[i];\n      const [station, latitude, _t, _v, _a, velocity] = nodes[i + 1];\n\n      let length;\n      let pathBuilder;\n\n      if (prevStation < 0) {\n        const start = {\n          pos: new THREE.Vector2(0, 0),\n          rot: 0,\n          curv: vehiclePose.curv\n        };\n\n        const endIndex = (station * this.config.lattice.numLatitudes + latitude) * 4;\n        const end = {\n          pos: new THREE.Vector2(lattice[endIndex], lattice[endIndex + 1]),\n          rot: lattice[endIndex + 2],\n          curv: lattice[endIndex + 3]\n        };\n\n        if (prevLatitude == 0) { // Cubic path from vehicle to lattice node\n          length = cubicPathFromVehicleParams[endIndex + 2];\n\n          const params = {\n            p1: cubicPathFromVehicleParams[endIndex],\n            p2: cubicPathFromVehicleParams[endIndex + 1],\n            sG: length\n          };\n\n          pathBuilder = new CubicPath(start, end, params);\n\n          fromVehicleParams = { type: 'cubic', params: params };\n        } else { // Quintic path from vehicle to lattice node\n          length = quinticPathFromVehicleParams[endIndex + 2];\n\n          const params = {\n            p3: quinticPathFromVehicleParams[endIndex],\n            p4: quinticPathFromVehicleParams[endIndex + 1],\n            sG: length\n          };\n\n          pathBuilder = new QuinticPath(start, end, params);\n\n          fromVehicleParams = { type: 'quintic', params: params };\n        }\n      } else {\n        const startIndex = (prevStation * this.config.lattice.numLatitudes + prevLatitude) * 4;\n        const endIndex = (station * this.config.lattice.numLatitudes + latitude) * 4;\n\n        const start = {\n          pos: new THREE.Vector2(lattice[startIndex], lattice[startIndex + 1]),\n          rot: lattice[startIndex + 2],\n          curv: lattice[startIndex + 3]\n        };\n\n        const end = {\n          pos: new THREE.Vector2(lattice[endIndex], lattice[endIndex + 1]),\n          rot: lattice[endIndex + 2],\n          curv: lattice[endIndex + 3]\n        };\n\n        const slIndex = station * this.config.lattice.numLatitudes + latitude;\n        const connectivityIndex = (prevStation - station + this.config.lattice.stationConnectivity) * this.config.lattice.latitudeConnectivity + prevLatitude - latitude + Math.floor(this.config.lattice.latitudeConnectivity / 2);\n        const cubicPathIndex = (connectivityIndex * this.config.lattice.numStations * this.config.lattice.numLatitudes + slIndex) * 4;\n\n        length = cubicPathParams[cubicPathIndex + 2];\n\n        pathBuilder = new CubicPath(start, end, {\n          p1: cubicPathParams[cubicPathIndex],\n          p2: cubicPathParams[cubicPathIndex + 1],\n          sG: length\n        });\n      }\n\n      const path = pathBuilder.buildPath(Math.ceil(length / 0.25));\n\n      const prevVelocitySq = prevVelocity * prevVelocity;\n      const accel = (velocity * velocity - prevVelocitySq) / 2 / length;\n      const ds = length / (path.length - 1);\n      let s = 0;\n\n      for (let p = 0; p < path.length; p++) {\n        path[p].velocity = Math.sqrt(2 * accel * s + prevVelocitySq);\n        path[p].acceleration = accel;\n        s += ds;\n      }\n\n      if (prevStation < 0) {\n        fromVehicleSegment = path;\n      } else {\n        if (i > 0) path.shift();\n        points.push(...path);\n      }\n    }\n\n    let firstLatticePoint = null\n    let firstAcceleration = null;\n    let secondLatticePoint = null;\n    let secondAcceleration = null;\n\n    if (nodes.length >= 2) {\n      firstLatticePoint = nodes[1][0] * this.config.lattice.numLatitudes + nodes[1][1];\n      firstAcceleration = nodes[1][4];\n    }\n\n    if (nodes.length >= 3) {\n      secondLatticePoint = nodes[2][0] * this.config.lattice.numLatitudes + nodes[2][1];\n      secondAcceleration = nodes[2][4];\n    }\n\n    return [points, fromVehicleSegment, fromVehicleParams, firstLatticePoint, firstAcceleration, secondLatticePoint, secondAcceleration];\n  }\n}\n\nfunction vehicleTransform({ pos, rot }) {\n  const translate = new THREE.Matrix3();\n  translate.set(\n    1, 0, -pos.x,\n    0, 1, -pos.y,\n    0, 0, 1\n  );\n\n  const cosRot = Math.cos(rot);\n  const sinRot = Math.sin(rot);\n\n  const rotate = new THREE.Matrix3();\n  rotate.set(\n    cosRot, sinRot, 0,\n    -sinRot, cosRot, 0,\n    0, 0, 1\n  );\n\n  return rotate.multiply(translate);\n}\n\nfunction obstacleTransform(vehicleXform, xyCenterPoint, width, height) {\n  const translate = new THREE.Matrix3();\n  translate.set(\n    1, 0, -xyCenterPoint.x,\n    0, 1, -xyCenterPoint.y,\n    0, 0, 1\n  );\n\n  const scale = new THREE.Matrix3();\n  scale.set(\n    2 / width, 0, 0,\n    0, 2 / height, 0,\n    0, 0, 1\n  );\n\n  return scale.multiply(translate).multiply(vehicleXform);\n}\n","export default class MovingAverage {\n  constructor(maxSamples) {\n    this.samples = new Array(maxSamples);\n    this.numSamples = 0;\n    this.nextIndex = 0;\n    this.average = null;\n  }\n\n  addSample(sample) {\n    this.samples[this.nextIndex++] = sample;\n    this.nextIndex = this.nextIndex % this.samples.length;\n    this.numSamples = Math.min(this.numSamples + 1, this.samples.length);\n\n    const k = 2 / (this.numSamples + 1);\n    let curr = this.nextIndex % this.numSamples;\n    let newAverage = this.samples[curr];\n\n    for (let i = 1; i < this.numSamples; i++) {\n      curr = (curr + 1) % this.numSamples;\n      newAverage = this.samples[curr] * k + newAverage * (1 - k);\n    }\n\n    this.average = newAverage;\n  }\n}\n","import Physics from \"./physics/Physics.js\";\nimport Path from \"./autonomy/Path.js\";\nimport CubicPath from \"./autonomy/path-planning/CubicPath.js\";\nimport AutonomousController from \"./autonomy/control/AutonomousController.js\";\nimport FollowController from \"./autonomy/control/FollowController.js\";\nimport ManualController from \"./autonomy/control/ManualController.js\";\nimport MapObject from \"./objects/MapObject.js\";\nimport CarObject from \"./objects/CarObject.js\";\nimport StaticObstacleObject from \"./objects/StaticObstacleObject.js\";\nimport DynamicObstacleObject from \"./objects/DynamicObstacleObject.js\";\nimport Editor from \"./simulator/Editor.js\";\nimport OrbitControls from \"./simulator/OrbitControls.js\";\nimport TopDownCameraControls from \"./simulator/TopDownCameraControls.js\";\nimport Dashboard from \"./simulator/Dashboard.js\";\nimport GPGPU from \"./GPGPU.js\";\nimport RoadLattice from \"./autonomy/path-planning/RoadLattice.js\";\nimport PathPlanner from \"./autonomy/path-planning/PathPlanner.js\";\nimport StaticObstacle from \"./autonomy/StaticObstacle.js\";\nimport DynamicObstacle from \"./autonomy/DynamicObstacle.js\";\nimport MovingAverage from \"./autonomy/MovingAverage.js\";\nimport PathPlannerConfigEditor from \"./simulator/PathPlannerConfigEditor.js\";\nimport Car from \"./physics/Car.js\";\n\nimport Utils from \"script-loader!./Utils.js\";\n\nconst WELCOME_MODAL_KEY = 'dash_WelcomeModal';\n\nimport EXAMPLES from \"./simulator/examples.js\";\n\nexport default class Simulator {\n  constructor(domElement) {\n    this.pathPlannerWorker = new Worker(URL.createObjectURL(new Blob([`(${dash_initPathPlannerWorker.toString()})()`], { type: 'text/javascript' })));\n    this.pathPlannerWorker.onmessage = this.receivePlannedPath.bind(this);\n    this.pathPlannerConfigEditor = new PathPlannerConfigEditor();\n\n    this.physics = new Physics();\n    this.car = this.physics.createCar();\n\n    this.renderer = new THREE.WebGLRenderer({ antialias: true });\n    this.renderer.setPixelRatio(window.devicePixelRatio);\n    this.renderer.setSize(domElement.clientWidth, domElement.clientHeight);\n    this.renderer.shadowMap.enabled = true;\n    domElement.appendChild(this.renderer.domElement);\n\n    this.lastPlanParams = null;\n    this.renderer.context.canvas.addEventListener('webglcontextlost', event => {\n      console.log('Simulator: webgl context lost');\n      console.log(event);\n      console.log(this.lastPlanParams);\n    });\n\n    this._setUpCameras(this.renderer.domElement);\n\n    this.scene = new THREE.Scene();\n    this.sceneFog = null;//new THREE.FogExp2(0x111111, 0.0025);\n    this.scene.fog = this.sceneFog;\n    this.scene.background = new THREE.Color(0x111111);\n\n    this.editor = new Editor(this.renderer.domElement, this.editorCamera, this.scene);\n\n    const geolocation = null;//[33.523900, -111.908756];\n    const map = new MapObject(geolocation);\n    this.scene.add(map);\n\n    this.carObject = new CarObject(this.car);\n    this.scene.add(this.carObject);\n\n    this.scene.add(new THREE.AmbientLight(0x666666));\n    const light = new THREE.DirectionalLight(0xffffff, 0.75);\n    light.position.set(1, 1, 1).normalize();\n    this.scene.add(light);\n\n    this.manualCarController = new ManualController();\n    this.autonomousCarController = null;\n\n    this.dashboard = new Dashboard(this.car);\n\n    this.plannerReady = false;\n    this.plannerRunning = false;\n    this.plannerReset = false;\n    this.carStation = null;\n    this.plannedPathGroup = new THREE.Group();\n    this.scene.add(this.plannedPathGroup);\n\n    this.staticObstaclesGroup = new THREE.Group();\n    this.scene.add(this.staticObstaclesGroup);\n    this.dynamicObstaclesGroup = new THREE.Group();\n    this.scene.add(this.dynamicObstaclesGroup);\n\n    this.paused = false;\n    this.prevTimestamp = null;\n    this.frameCounter = 0;\n    this.fpsTime = 0;\n    this.fps = 0;\n    this.simulatedTime = 0;\n    this.lastPlanRequestTime = null;\n    this.latestPlanTimestamp = null;\n    this.averagePlanTime = new MovingAverage(20);\n\n    window.addEventListener('resize', e => {\n      this._updateCameraAspects(domElement.clientWidth / domElement.clientHeight);\n      this.renderer.setSize(domElement.clientWidth, domElement.clientHeight);\n    });\n\n    window.addEventListener('hashchange', e => {\n      if (window.location.hash.startsWith('#/s/'))\n        window.location.reload();\n    });\n\n    this.manualModeButton = document.getElementById('mode-manual');\n    this.manualModeButton.addEventListener('click', this.enableManualMode.bind(this));\n    this.autonomousModeButton = document.getElementById('mode-autonomous');\n    this.autonomousModeButton.addEventListener('click', this.enableAutonomousMode.bind(this));\n\n    document.getElementById('editor-enable').addEventListener('click', this.enableEditor.bind(this));\n    document.getElementById('editor-finalize').addEventListener('click', this.finalizeEditor.bind(this));\n    document.getElementById('simulator-load').addEventListener('click', this.loadScenario.bind(this));\n\n    this.scenarioPlayButton = document.getElementById('scenario-play');\n    this.scenarioPlayButton.addEventListener('click', this.playScenario.bind(this));\n    this.scenarioPauseButton = document.getElementById('scenario-pause');\n    this.scenarioPauseButton.addEventListener('click', this.pauseScenario.bind(this));\n    for (const btn of document.querySelectorAll('[id=scenario-restart]')) {\n      btn.addEventListener('click', this.restartScenario.bind(this));\n    }\n\n    this.welcomeModal = document.getElementById('welcome-modal');\n    document.getElementById('show-welcome-modal').addEventListener('click', e => this.welcomeModal.classList.add('is-active'));\n\n    // if (window.localStorage.getItem(WELCOME_MODAL_KEY) !== 'hide') {\n    //  this.welcomeModal.classList.add('is-active');\n    // }\n\n    this.collisionMessage = document.getElementById('collision-message');\n    this.successMessage = document.getElementById('success-message');\n    // If the click was outside the div, hide it\n    document.addEventListener(\"click\", this.setHideCollisionMessageOnClickOutside.bind(this));\n\n    document.getElementById('welcome-modal-background').addEventListener('click', this.hideWelcomeModal.bind(this));\n    document.getElementById('welcome-modal-close').addEventListener('click', this.hideWelcomeModal.bind(this));\n\n    document.getElementById('welcome-modal-examples').addEventListener('click', e => {\n      this.welcomeModal.classList.remove('is-active');\n      this.loadScenario();\n      this.editor.scenarioManager.switchTab(this.editor.scenarioManager.examplesTab);\n    });\n\n    document.getElementById('welcome-modal-create').addEventListener('click', e => {\n      this.welcomeModal.classList.remove('is-active');\n      this.enableEditor();\n    });\n\n    this.simModeBoxes = Array.prototype.slice.call(document.getElementsByClassName('sim-mode-box'), 0);\n    this.editModeBoxes = Array.prototype.slice.call(document.getElementsByClassName('edit-mode-box'), 0);\n\n    this.fpsBox = document.getElementById('fps');\n\n    this.enableManualMode();\n    this.changeCamera('chase');\n\n    this.aroundAnchorIndex = null;\n    this.staticObstacles = [];\n    this.dynamicObstacles = [];\n\n    this._checkHashScenario();\n\n    requestAnimationFrame(this.step.bind(this));\n\n    this.editor.scenarioManager._loadScenario(EXAMPLES[2]);\n    this.finalizeEditor();\n  }\n\n  toss() {\n    const pose = this.car.pose;\n    const rotVec = THREE.Vector2.fromAngle(pose.rot);\n    const pos = rotVec.clone().multiplyScalar(50).add(new THREE.Vector2(rotVec.y, rotVec.x)).add(pose.pos);\n    const obstacle = new StaticObstacle(pos, 0, 1.0, 1.0);\n\n    const obsGeom = new THREE.PlaneGeometry(obstacle.width, obstacle.height);\n    const obsMat = new THREE.MeshBasicMaterial({ color: 0x0000ff, depthTest: false, transparent: true, opacity: 0.5 });\n    const obsObj = new THREE.Mesh(obsGeom, obsMat);\n    obsObj.rotation.x = -Math.PI / 2;\n    obsObj.rotation.z = -obstacle.rot;\n    obsObj.position.set(obstacle.pos.x, 0, obstacle.pos.y);\n    this.scene.add(obsObj);\n\n    this.staticObstacles.push(obstacle);\n  }\n\n  _checkHashScenario() {\n    if (!window.location.hash.startsWith('#/s/')) return;\n\n    const [_hash, _s, code] = window.location.hash.split('/');\n\n    try {\n      const json = JSON.parse(atob(decodeURIComponent(code)));\n      this.editor.loadJSON(json);\n      this.finalizeEditor();\n      this.welcomeModal.classList.remove('is-active');\n      window.location.hash = '';\n    } catch (e) {\n      console.log('Error importing scenario code:');\n      console.log(code);\n      console.log(e);\n    }\n  }\n\n  _setUpCameras(domElement) {\n    this.chaseCamera = new THREE.PerspectiveCamera(55, domElement.clientWidth / domElement.clientHeight, 1, 10000);\n    this.chaseCameraControls = new OrbitControls(this.chaseCamera, domElement);\n    this.chaseCameraControls.minDistance = 4;\n    this.chaseCameraControls.maxDistance = 5000;\n    this.chaseCameraControls.maxPolarAngle = Math.PI / 2.02;\n    this.chaseCameraControls.enablePan = false;\n    this.chaseCameraControls.enabled = false;\n    this._resetChaseCamera();\n\n    this.freeCamera = new THREE.PerspectiveCamera(55, domElement.clientWidth / domElement.clientHeight, 1, 10000);\n    this.freeCameraControls = new OrbitControls(this.freeCamera, domElement);\n    this.freeCameraControls.minDistance = 5;\n    this.freeCameraControls.maxDistance = 5000;\n    this.freeCameraControls.maxPolarAngle = Math.PI / 2.02;\n    this.freeCameraControls.enabled = true;\n    this._resetFreeCamera();\n\n    this.topDownCamera = new THREE.PerspectiveCamera(55, domElement.clientWidth / domElement.clientHeight, 1, 10000);\n    this.topDownCamera.position.set(0, 50, 0);\n    this.topDownCamera.lookAt(0, 0, 0);\n    this.topDownControls = new TopDownCameraControls(domElement, this.topDownCamera);\n    this.topDownControls.enabled = false;\n    this.topDownControls.minAltitude = 5;\n    this.topDownControls.maxAltitude = 10000;\n\n    this.editorCamera = new THREE.PerspectiveCamera(45, domElement.clientWidth / domElement.clientHeight, 1, 10000);\n    this.editorCamera.layers.enable(2);\n    this.editorCamera.position.set(0, 200, 0);\n    this.editorCamera.lookAt(0, 0, 0);\n    this.editorCameraControls = new TopDownCameraControls(domElement, this.editorCamera);\n    this.editorCameraControls.enabled = false;\n    this.editorCameraControls.enablePanning = true;\n    this.editorCameraControls.minAltitude = 10;\n    this.editorCameraControls.maxAltitude = 10000;\n\n    this.cameraButtons = {};\n\n    ['free', 'chase', 'topDown'].forEach(c => {\n      const cameraButton = document.getElementById(`camera-${c}`);\n      cameraButton.addEventListener('click', () => this.changeCamera(c));\n      this.cameraButtons[c] = cameraButton;\n    });\n\n    this.switchTo2DButton = document.getElementById('camera-2D');\n    this.switchTo2DButton.addEventListener('click', this.switchTo2D.bind(this));\n    this.switchTo3DButton = document.getElementById('camera-3D');\n    this.switchTo3DButton.addEventListener('click', this.switchTo3D.bind(this));\n\n    this.switchTo3D();\n  }\n\n  _resetFreeCamera() {\n    this.freeCameraControls.position0.copy(this.chaseCamera.position);\n    const carPosition = this.car.position;\n    this.freeCameraControls.target0.set(carPosition.x, 0, carPosition.y);\n    this.freeCameraControls.reset();\n  }\n\n  _resetChaseCamera() {\n    const pos = this.car.position;\n    const dirVector = THREE.Vector2.fromAngle(this.car.rotation).multiplyScalar(-20);\n    this.chaseCamera.position.set(pos.x + dirVector.x, 8, pos.y + dirVector.y);\n    this.chaseCamera.lookAt(pos.x, 0, pos.y);\n  }\n\n  _resetTopDownCamera() {\n    const carPosition = this.car.position;\n    this.topDownCamera.position.set(carPosition.x, 50, carPosition.y);\n    this.topDownCamera.rotation.z = -this.car.rotation - Math.PI / 2\n  }\n\n  _updateCameraAspects(aspect) {\n    this.freeCamera.aspect = aspect;\n    this.freeCamera.updateProjectionMatrix();\n    this.chaseCamera.aspect = aspect;\n    this.chaseCamera.updateProjectionMatrix();\n    this.topDownCamera.aspect = aspect;\n    this.topDownCamera.updateProjectionMatrix();\n    this.editorCamera.aspect = aspect;\n    this.editorCamera.updateProjectionMatrix();\n  }\n\n  enableEditor() {\n    this.editor.enabled = true;\n    this.plannerRunning = false;\n\n    this.previousCamera = this.camera;\n    this.camera = this.editorCamera;\n    this.editorCameraControls.enabled = true;\n    this.chaseCameraControls.enabled = false;\n    this.topDownControls.enabled = false;\n    this.freeCameraControls.enabled = false;\n\n    this.scene.fog = null;\n    this.carObject.visible = false;\n    if (this.plannedPathGroup) this.plannedPathGroup.visible = false;\n    this.staticObstaclesGroup.visible = false;\n    this.dynamicObstaclesGroup.visible = false;\n\n    this.simModeBoxes.forEach(el => el.classList.add('is-hidden'));\n    this.editModeBoxes.forEach(el => el.classList.remove('is-hidden'));\n\n    this.showPlannerUnavailable(false);\n  }\n\n  finalizeEditor(replaceCamera = true) {\n    this.editor.enabled = false;\n    this.editorCameraControls.enabled = false;\n\n    this.latestPlanTimestamp = null;\n    this.prevTimestamp = null;\n\n    this.scene.fog = this.sceneFog;\n    this.carObject.visible = true;\n\n    this.simModeBoxes.forEach(el => el.classList.remove('is-hidden'));\n    this.editModeBoxes.forEach(el => el.classList.add('is-hidden'));\n\n    if (this.editor.lanePath.anchors.length > 1) {\n      const centerline = this.editor.lanePath.centerline;\n      const pos = centerline[0].clone();\n      const dir = centerline[1].clone().sub(centerline[0]);\n      const rot = Math.atan2(dir.y, dir.x);\n      const perpindicular = rot + Math.PI / 2 * (Math.sign(this.editor.lanePreference) || 0);\n      const latitude = this.pathPlannerConfigEditor.config.roadWidth / 4;\n\n      this.car.setPose(pos.x + Math.cos(perpindicular) * latitude, pos.y + Math.sin(perpindicular) * latitude, rot);\n      this.car.velocity = this.editor.initialSpeed;\n\n      this.dynamicObstacles = this.editor.dynamicObstacles;\n\n      // The `false` value means the controller is waiting to be created after the first planning cycle.\n      // This signals the simulator to use neutral controls instead of the hard brake used for the `null` value.\n      this.autonomousCarController = false;\n      this.enableAutonomousMode();\n\n      if (!this.plannerRunning) {\n        this.plannerReady = true;\n        this.plannerRunning = true;\n      }\n      this.plannerReset = true;\n      this.simulatedTime = 0;\n      this.carStation = 0;\n      this.aroundAnchorIndex = null;\n\n      this.pauseScenario();\n      this.autonomousModeButton.classList.add('is-loading');\n      this.waitingForFirstPlan = true;\n    } else {\n      this.dynamicObstacles = [];\n    }\n\n    this.staticObstacles = this.editor.staticObstacles;\n    this.recreateStaticObstacleObjects();\n    this.recreateDynamicObstacleObjects();\n\n    this.dashboard.update({ steer: 0, brake: 0, gas: 0 }, this.car.velocity, null, null, 0, this.averagePlanTime.average);\n\n    if (replaceCamera) {\n      this.camera = this.previousCamera;\n\n      if (this.previousCamera == this.chaseCamera)\n        this.chaseCameraControls.enabled = true;\n      else if (this.previousCamera == this.topDownCamera)\n        this.topDownControls.enabled = true;\n      else if (this.previousCamera == this.freeCamera)\n        this.freeCameraControls.enabled = true;\n      else\n        this.changeCamera('chase');\n    }\n\n    this._resetFreeCamera();\n    this._resetChaseCamera();\n    this._resetTopDownCamera();\n  }\n\n  recreateStaticObstacleObjects() {\n    this.scene.remove(this.staticObstaclesGroup);\n    this.staticObstaclesGroup = new THREE.Group();\n    this.scene.add(this.staticObstaclesGroup);\n\n    this.staticObstacles.forEach(o => {\n      const obstacleObject = new StaticObstacleObject(o);\n      this.staticObstaclesGroup.add(obstacleObject);\n    });\n  }\n\n  recreateDynamicObstacleObjects() {\n    this.scene.remove(this.dynamicObstaclesGroup);\n    this.dynamicObstaclesGroup = new THREE.Group();\n    this.scene.add(this.dynamicObstaclesGroup);\n\n    this.dynamicObstacles.forEach(o => {\n      const obstacleObject = new DynamicObstacleObject(o, this.editor.lanePath);\n      this.dynamicObstaclesGroup.add(obstacleObject);\n    });\n\n    this.updateDynamicObjects(this.simulatedTime);\n  }\n\n  updateDynamicObjects(time) {\n    this.dynamicObstaclesGroup.children.forEach(o => o.update(time));\n  }\n\n  playScenario() {\n    this.paused = false;\n    this.scenarioPlayButton.classList.add('is-hidden');\n    this.scenarioPauseButton.classList.remove('is-hidden');\n    this.showPlannerUnavailable(false);\n  }\n\n  pauseScenario() {\n    this.paused = true;\n    this.scenarioPlayButton.classList.remove('is-hidden');\n    this.scenarioPauseButton.classList.add('is-hidden');\n\n    this.showPlannerUnavailable(false);\n    this.waitingForFirstPlan = false;\n  }\n\n  restartScenario() {\n    if (this.editor.enabled) return;\n\n    if (this.plannedPathGroup)\n      this.scene.remove(this.plannedPathGroup);\n\n    this.finalizeEditor(false);\n\n    this.successMessage.classList.remove('is-active');\n    this.collisionMessage.classList.remove('is-active');\n\n    this.latestPlanTimestamp = null;\n    this.showPlannerUnavailable(false);\n  }\n\n  loadScenario() {\n    if (this.editor.enabled) return;\n\n    this.editor.scenarioManager.showModal(this.finalizeEditor.bind(this));\n  }\n\n  enableManualMode() {\n    this.manualModeButton.classList.remove('is-outlined');\n    this.manualModeButton.classList.add('is-selected');\n    this.autonomousModeButton.classList.add('is-outlined', 'is-inverted');\n    this.autonomousModeButton.classList.remove('is-selected', 'is-link');\n\n    this.carControllerMode = 'manual';\n\n    this.showPlannerUnavailable(false);\n  }\n\n  enableAutonomousMode() {\n    this.autonomousModeButton.classList.remove('is-outlined', 'is-inverted');\n    this.autonomousModeButton.classList.add('is-selected', 'is-link');\n    this.manualModeButton.classList.add('is-outlined');\n    this.manualModeButton.classList.remove('is-selected');\n\n    this.carControllerMode = 'autonomous';\n  }\n\n  changeCamera(mode) {\n    if (this.editor.enabled) return;\n\n    switch (mode) {\n      case \"free\":\n        this.chaseCameraControls.enabled = false;\n        this.topDownControls.enabled = false;\n        this.freeCameraControls.enabled = true;\n\n        if (this.camera == this.freeCamera)\n          this._resetFreeCamera();\n        else\n          this.camera = this.freeCamera;\n\n        break;\n      case \"chase\":\n        this.freeCameraControls.enabled = false;\n        this.topDownControls.enabled = false;\n        this.chaseCameraControls.enabled = true;\n\n        if (this.camera == this.chaseCamera)\n          this._resetChaseCamera();\n        else\n          this.camera = this.chaseCamera;\n\n        break;\n      case \"topDown\":\n        this.freeCameraControls.enabled = false;\n        this.chaseCameraControls.enabled = false;\n        this.topDownControls.enabled = true;\n\n        if (this.camera == this.topDownCamera)\n          this._resetTopDownCamera();\n        else\n          this.camera = this.topDownCamera;\n\n        break;\n      default:\n        console.log(`Unknown camera mode: ${mode}`);\n        return;\n    }\n\n    for (const c in this.cameraButtons) {\n      const classes = this.cameraButtons[c].classList;\n      if (c == mode) {\n        classes.remove('is-outlined');\n        classes.add('is-selected');\n      } else {\n        classes.add('is-outlined');\n        classes.remove('is-selected');\n      }\n    }\n  }\n\n  switchTo2D() {\n    this.switchTo2DButton.classList.remove('is-outlined');\n    this.switchTo2DButton.classList.add('is-selected');\n    this.switchTo3DButton.classList.add('is-outlined');\n    this.switchTo3DButton.classList.remove('is-selected');\n\n    this.chaseCamera.layers.enable(2);\n    this.topDownCamera.layers.enable(2);\n    this.freeCamera.layers.enable(2);\n    this.chaseCamera.layers.disable(3);\n    this.topDownCamera.layers.disable(3);\n    this.freeCamera.layers.disable(3);\n  }\n\n  switchTo3D() {\n    this.switchTo3DButton.classList.remove('is-outlined');\n    this.switchTo3DButton.classList.add('is-selected');\n    this.switchTo2DButton.classList.add('is-outlined');\n    this.switchTo2DButton.classList.remove('is-selected');\n\n    this.chaseCamera.layers.enable(3);\n    this.topDownCamera.layers.enable(3);\n    this.freeCamera.layers.enable(3);\n    this.chaseCamera.layers.disable(2);\n    this.topDownCamera.layers.disable(2);\n    this.freeCamera.layers.disable(2);\n  }\n\n  hideWelcomeModal() {\n    this.welcomeModal.classList.remove('is-active');\n    window.localStorage.setItem(WELCOME_MODAL_KEY, 'hide');\n  }\n\n  showPlannerUnavailable(show) {\n    const message = document.getElementById(\"planner-unavailable-message\");\n    if (show) {\n      message.classList.add('is-active');\n      this.autonomousModeButton.classList.add('is-loading');\n    } else {\n      message.classList.remove('is-active');\n      this.autonomousModeButton.classList.remove('is-loading');\n    }\n  }\n\n  setHideCollisionMessageOnClickOutside() {\n    if (!this.collisionMessage.contains(event.target)) {\n      this.collisionMessage.classList.remove('is-active');\n    }\n    if (!this.successMessage.contains(event.target)) {\n      this.successMessage.classList.remove('is-active');\n    }\n  }\n\n  startPlanner(pose, station) {\n    this.plannerReady = false;\n    this.lastPlanRequestTime = performance.now();\n\n    // In order to create a stable trajectory between successive planning\n    // cycles, we must compensate for the latency between when a planning cycle\n    // starts and when it ends. The average planning time is used to forward\n    // simulate the vehicle to the pose it is expected to have when the\n    // planning actually finishes.\n\n    let predictedPose = pose;\n    let predictedStation = station;\n    let startTime = this.simulatedTime;\n\n    if (!this.plannerReset && !this.paused && this.autonomousCarController && this.carControllerMode == 'autonomous') {\n      const latency = this.averagePlanTime.average;\n      predictedPose = this.autonomousCarController.predictPoseAfterTime(pose, latency);\n      predictedStation = this.editor.lanePath.stationLatitudeFromPosition(predictedPose.pos, this.aroundAnchorIndex)[0];\n      startTime += latency;\n    }\n\n    const reset = this.plannerReset;\n    this.plannerReset = false;\n\n    this.lastPlanParams =  {\n      type: 'plan',\n      config: Object.assign({}, this.pathPlannerConfigEditor.config, { speedLimit: this.editor.speedLimit, lanePreference: this.editor.lanePreference }),\n      vehiclePose: predictedPose,\n      vehicleStation: predictedStation,\n      lanePath: this.editor.lanePath,\n      startTime: startTime,\n      staticObstacles: this.staticObstacles,\n      dynamicObstacles: this.dynamicObstacles.filter(o => o.positionAtTime(startTime).x >= 0),\n      reset: reset\n    };\n\n    this.pathPlannerWorker.postMessage(this.lastPlanParams);\n  }\n\n  receivePlannedPath(event) {\n    if (event.data.error) {\n      if (event.data.error === \"planner_unavailable\" && !this.paused) {\n        this.showPlannerUnavailable(true);\n      }\n      //document.getElementById('planner-error').classList.remove('is-hidden')\n      return;\n    }\n\n    this.showPlannerUnavailable(false);\n\n    this.latestPlanTimestamp = performance.now();\n\n    if (this.waitingForFirstPlan && !this.plannerReset) {\n      this.waitingForFirstPlan = false;\n      this.autonomousModeButton.classList.remove('is-loading');\n      this.playScenario();\n    }\n\n    if (this.editor.enabled) return;\n\n    const { fromVehicleParams, vehiclePose, vehicleStation, latticeStartStation, config, dynamicObstacleGrid } = event.data;\n    let { path, fromVehicleSegment } = event.data;\n\n    const planningDuration = Math.min((this.latestPlanTimestamp - this.lastPlanRequestTime) / 1000, 0.3);\n    this.averagePlanTime.addSample(planningDuration);\n    this.plannerReady = true;\n\n    if (this.plannerReset) return;\n\n    if (this.plannedPathGroup)\n      this.scene.remove(this.plannedPathGroup);\n    this.plannedPathGroup = new THREE.Group();\n    this.scene.add(this.plannedPathGroup);\n\n    const circleGeom = new THREE.CircleGeometry(0.1, 32);\n    const circleMat = new THREE.MeshBasicMaterial({ color: 0x00ff80, transparent: true, opacity: 0.7 });\n\n    if (latticeStartStation) {\n      const lattice = new RoadLattice(this.editor.lanePath, latticeStartStation, config);\n      lattice.lattice.forEach(cells => {\n        cells.forEach(c => {\n          const circle = new THREE.Mesh(circleGeom, circleMat);\n          circle.position.set(c.pos.x, 0, c.pos.y);\n          circle.rotation.x = -Math.PI / 2;\n          this.plannedPathGroup.add(circle);\n        });\n      });\n    }\n\n    // TODO: clear this up or just remove it\n    if (false && dynamicObstacleGrid) {\n      const dynamicGridTex = new THREE.DataTexture(dynamicObstacleGrid.data, dynamicObstacleGrid.width, dynamicObstacleGrid.height, THREE.RGBAFormat, THREE.FloatType);\n      dynamicGridTex.flipY = true;\n      dynamicGridTex.needsUpdate = true;\n\n      const [gridStart] = this.editor.lanePath.sampleStations(vehicleStation, 1, 0);\n      if (gridStart) {\n        const dynamicGridGeom = new THREE.PlaneGeometry(dynamicObstacleGrid.width * config.slGridCellSize, dynamicObstacleGrid.height * config.slGridCellSize);\n        const dynamicGridMat = new THREE.MeshBasicMaterial({ map: dynamicGridTex, depthTest: false, transparent: true, opacity: 0.5 });\n        const dynamicGridObj = new THREE.Mesh(dynamicGridGeom, dynamicGridMat);\n        dynamicGridObj.rotation.x = -Math.PI / 2;\n        dynamicGridObj.rotation.z = -gridStart.rot;\n        const offset = THREE.Vector2.fromAngle(gridStart.rot).multiplyScalar(dynamicObstacleGrid.width * config.slGridCellSize / 2 - config.spatialHorizon / config.lattice.numStations);\n        dynamicGridObj.position.set(gridStart.pos.x + offset.x, 0, gridStart.pos.y + offset.y);\n\n        this.plannedPathGroup.add(dynamicGridObj);\n      }\n    }\n\n    if (path === null) {\n      this.autonomousCarController = null;\n      return;\n    }\n\n    if (fromVehicleParams.type == 'cubic') {\n      const start = this.car.pose;\n      const end = fromVehicleSegment[fromVehicleSegment.length - 1];\n\n      const pathBuilder = new CubicPath(start, end, fromVehicleParams.params);\n\n      if (pathBuilder.optimize()) {\n        fromVehicleSegment = pathBuilder.buildPath(Math.ceil(pathBuilder.params.sG / 0.25));\n\n        const prevVelocitySq = this.car.velocity * this.car.velocity;\n        const accel = (end.velocity * end.velocity - prevVelocitySq) / 2 / pathBuilder.params.sG;\n        const ds = pathBuilder.params.sG / (fromVehicleSegment.length - 1);\n        let s = 0;\n\n        for (let p = 0; p < fromVehicleSegment.length; p++) {\n          fromVehicleSegment[p].velocity = Math.sqrt(2 * accel * s + prevVelocitySq);\n          fromVehicleSegment[p].acceleration = accel;\n          s += ds;\n        }\n      }\n    }\n\n    if (fromVehicleSegment.length > 0) {\n      path = fromVehicleSegment.concat(path);\n    }\n\n    path.forEach(p => Object.setPrototypeOf(p.pos, THREE.Vector2.prototype));\n    const followPath = new Path(path);\n\n    if (this.autonomousCarController)\n      this.autonomousCarController.replacePath(followPath);\n    else\n      this.autonomousCarController = new FollowController(followPath, this.car);\n\n    const pathGeometry = new THREE.Geometry();\n    pathGeometry.setFromPoints(path.map(p => new THREE.Vector3(p.pos.x, 0, p.pos.y)));\n    const pathLine = new MeshLine();\n    pathLine.setGeometry(pathGeometry);\n\n    const color = fromVehicleParams.type == 'cubic' ? new THREE.Color(0xff8800) : new THREE.Color(0xffff40);\n    const pathObject = new THREE.Mesh(\n      pathLine.geometry,\n      new MeshLineMaterial({\n        color: color,\n        lineWidth: 0.15,\n        resolution: new THREE.Vector2(this.renderer.domElement.clientWidth, this.renderer.domElement.clientHeight)\n      })\n    );\n    pathObject.renderOrder = 1;\n    this.plannedPathGroup.add(pathObject);\n  }\n\n  _hasCarStaticObstacleCollision(carRectangle) {\n    for (const obstacle of this.staticObstacles) {\n      const obstacleRectangle = {\n        x: obstacle.pos.x,\n        y: obstacle.pos.y,\n        width: obstacle.width,\n        height: obstacle.height,\n        angle: obstacle.rot,\n      };\n      if (areRectanglesColliding(carRectangle, obstacleRectangle)) {\n        return true;\n      }\n    }\n  }\n\n  _hasCarDynamicObstacleCollision(carRectangle) {\n    for (const obstacle of this.dynamicObstaclesGroup.children) {\n      const positoin_at_time = obstacle.position\n      const obstacleRectangle = {\n        x: positoin_at_time.x,\n        y: positoin_at_time.z,\n        width: obstacle.size.w + 0.4,  // 30 cm is collision buffer\n        height: obstacle.size.h + 0.4,\n        angle: obstacle.rotation.y,\n      };\n      if (areRectanglesColliding(carRectangle, obstacleRectangle)) {\n        return true;\n      }\n    }\n  }\n\n  _hasCarOutOfRoadCollision(carRectangle) {\n    for (const left_boundary of this.editor.lanePath.leftBoundaries) {\n      if (checkRectanglePolylineIntersection(carRectangle, left_boundary)) {\n        return true;\n      }\n    }\n\n    for (const right_boundary of this.editor.lanePath.rightBoundaries) {\n      if (checkRectanglePolylineIntersection(carRectangle, right_boundary)) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  hasAnyCollisions() {\n    const carRectangle = {\n      x: this.car.position.x,\n      y: this.car.position.y,\n      height: Car.HALF_CAR_WIDTH * 2,\n      width: Car.HALF_CAR_LENGTH * 2,\n      angle: this.car.pose.rot,\n    };\n\n    if (this._hasCarStaticObstacleCollision(carRectangle)) {\n      return \"Collision with static object\";\n    }\n    if (this._hasCarDynamicObstacleCollision(carRectangle)) {\n      return \"Collision with bot\";\n    }\n    if (this._hasCarOutOfRoadCollision(carRectangle)) {\n      return \"Out of road\";\n    }\n\n    return null;\n  }\n\n  checkScenarioCompletion() {\n    return this.carStation >= this.editor.lanePath.arcLength - 5.0;\n  }\n\n  step(timestamp) {\n    if (this.prevTimestamp == null) {\n      this.prevTimestamp = timestamp;\n      requestAnimationFrame(this.step.bind(this));\n      return;\n    }\n\n    // plan is outdated, should pause simulation\n    const planWaitingThreshold = 0.3;  // path expected to be updated once in 300ms\n    const timeSinceLastPlanUpdate =\n      this.latestPlanTimestamp != null ? (performance.now() - this.latestPlanTimestamp) / 1000.0 : 0;  // in ms\n    if (!this.editor.enabled &&\n        (this.waitingForFirstPlan || (!this.paused && timeSinceLastPlanUpdate > planWaitingThreshold))) {\n      this.showPlannerUnavailable(true);\n      this.prevTimestamp = timestamp;\n    }\n    const dt = (timestamp - this.prevTimestamp) / 1000;\n\n    this.editor.update();\n\n    // skip simulation when dt is not in valid expected range\n    if (!this.editor.enabled && !this.paused && dt > 1e-6 && dt < 0.5) {\n      this.showPlannerUnavailable(false);\n\n      this.simulatedTime += dt;\n\n      const prevCarPosition = this.car.position;\n      const prevCarRotation = this.car.rotation;\n\n      const manualControls = this.manualCarController.control(this.car.pose, this.car.wheelAngle, this.car.velocity, dt);\n      if (manualControls.steer != 0 || manualControls.brake != 0 || manualControls.gas != 0)\n        this.enableManualMode();\n\n      let autonomousControls = { steer: 0, brake: 0, gas: 0};\n      if (this.autonomousCarController)\n        autonomousControls = this.autonomousCarController.control(this.car.pose, this.car.wheelAngle, this.car.velocity, dt, this.carControllerMode == 'autonomous') ;\n      else if (this.autonomousCarController === null)\n        autonomousControls = { steer: 0, brake: 1, gas: 0 };\n\n      const controls = this.carControllerMode == 'autonomous' ? autonomousControls : manualControls;\n\n      this.car.update(controls, dt);\n      this.physics.step(dt);\n\n      this.updateDynamicObjects(this.simulatedTime);\n\n      const carPosition = this.car.position;\n      const carRotation = this.car.rotation;\n      const carRearAxle = this.car.rearAxlePosition;\n      const carVelocity = this.car.velocity;\n\n      const positionOffset = { x: carPosition.x - prevCarPosition.x, y: 0, z: carPosition.y - prevCarPosition.y };\n      this.chaseCamera.position.add(positionOffset);\n      this.chaseCameraControls.target.set(carPosition.x, 0, carPosition.y);\n      this.chaseCameraControls.rotateLeft(carRotation - prevCarRotation);\n      this.chaseCameraControls.update();\n\n      this.topDownCamera.position.setX(carPosition.x);\n      this.topDownCamera.position.setZ(carPosition.y);\n      this.topDownCamera.rotation.z = -carRotation - Math.PI / 2\n\n      let latitude = null;\n\n      if (this.editor.lanePath.anchors.length > 1) {\n        const [s, l, aroundAnchorIndex] = this.editor.lanePath.stationLatitudeFromPosition(carRearAxle, this.aroundAnchorIndex);\n        this.aroundAnchorIndex = aroundAnchorIndex;\n\n        this.carStation = s;\n        latitude = l;\n      }\n\n      const any_collision = this.hasAnyCollisions();\n      if (any_collision != null) {\n        this.pauseScenario();\n        this.collisionMessage.classList.add('is-active');\n        document.getElementById('collision-message-text').innerText = \"Case failed: \" + any_collision;\n\n        this.pathPlannerWorker.postMessage({\n          type: 'notify_case_status',\n          status: {status: \"failed\", reason: any_collision}\n        });\n\n      } else if (this.checkScenarioCompletion()) {\n        this.pauseScenario();\n        this.successMessage.classList.add('is-active');\n\n        this.pathPlannerWorker.postMessage({\n          type: 'notify_case_status',\n          status: {status: \"completed\"}\n        });\n      }\n\n      this.dashboard.update(\n        controls,\n        carVelocity,\n        this.carStation,\n        latitude,\n        this.simulatedTime,\n        this.averagePlanTime.average);\n    }\n\n    if (!this.editor.enabled && this.plannerReady) {\n      this.startPlanner(this.car.pose, this.carStation || 0);\n      this.dashboard.updatePlanTime(this.averagePlanTime.average);\n    } else if (!this.plannerReady) {\n      this.dashboard.updatePlanTime(timeSinceLastPlanUpdate);\n    }\n\n    this.frameCounter++;\n    this.fpsTime += dt;\n    if (this.fpsTime >= 1) {\n      this.fps = this.frameCounter / this.fpsTime;\n      this.frameCounter = 0;\n      this.fpsTime = 0;\n      this.fpsBox.textContent = this.fps.toFixed(1);\n    }\n\n    this.renderer.render(this.scene, this.camera);\n\n    this.prevTimestamp = timestamp;\n\n    requestAnimationFrame(this.step.bind(this));\n  }\n}\n","import Simulator from \"./Simulator.js\";\nimport StaticObstacle from \"./autonomy/StaticObstacle.js\";\n\ndocument.addEventListener('DOMContentLoaded', e => {\n  window.simulator = new Simulator(document.getElementById('container'));\n});\n"],"names":[],"sourceRoot":""}\n//# sourceURL=webpack-internal:///236\n')},585:module=>{eval('module.exports = "Math.clamp = (number, min, max) => Math.max(min, Math.min(number, max));\\n\\nMath.wrapAngle = (angle) => {\\n angle = angle % (Math.PI * 2);\\n if (angle <= -Math.PI) return angle + Math.PI * 2;\\n else if (angle > Math.PI) return angle - Math.PI * 2;\\n else return angle;\\n}\\n\\nTHREE.Vector2.fromAngle = (angle) => new THREE.Vector2(Math.cos(angle), Math.sin(angle));\\n\\nTHREE.Curve.prototype.getCurvatureAt = function(u) {\\n let t2 = this.getUtoTmapping(u);\\n\\n const delta = 0.0001;\\n let t1 = t2 - delta;\\n let t3 = t2 + delta;\\n\\n if (t1 < 0) {\\n t1 = 0;\\n t2 = delta;\\n t3 = 2 * delta;\\n }\\n\\n if (t3 > 1) {\\n t3 = 1;\\n t2 = 1 - delta;\\n t1 = 1 - 2 * delta;\\n }\\n\\n const p1 = this.getPoint(t1);\\n const p2 = this.getPoint(t2);\\n const p3 = this.getPoint(t3);\\n\\n return (Math.atan2(p3.y - p2.y, p3.x - p2.x) - Math.atan2(p2.y - p1.y, p2.x - p1.x)) / p2.distanceTo(p1);\\n};\\n\\n\\nfunction getOBBVertices(cx, cy, width, height, angle) {\\n const hw = width / 2; // half width\\n const hh = height / 2; // half height\\n const cos = Math.cos(angle);\\n const sin = Math.sin(angle);\\n\\n return [\\n // Top-left\\n { x: cx - hw * cos + hh * sin, y: cy - hw * sin - hh * cos },\\n // Top-right\\n { x: cx + hw * cos + hh * sin, y: cy + hw * sin - hh * cos },\\n // Bottom-right\\n { x: cx + hw * cos - hh * sin, y: cy + hw * sin + hh * cos },\\n // Bottom-left\\n { x: cx - hw * cos - hh * sin, y: cy - hw * sin + hh * cos }\\n ];\\n}\\n\\nfunction getOOBBAxes(vertices) {\\n const axes = [];\\n for (let i = 0; i < vertices.length; i++) {\\n const p1 = vertices[i];\\n const p2 = vertices[(i + 1) % vertices.length]; // Next vertex\\n const edge = { x: p1.x - p2.x, y: p1.y - p2.y }; // Get edge vector\\n const normal = { x: -edge.y, y: edge.x }; // Get normal (perpendicular) vector\\n const length = Math.sqrt(normal.x * normal.x + normal.y * normal.y);\\n axes.push({ x: normal.x / length, y: normal.y / length }); // Normalize vector\\n }\\n return axes;\\n}\\n\\nfunction projectOnAxis(vertices, axis) {\\n let min = Infinity;\\n let max = -Infinity;\\n for (const vertex of vertices) {\\n let projection = vertex.x * axis.x + vertex.y * axis.y;\\n min = Math.min(min, projection);\\n max = Math.max(max, projection);\\n }\\n return { min, max };\\n}\\n\\nfunction segmentsOverlaps(projection1, projection2) {\\n return projection1.max >= projection2.min && projection2.max >= projection1.min;\\n}\\n\\nfunction areRectanglesColliding(rect1, rect2) {\\n const verticesA = getOBBVertices(rect1.x, rect1.y, rect1.width, rect1.height, rect1.angle);\\n const verticesB = getOBBVertices(rect2.x, rect2.y, rect2.width, rect2.height, rect2.angle);\\n\\n const axesA = getOOBBAxes(verticesA);\\n const axesB = getOOBBAxes(verticesB);\\n const axes = axesA.concat(axesB);\\n\\n for (const axis of axes) {\\n const projectionA = projectOnAxis(verticesA, axis);\\n const projectionB = projectOnAxis(verticesB, axis);\\n if (!segmentsOverlaps(projectionA, projectionB)) {\\n return false; // Found a separating axis, no collision\\n }\\n }\\n\\n return true; // No separating axis found, rectangles intersect\\n}\\n\\nfunction checkRectanglePolylineIntersection(rect, polylinePoints) {\\n const rectanglePoints = getOBBVertices(rect.x, rect.y, rect.width, rect.height, rect.angle)\\n\\n // Transform rectangle points into array of lines\\n const rectangleLines = [];\\n for (let i = 0; i < rectanglePoints.length; i++) {\\n rectangleLines.push([\\n rectanglePoints[i],\\n rectanglePoints[(i + 1) % rectanglePoints.length]\\n ]);\\n }\\n\\n // Check each polyline segment for intersection with each rectangle line\\n for (let i = 0; i < polylinePoints.length - 1; i++) {\\n const polylineSegment = [\\n polylinePoints[i],\\n polylinePoints[i + 1]\\n ];\\n\\n for (const rectLine of rectangleLines) {\\n if (intersectSegment(rectLine[0], rectLine[1], polylineSegment[0], polylineSegment[1])) {\\n return true; // Found an intersection\\n }\\n }\\n }\\n\\n // No intersections found\\n return false;\\n}\\n\\n// Helper function to detect intersection between two line segments\\nfunction intersectSegment(p0, p1, p2, p3) {\\n let s1_x, s1_y, s2_x, s2_y;\\n s1_x = p1.x - p0.x; s1_y = p1.y - p0.y;\\n s2_x = p3.x - p2.x; s2_y = p3.y - p2.y;\\n\\n let s, t;\\n s = (-s1_y * (p0.x - p2.x) + s1_x * (p0.y - p2.y)) / (-s2_x * s1_y + s1_x * s2_y);\\n t = ( s2_x * (p0.y - p2.y) - s2_y * (p0.x - p2.x)) / (-s2_x * s1_y + s1_x * s2_y);\\n\\n // Collision detected\\n if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {\\n // Intersection point is p0 + t * s1\\n return true;\\n }\\n\\n return false; // No collision\\n}\\n"//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,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\n//# sourceURL=webpack-internal:///585\n')},642:module=>{eval('/*\n\tMIT License http://www.opensource.org/licenses/mit-license.php\n\tAuthor Tobias Koppers @sokra\n*/\nmodule.exports = function(src) {\n\tfunction log(error) {\n\t\t(typeof console !== "undefined")\n\t\t&& (console.error || console.log)("[Script Loader]", error);\n\t}\n\n\t// Check for IE =< 8\n\tfunction isIE() {\n\t\treturn typeof attachEvent !== "undefined" && typeof addEventListener === "undefined";\n\t}\n\n\ttry {\n\t\tif (typeof execScript !== "undefined" && isIE()) {\n\t\t\texecScript(src);\n\t\t} else if (typeof eval !== "undefined") {\n\t\t\teval.call(null, src);\n\t\t} else {\n\t\t\tlog("EvalError: No eval function available");\n\t\t}\n\t} catch (error) {\n\t\tlog(error);\n\t}\n}\n//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiNjQyLmpzIiwibWFwcGluZ3MiOiJBQUFBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTs7QUFFQTtBQUNBO0FBQ0E7QUFDQTs7QUFFQTtBQUNBO0FBQ0E7QUFDQSxJQUFJO0FBQ0o7QUFDQSxJQUFJO0FBQ0o7QUFDQTtBQUNBLEdBQUc7QUFDSDtBQUNBO0FBQ0EiLCJzb3VyY2VzIjpbIndlYnBhY2s6Ly9kYXNoLy4vbm9kZV9tb2R1bGVzL3NjcmlwdC1sb2FkZXIvYWRkU2NyaXB0LmpzP2YyYjUiXSwic291cmNlc0NvbnRlbnQiOlsiLypcblx0TUlUIExpY2Vuc2UgaHR0cDovL3d3dy5vcGVuc291cmNlLm9yZy9saWNlbnNlcy9taXQtbGljZW5zZS5waHBcblx0QXV0aG9yIFRvYmlhcyBLb3BwZXJzIEBzb2tyYVxuKi9cbm1vZHVsZS5leHBvcnRzID0gZnVuY3Rpb24oc3JjKSB7XG5cdGZ1bmN0aW9uIGxvZyhlcnJvcikge1xuXHRcdCh0eXBlb2YgY29uc29sZSAhPT0gXCJ1bmRlZmluZWRcIilcblx0XHQmJiAoY29uc29sZS5lcnJvciB8fCBjb25zb2xlLmxvZykoXCJbU2NyaXB0IExvYWRlcl1cIiwgZXJyb3IpO1xuXHR9XG5cblx0Ly8gQ2hlY2sgZm9yIElFID08IDhcblx0ZnVuY3Rpb24gaXNJRSgpIHtcblx0XHRyZXR1cm4gdHlwZW9mIGF0dGFjaEV2ZW50ICE9PSBcInVuZGVmaW5lZFwiICYmIHR5cGVvZiBhZGRFdmVudExpc3RlbmVyID09PSBcInVuZGVmaW5lZFwiO1xuXHR9XG5cblx0dHJ5IHtcblx0XHRpZiAodHlwZW9mIGV4ZWNTY3JpcHQgIT09IFwidW5kZWZpbmVkXCIgJiYgaXNJRSgpKSB7XG5cdFx0XHRleGVjU2NyaXB0KHNyYyk7XG5cdFx0fSBlbHNlIGlmICh0eXBlb2YgZXZhbCAhPT0gXCJ1bmRlZmluZWRcIikge1xuXHRcdFx0ZXZhbC5jYWxsKG51bGwsIHNyYyk7XG5cdFx0fSBlbHNlIHtcblx0XHRcdGxvZyhcIkV2YWxFcnJvcjogTm8gZXZhbCBmdW5jdGlvbiBhdmFpbGFibGVcIik7XG5cdFx0fVxuXHR9IGNhdGNoIChlcnJvcikge1xuXHRcdGxvZyhlcnJvcik7XG5cdH1cbn1cbiJdLCJuYW1lcyI6W10sInNvdXJjZVJvb3QiOiIifQ==\n//# sourceURL=webpack-internal:///642\n')},172:(__unused_webpack_module,__unused_webpack_exports,__webpack_require__)=>{eval("__webpack_require__(642)(__webpack_require__(585))//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMTcyLmpzIiwibWFwcGluZ3MiOiJBQUFBLG1CQUFPLENBQUMsR0FBNkUsRUFBRSxtQkFBTyxDQUFDLEdBQW9IIiwic291cmNlcyI6WyJ3ZWJwYWNrOi8vZGFzaC8uL2pzL1V0aWxzLmpzPzdiNWYiXSwic291cmNlc0NvbnRlbnQiOlsicmVxdWlyZShcIiEhL1VzZXJzL2xuZHN0b2wvRGV2L2Rhc2gvc2ltdWxhdG9yL25vZGVfbW9kdWxlcy9zY3JpcHQtbG9hZGVyL2FkZFNjcmlwdC5qc1wiKShyZXF1aXJlKFwiISEvVXNlcnMvbG5kc3RvbC9EZXYvZGFzaC9zaW11bGF0b3Ivbm9kZV9tb2R1bGVzL3Jhdy1sb2FkZXIvaW5kZXguanMhL1VzZXJzL2xuZHN0b2wvRGV2L2Rhc2gvc2ltdWxhdG9yL2pzL1V0aWxzLmpzXCIpKSJdLCJuYW1lcyI6W10sInNvdXJjZVJvb3QiOiIifQ==\n//# sourceURL=webpack-internal:///172\n")}},__webpack_module_cache__={};function __webpack_require__(A){var Q=__webpack_module_cache__[A];if(void 0!==Q)return Q.exports;var B=__webpack_module_cache__[A]={exports:{}};return __webpack_modules__[A](B,B.exports,__webpack_require__),B.exports}var __webpack_exports__=__webpack_require__(236)})(); \ No newline at end of file diff --git a/seminar06-planning/simulator/dist/PathPlannerWorker.js b/seminar06-planning/simulator/dist/PathPlannerWorker.js new file mode 100644 index 0000000..df46c54 --- /dev/null +++ b/seminar06-planning/simulator/dist/PathPlannerWorker.js @@ -0,0 +1 @@ +function dash_initPathPlannerWorker(){(()=>{var __webpack_modules__={585:module=>{eval('module.exports = "Math.clamp = (number, min, max) => Math.max(min, Math.min(number, max));\\n\\nMath.wrapAngle = (angle) => {\\n angle = angle % (Math.PI * 2);\\n if (angle <= -Math.PI) return angle + Math.PI * 2;\\n else if (angle > Math.PI) return angle - Math.PI * 2;\\n else return angle;\\n}\\n\\nTHREE.Vector2.fromAngle = (angle) => new THREE.Vector2(Math.cos(angle), Math.sin(angle));\\n\\nTHREE.Curve.prototype.getCurvatureAt = function(u) {\\n let t2 = this.getUtoTmapping(u);\\n\\n const delta = 0.0001;\\n let t1 = t2 - delta;\\n let t3 = t2 + delta;\\n\\n if (t1 < 0) {\\n t1 = 0;\\n t2 = delta;\\n t3 = 2 * delta;\\n }\\n\\n if (t3 > 1) {\\n t3 = 1;\\n t2 = 1 - delta;\\n t1 = 1 - 2 * delta;\\n }\\n\\n const p1 = this.getPoint(t1);\\n const p2 = this.getPoint(t2);\\n const p3 = this.getPoint(t3);\\n\\n return (Math.atan2(p3.y - p2.y, p3.x - p2.x) - Math.atan2(p2.y - p1.y, p2.x - p1.x)) / p2.distanceTo(p1);\\n};\\n\\n\\nfunction getOBBVertices(cx, cy, width, height, angle) {\\n const hw = width / 2; // half width\\n const hh = height / 2; // half height\\n const cos = Math.cos(angle);\\n const sin = Math.sin(angle);\\n\\n return [\\n // Top-left\\n { x: cx - hw * cos + hh * sin, y: cy - hw * sin - hh * cos },\\n // Top-right\\n { x: cx + hw * cos + hh * sin, y: cy + hw * sin - hh * cos },\\n // Bottom-right\\n { x: cx + hw * cos - hh * sin, y: cy + hw * sin + hh * cos },\\n // Bottom-left\\n { x: cx - hw * cos - hh * sin, y: cy - hw * sin + hh * cos }\\n ];\\n}\\n\\nfunction getOOBBAxes(vertices) {\\n const axes = [];\\n for (let i = 0; i < vertices.length; i++) {\\n const p1 = vertices[i];\\n const p2 = vertices[(i + 1) % vertices.length]; // Next vertex\\n const edge = { x: p1.x - p2.x, y: p1.y - p2.y }; // Get edge vector\\n const normal = { x: -edge.y, y: edge.x }; // Get normal (perpendicular) vector\\n const length = Math.sqrt(normal.x * normal.x + normal.y * normal.y);\\n axes.push({ x: normal.x / length, y: normal.y / length }); // Normalize vector\\n }\\n return axes;\\n}\\n\\nfunction projectOnAxis(vertices, axis) {\\n let min = Infinity;\\n let max = -Infinity;\\n for (const vertex of vertices) {\\n let projection = vertex.x * axis.x + vertex.y * axis.y;\\n min = Math.min(min, projection);\\n max = Math.max(max, projection);\\n }\\n return { min, max };\\n}\\n\\nfunction segmentsOverlaps(projection1, projection2) {\\n return projection1.max >= projection2.min && projection2.max >= projection1.min;\\n}\\n\\nfunction areRectanglesColliding(rect1, rect2) {\\n const verticesA = getOBBVertices(rect1.x, rect1.y, rect1.width, rect1.height, rect1.angle);\\n const verticesB = getOBBVertices(rect2.x, rect2.y, rect2.width, rect2.height, rect2.angle);\\n\\n const axesA = getOOBBAxes(verticesA);\\n const axesB = getOOBBAxes(verticesB);\\n const axes = axesA.concat(axesB);\\n\\n for (const axis of axes) {\\n const projectionA = projectOnAxis(verticesA, axis);\\n const projectionB = projectOnAxis(verticesB, axis);\\n if (!segmentsOverlaps(projectionA, projectionB)) {\\n return false; // Found a separating axis, no collision\\n }\\n }\\n\\n return true; // No separating axis found, rectangles intersect\\n}\\n\\nfunction checkRectanglePolylineIntersection(rect, polylinePoints) {\\n const rectanglePoints = getOBBVertices(rect.x, rect.y, rect.width, rect.height, rect.angle)\\n\\n // Transform rectangle points into array of lines\\n const rectangleLines = [];\\n for (let i = 0; i < rectanglePoints.length; i++) {\\n rectangleLines.push([\\n rectanglePoints[i],\\n rectanglePoints[(i + 1) % rectanglePoints.length]\\n ]);\\n }\\n\\n // Check each polyline segment for intersection with each rectangle line\\n for (let i = 0; i < polylinePoints.length - 1; i++) {\\n const polylineSegment = [\\n polylinePoints[i],\\n polylinePoints[i + 1]\\n ];\\n\\n for (const rectLine of rectangleLines) {\\n if (intersectSegment(rectLine[0], rectLine[1], polylineSegment[0], polylineSegment[1])) {\\n return true; // Found an intersection\\n }\\n }\\n }\\n\\n // No intersections found\\n return false;\\n}\\n\\n// Helper function to detect intersection between two line segments\\nfunction intersectSegment(p0, p1, p2, p3) {\\n let s1_x, s1_y, s2_x, s2_y;\\n s1_x = p1.x - p0.x; s1_y = p1.y - p0.y;\\n s2_x = p3.x - p2.x; s2_y = p3.y - p2.y;\\n\\n let s, t;\\n s = (-s1_y * (p0.x - p2.x) + s1_x * (p0.y - p2.y)) / (-s2_x * s1_y + s1_x * s2_y);\\n t = ( s2_x * (p0.y - p2.y) - s2_y * (p0.x - p2.x)) / (-s2_x * s1_y + s1_x * s2_y);\\n\\n // Collision detected\\n if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {\\n // Intersection point is p0 + t * s1\\n return true;\\n }\\n\\n return false; // No collision\\n}\\n"//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,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\n//# sourceURL=webpack-internal:///585\n')},621:module=>{eval("module.exports = \"(function (global, factory) {\\n\\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\\n\\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\\n\\t(factory((global.THREE = {})));\\n}(this, (function (exports) { 'use strict';\\n\\n\\t// Polyfills\\n\\n\\tif ( Number.EPSILON === undefined ) {\\n\\n\\t\\tNumber.EPSILON = Math.pow( 2, - 52 );\\n\\n\\t}\\n\\n\\tif ( Number.isInteger === undefined ) {\\n\\n\\t\\t// Missing in IE\\n\\t\\t// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger\\n\\n\\t\\tNumber.isInteger = function ( value ) {\\n\\n\\t\\t\\treturn typeof value === 'number' && isFinite( value ) && Math.floor( value ) === value;\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t//\\n\\n\\tif ( Math.sign === undefined ) {\\n\\n\\t\\t// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign\\n\\n\\t\\tMath.sign = function ( x ) {\\n\\n\\t\\t\\treturn ( x < 0 ) ? - 1 : ( x > 0 ) ? 1 : + x;\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\tif ( 'name' in Function.prototype === false ) {\\n\\n\\t\\t// Missing in IE\\n\\t\\t// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name\\n\\n\\t\\tObject.defineProperty( Function.prototype, 'name', {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.toString().match( /^\\\\s*function\\\\s*([^\\\\(\\\\s]*)/ )[ 1 ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t} );\\n\\n\\t}\\n\\n\\tif ( Object.assign === undefined ) {\\n\\n\\t\\t// Missing in IE\\n\\t\\t// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign\\n\\n\\t\\t( function () {\\n\\n\\t\\t\\tObject.assign = function ( target ) {\\n\\n\\t\\t\\t\\tif ( target === undefined || target === null ) {\\n\\n\\t\\t\\t\\t\\tthrow new TypeError( 'Cannot convert undefined or null to object' );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar output = Object( target );\\n\\n\\t\\t\\t\\tfor ( var index = 1; index < arguments.length; index ++ ) {\\n\\n\\t\\t\\t\\t\\tvar source = arguments[ index ];\\n\\n\\t\\t\\t\\t\\tif ( source !== undefined && source !== null ) {\\n\\n\\t\\t\\t\\t\\t\\tfor ( var nextKey in source ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( Object.prototype.hasOwnProperty.call( source, nextKey ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\toutput[ nextKey ] = source[ nextKey ];\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn output;\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )();\\n\\n\\t}\\n\\n\\t/**\\n\\t * https://github.com/mrdoob/eventdispatcher.js/\\n\\t */\\n\\n\\tfunction EventDispatcher() {}\\n\\n\\tObject.assign( EventDispatcher.prototype, {\\n\\n\\t\\taddEventListener: function ( type, listener ) {\\n\\n\\t\\t\\tif ( this._listeners === undefined ) this._listeners = {};\\n\\n\\t\\t\\tvar listeners = this._listeners;\\n\\n\\t\\t\\tif ( listeners[ type ] === undefined ) {\\n\\n\\t\\t\\t\\tlisteners[ type ] = [];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( listeners[ type ].indexOf( listener ) === - 1 ) {\\n\\n\\t\\t\\t\\tlisteners[ type ].push( listener );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\thasEventListener: function ( type, listener ) {\\n\\n\\t\\t\\tif ( this._listeners === undefined ) return false;\\n\\n\\t\\t\\tvar listeners = this._listeners;\\n\\n\\t\\t\\treturn listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== - 1;\\n\\n\\t\\t},\\n\\n\\t\\tremoveEventListener: function ( type, listener ) {\\n\\n\\t\\t\\tif ( this._listeners === undefined ) return;\\n\\n\\t\\t\\tvar listeners = this._listeners;\\n\\t\\t\\tvar listenerArray = listeners[ type ];\\n\\n\\t\\t\\tif ( listenerArray !== undefined ) {\\n\\n\\t\\t\\t\\tvar index = listenerArray.indexOf( listener );\\n\\n\\t\\t\\t\\tif ( index !== - 1 ) {\\n\\n\\t\\t\\t\\t\\tlistenerArray.splice( index, 1 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tdispatchEvent: function ( event ) {\\n\\n\\t\\t\\tif ( this._listeners === undefined ) return;\\n\\n\\t\\t\\tvar listeners = this._listeners;\\n\\t\\t\\tvar listenerArray = listeners[ event.type ];\\n\\n\\t\\t\\tif ( listenerArray !== undefined ) {\\n\\n\\t\\t\\t\\tevent.target = this;\\n\\n\\t\\t\\t\\tvar array = listenerArray.slice( 0 );\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = array.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tarray[ i ].call( this, event );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tvar REVISION = '89';\\n\\tvar MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2 };\\n\\tvar CullFaceNone = 0;\\n\\tvar CullFaceBack = 1;\\n\\tvar CullFaceFront = 2;\\n\\tvar CullFaceFrontBack = 3;\\n\\tvar FrontFaceDirectionCW = 0;\\n\\tvar FrontFaceDirectionCCW = 1;\\n\\tvar BasicShadowMap = 0;\\n\\tvar PCFShadowMap = 1;\\n\\tvar PCFSoftShadowMap = 2;\\n\\tvar FrontSide = 0;\\n\\tvar BackSide = 1;\\n\\tvar DoubleSide = 2;\\n\\tvar FlatShading = 1;\\n\\tvar SmoothShading = 2;\\n\\tvar NoColors = 0;\\n\\tvar FaceColors = 1;\\n\\tvar VertexColors = 2;\\n\\tvar NoBlending = 0;\\n\\tvar NormalBlending = 1;\\n\\tvar AdditiveBlending = 2;\\n\\tvar SubtractiveBlending = 3;\\n\\tvar MultiplyBlending = 4;\\n\\tvar CustomBlending = 5;\\n\\tvar AddEquation = 100;\\n\\tvar SubtractEquation = 101;\\n\\tvar ReverseSubtractEquation = 102;\\n\\tvar MinEquation = 103;\\n\\tvar MaxEquation = 104;\\n\\tvar ZeroFactor = 200;\\n\\tvar OneFactor = 201;\\n\\tvar SrcColorFactor = 202;\\n\\tvar OneMinusSrcColorFactor = 203;\\n\\tvar SrcAlphaFactor = 204;\\n\\tvar OneMinusSrcAlphaFactor = 205;\\n\\tvar DstAlphaFactor = 206;\\n\\tvar OneMinusDstAlphaFactor = 207;\\n\\tvar DstColorFactor = 208;\\n\\tvar OneMinusDstColorFactor = 209;\\n\\tvar SrcAlphaSaturateFactor = 210;\\n\\tvar NeverDepth = 0;\\n\\tvar AlwaysDepth = 1;\\n\\tvar LessDepth = 2;\\n\\tvar LessEqualDepth = 3;\\n\\tvar EqualDepth = 4;\\n\\tvar GreaterEqualDepth = 5;\\n\\tvar GreaterDepth = 6;\\n\\tvar NotEqualDepth = 7;\\n\\tvar MultiplyOperation = 0;\\n\\tvar MixOperation = 1;\\n\\tvar AddOperation = 2;\\n\\tvar NoToneMapping = 0;\\n\\tvar LinearToneMapping = 1;\\n\\tvar ReinhardToneMapping = 2;\\n\\tvar Uncharted2ToneMapping = 3;\\n\\tvar CineonToneMapping = 4;\\n\\tvar UVMapping = 300;\\n\\tvar CubeReflectionMapping = 301;\\n\\tvar CubeRefractionMapping = 302;\\n\\tvar EquirectangularReflectionMapping = 303;\\n\\tvar EquirectangularRefractionMapping = 304;\\n\\tvar SphericalReflectionMapping = 305;\\n\\tvar CubeUVReflectionMapping = 306;\\n\\tvar CubeUVRefractionMapping = 307;\\n\\tvar RepeatWrapping = 1000;\\n\\tvar ClampToEdgeWrapping = 1001;\\n\\tvar MirroredRepeatWrapping = 1002;\\n\\tvar NearestFilter = 1003;\\n\\tvar NearestMipMapNearestFilter = 1004;\\n\\tvar NearestMipMapLinearFilter = 1005;\\n\\tvar LinearFilter = 1006;\\n\\tvar LinearMipMapNearestFilter = 1007;\\n\\tvar LinearMipMapLinearFilter = 1008;\\n\\tvar UnsignedByteType = 1009;\\n\\tvar ByteType = 1010;\\n\\tvar ShortType = 1011;\\n\\tvar UnsignedShortType = 1012;\\n\\tvar IntType = 1013;\\n\\tvar UnsignedIntType = 1014;\\n\\tvar FloatType = 1015;\\n\\tvar HalfFloatType = 1016;\\n\\tvar UnsignedShort4444Type = 1017;\\n\\tvar UnsignedShort5551Type = 1018;\\n\\tvar UnsignedShort565Type = 1019;\\n\\tvar UnsignedInt248Type = 1020;\\n\\tvar AlphaFormat = 1021;\\n\\tvar RGBFormat = 1022;\\n\\tvar RGBAFormat = 1023;\\n\\tvar LuminanceFormat = 1024;\\n\\tvar LuminanceAlphaFormat = 1025;\\n\\tvar RGBEFormat = RGBAFormat;\\n\\tvar DepthFormat = 1026;\\n\\tvar DepthStencilFormat = 1027;\\n\\tvar RGB_S3TC_DXT1_Format = 2001;\\n\\tvar RGBA_S3TC_DXT1_Format = 2002;\\n\\tvar RGBA_S3TC_DXT3_Format = 2003;\\n\\tvar RGBA_S3TC_DXT5_Format = 2004;\\n\\tvar RGB_PVRTC_4BPPV1_Format = 2100;\\n\\tvar RGB_PVRTC_2BPPV1_Format = 2101;\\n\\tvar RGBA_PVRTC_4BPPV1_Format = 2102;\\n\\tvar RGBA_PVRTC_2BPPV1_Format = 2103;\\n\\tvar RGB_ETC1_Format = 2151;\\n\\tvar LoopOnce = 2200;\\n\\tvar LoopRepeat = 2201;\\n\\tvar LoopPingPong = 2202;\\n\\tvar InterpolateDiscrete = 2300;\\n\\tvar InterpolateLinear = 2301;\\n\\tvar InterpolateSmooth = 2302;\\n\\tvar ZeroCurvatureEnding = 2400;\\n\\tvar ZeroSlopeEnding = 2401;\\n\\tvar WrapAroundEnding = 2402;\\n\\tvar TrianglesDrawMode = 0;\\n\\tvar TriangleStripDrawMode = 1;\\n\\tvar TriangleFanDrawMode = 2;\\n\\tvar LinearEncoding = 3000;\\n\\tvar sRGBEncoding = 3001;\\n\\tvar GammaEncoding = 3007;\\n\\tvar RGBEEncoding = 3002;\\n\\tvar LogLuvEncoding = 3003;\\n\\tvar RGBM7Encoding = 3004;\\n\\tvar RGBM16Encoding = 3005;\\n\\tvar RGBDEncoding = 3006;\\n\\tvar BasicDepthPacking = 3200;\\n\\tvar RGBADepthPacking = 3201;\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tvar _Math = {\\n\\n\\t\\tDEG2RAD: Math.PI / 180,\\n\\t\\tRAD2DEG: 180 / Math.PI,\\n\\n\\t\\tgenerateUUID: ( function () {\\n\\n\\t\\t\\t// http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136\\n\\n\\t\\t\\tvar lut = [];\\n\\n\\t\\t\\tfor ( var i = 0; i < 256; i ++ ) {\\n\\n\\t\\t\\t\\tlut[ i ] = ( i < 16 ? '0' : '' ) + ( i ).toString( 16 ).toUpperCase();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn function () {\\n\\n\\t\\t\\t\\tvar d0 = Math.random() * 0xffffffff | 0;\\n\\t\\t\\t\\tvar d1 = Math.random() * 0xffffffff | 0;\\n\\t\\t\\t\\tvar d2 = Math.random() * 0xffffffff | 0;\\n\\t\\t\\t\\tvar d3 = Math.random() * 0xffffffff | 0;\\n\\t\\t\\t\\treturn lut[ d0 & 0xff ] + lut[ d0 >> 8 & 0xff ] + lut[ d0 >> 16 & 0xff ] + lut[ d0 >> 24 & 0xff ] + '-' +\\n\\t\\t\\t\\t\\tlut[ d1 & 0xff ] + lut[ d1 >> 8 & 0xff ] + '-' + lut[ d1 >> 16 & 0x0f | 0x40 ] + lut[ d1 >> 24 & 0xff ] + '-' +\\n\\t\\t\\t\\t\\tlut[ d2 & 0x3f | 0x80 ] + lut[ d2 >> 8 & 0xff ] + '-' + lut[ d2 >> 16 & 0xff ] + lut[ d2 >> 24 & 0xff ] +\\n\\t\\t\\t\\t\\tlut[ d3 & 0xff ] + lut[ d3 >> 8 & 0xff ] + lut[ d3 >> 16 & 0xff ] + lut[ d3 >> 24 & 0xff ];\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )(),\\n\\n\\t\\tclamp: function ( value, min, max ) {\\n\\n\\t\\t\\treturn Math.max( min, Math.min( max, value ) );\\n\\n\\t\\t},\\n\\n\\t\\t// compute euclidian modulo of m % n\\n\\t\\t// https://en.wikipedia.org/wiki/Modulo_operation\\n\\n\\t\\teuclideanModulo: function ( n, m ) {\\n\\n\\t\\t\\treturn ( ( n % m ) + m ) % m;\\n\\n\\t\\t},\\n\\n\\t\\t// Linear mapping from range to range \\n\\n\\t\\tmapLinear: function ( x, a1, a2, b1, b2 ) {\\n\\n\\t\\t\\treturn b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 );\\n\\n\\t\\t},\\n\\n\\t\\t// https://en.wikipedia.org/wiki/Linear_interpolation\\n\\n\\t\\tlerp: function ( x, y, t ) {\\n\\n\\t\\t\\treturn ( 1 - t ) * x + t * y;\\n\\n\\t\\t},\\n\\n\\t\\t// http://en.wikipedia.org/wiki/Smoothstep\\n\\n\\t\\tsmoothstep: function ( x, min, max ) {\\n\\n\\t\\t\\tif ( x <= min ) return 0;\\n\\t\\t\\tif ( x >= max ) return 1;\\n\\n\\t\\t\\tx = ( x - min ) / ( max - min );\\n\\n\\t\\t\\treturn x * x * ( 3 - 2 * x );\\n\\n\\t\\t},\\n\\n\\t\\tsmootherstep: function ( x, min, max ) {\\n\\n\\t\\t\\tif ( x <= min ) return 0;\\n\\t\\t\\tif ( x >= max ) return 1;\\n\\n\\t\\t\\tx = ( x - min ) / ( max - min );\\n\\n\\t\\t\\treturn x * x * x * ( x * ( x * 6 - 15 ) + 10 );\\n\\n\\t\\t},\\n\\n\\t\\t// Random integer from interval\\n\\n\\t\\trandInt: function ( low, high ) {\\n\\n\\t\\t\\treturn low + Math.floor( Math.random() * ( high - low + 1 ) );\\n\\n\\t\\t},\\n\\n\\t\\t// Random float from interval\\n\\n\\t\\trandFloat: function ( low, high ) {\\n\\n\\t\\t\\treturn low + Math.random() * ( high - low );\\n\\n\\t\\t},\\n\\n\\t\\t// Random float from <-range/2, range/2> interval\\n\\n\\t\\trandFloatSpread: function ( range ) {\\n\\n\\t\\t\\treturn range * ( 0.5 - Math.random() );\\n\\n\\t\\t},\\n\\n\\t\\tdegToRad: function ( degrees ) {\\n\\n\\t\\t\\treturn degrees * _Math.DEG2RAD;\\n\\n\\t\\t},\\n\\n\\t\\tradToDeg: function ( radians ) {\\n\\n\\t\\t\\treturn radians * _Math.RAD2DEG;\\n\\n\\t\\t},\\n\\n\\t\\tisPowerOfTwo: function ( value ) {\\n\\n\\t\\t\\treturn ( value & ( value - 1 ) ) === 0 && value !== 0;\\n\\n\\t\\t},\\n\\n\\t\\tceilPowerOfTwo: function ( value ) {\\n\\n\\t\\t\\treturn Math.pow( 2, Math.ceil( Math.log( value ) / Math.LN2 ) );\\n\\n\\t\\t},\\n\\n\\t\\tfloorPowerOfTwo: function ( value ) {\\n\\n\\t\\t\\treturn Math.pow( 2, Math.floor( Math.log( value ) / Math.LN2 ) );\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author philogb / http://blog.thejit.org/\\n\\t * @author egraether / http://egraether.com/\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t */\\n\\n\\tfunction Vector2( x, y ) {\\n\\n\\t\\tthis.x = x || 0;\\n\\t\\tthis.y = y || 0;\\n\\n\\t}\\n\\n\\tObject.defineProperties( Vector2.prototype, {\\n\\n\\t\\t\\\"width\\\": {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.x;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis.x = value;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t\\\"height\\\": {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.y;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis.y = value;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Vector2.prototype, {\\n\\n\\t\\tisVector2: true,\\n\\n\\t\\tset: function ( x, y ) {\\n\\n\\t\\t\\tthis.x = x;\\n\\t\\t\\tthis.y = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.x = scalar;\\n\\t\\t\\tthis.y = scalar;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetX: function ( x ) {\\n\\n\\t\\t\\tthis.x = x;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetY: function ( y ) {\\n\\n\\t\\t\\tthis.y = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetComponent: function ( index, value ) {\\n\\n\\t\\t\\tswitch ( index ) {\\n\\n\\t\\t\\t\\tcase 0: this.x = value; break;\\n\\t\\t\\t\\tcase 1: this.y = value; break;\\n\\t\\t\\t\\tdefault: throw new Error( 'index is out of range: ' + index );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetComponent: function ( index ) {\\n\\n\\t\\t\\tswitch ( index ) {\\n\\n\\t\\t\\t\\tcase 0: return this.x;\\n\\t\\t\\t\\tcase 1: return this.y;\\n\\t\\t\\t\\tdefault: throw new Error( 'index is out of range: ' + index );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.x, this.y );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( v ) {\\n\\n\\t\\t\\tthis.x = v.x;\\n\\t\\t\\tthis.y = v.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tadd: function ( v, w ) {\\n\\n\\t\\t\\tif ( w !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.addVectors( v, w );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x += v.x;\\n\\t\\t\\tthis.y += v.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddScalar: function ( s ) {\\n\\n\\t\\t\\tthis.x += s;\\n\\t\\t\\tthis.y += s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddVectors: function ( a, b ) {\\n\\n\\t\\t\\tthis.x = a.x + b.x;\\n\\t\\t\\tthis.y = a.y + b.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddScaledVector: function ( v, s ) {\\n\\n\\t\\t\\tthis.x += v.x * s;\\n\\t\\t\\tthis.y += v.y * s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsub: function ( v, w ) {\\n\\n\\t\\t\\tif ( w !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.subVectors( v, w );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x -= v.x;\\n\\t\\t\\tthis.y -= v.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsubScalar: function ( s ) {\\n\\n\\t\\t\\tthis.x -= s;\\n\\t\\t\\tthis.y -= s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsubVectors: function ( a, b ) {\\n\\n\\t\\t\\tthis.x = a.x - b.x;\\n\\t\\t\\tthis.y = a.y - b.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiply: function ( v ) {\\n\\n\\t\\t\\tthis.x *= v.x;\\n\\t\\t\\tthis.y *= v.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.x *= scalar;\\n\\t\\t\\tthis.y *= scalar;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdivide: function ( v ) {\\n\\n\\t\\t\\tthis.x /= v.x;\\n\\t\\t\\tthis.y /= v.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdivideScalar: function ( scalar ) {\\n\\n\\t\\t\\treturn this.multiplyScalar( 1 / scalar );\\n\\n\\t\\t},\\n\\n\\t\\tapplyMatrix3: function ( m ) {\\n\\n\\t\\t\\tvar x = this.x, y = this.y;\\n\\t\\t\\tvar e = m.elements;\\n\\n\\t\\t\\tthis.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ];\\n\\t\\t\\tthis.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmin: function ( v ) {\\n\\n\\t\\t\\tthis.x = Math.min( this.x, v.x );\\n\\t\\t\\tthis.y = Math.min( this.y, v.y );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmax: function ( v ) {\\n\\n\\t\\t\\tthis.x = Math.max( this.x, v.x );\\n\\t\\t\\tthis.y = Math.max( this.y, v.y );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclamp: function ( min, max ) {\\n\\n\\t\\t\\t// assumes min < max, componentwise\\n\\n\\t\\t\\tthis.x = Math.max( min.x, Math.min( max.x, this.x ) );\\n\\t\\t\\tthis.y = Math.max( min.y, Math.min( max.y, this.y ) );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclampScalar: function () {\\n\\n\\t\\t\\tvar min = new Vector2();\\n\\t\\t\\tvar max = new Vector2();\\n\\n\\t\\t\\treturn function clampScalar( minVal, maxVal ) {\\n\\n\\t\\t\\t\\tmin.set( minVal, minVal );\\n\\t\\t\\t\\tmax.set( maxVal, maxVal );\\n\\n\\t\\t\\t\\treturn this.clamp( min, max );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tclampLength: function ( min, max ) {\\n\\n\\t\\t\\tvar length = this.length();\\n\\n\\t\\t\\treturn this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );\\n\\n\\t\\t},\\n\\n\\t\\tfloor: function () {\\n\\n\\t\\t\\tthis.x = Math.floor( this.x );\\n\\t\\t\\tthis.y = Math.floor( this.y );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tceil: function () {\\n\\n\\t\\t\\tthis.x = Math.ceil( this.x );\\n\\t\\t\\tthis.y = Math.ceil( this.y );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tround: function () {\\n\\n\\t\\t\\tthis.x = Math.round( this.x );\\n\\t\\t\\tthis.y = Math.round( this.y );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\troundToZero: function () {\\n\\n\\t\\t\\tthis.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );\\n\\t\\t\\tthis.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tnegate: function () {\\n\\n\\t\\t\\tthis.x = - this.x;\\n\\t\\t\\tthis.y = - this.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdot: function ( v ) {\\n\\n\\t\\t\\treturn this.x * v.x + this.y * v.y;\\n\\n\\t\\t},\\n\\n\\t\\tlengthSq: function () {\\n\\n\\t\\t\\treturn this.x * this.x + this.y * this.y;\\n\\n\\t\\t},\\n\\n\\t\\tlength: function () {\\n\\n\\t\\t\\treturn Math.sqrt( this.x * this.x + this.y * this.y );\\n\\n\\t\\t},\\n\\n\\t\\tmanhattanLength: function () {\\n\\n\\t\\t\\treturn Math.abs( this.x ) + Math.abs( this.y );\\n\\n\\t\\t},\\n\\n\\t\\tnormalize: function () {\\n\\n\\t\\t\\treturn this.divideScalar( this.length() || 1 );\\n\\n\\t\\t},\\n\\n\\t\\tangle: function () {\\n\\n\\t\\t\\t// computes the angle in radians with respect to the positive x-axis\\n\\n\\t\\t\\tvar angle = Math.atan2( this.y, this.x );\\n\\n\\t\\t\\tif ( angle < 0 ) angle += 2 * Math.PI;\\n\\n\\t\\t\\treturn angle;\\n\\n\\t\\t},\\n\\n\\t\\tdistanceTo: function ( v ) {\\n\\n\\t\\t\\treturn Math.sqrt( this.distanceToSquared( v ) );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToSquared: function ( v ) {\\n\\n\\t\\t\\tvar dx = this.x - v.x, dy = this.y - v.y;\\n\\t\\t\\treturn dx * dx + dy * dy;\\n\\n\\t\\t},\\n\\n\\t\\tmanhattanDistanceTo: function ( v ) {\\n\\n\\t\\t\\treturn Math.abs( this.x - v.x ) + Math.abs( this.y - v.y );\\n\\n\\t\\t},\\n\\n\\t\\tsetLength: function ( length ) {\\n\\n\\t\\t\\treturn this.normalize().multiplyScalar( length );\\n\\n\\t\\t},\\n\\n\\t\\tlerp: function ( v, alpha ) {\\n\\n\\t\\t\\tthis.x += ( v.x - this.x ) * alpha;\\n\\t\\t\\tthis.y += ( v.y - this.y ) * alpha;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tlerpVectors: function ( v1, v2, alpha ) {\\n\\n\\t\\t\\treturn this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( v ) {\\n\\n\\t\\t\\treturn ( ( v.x === this.x ) && ( v.y === this.y ) );\\n\\n\\t\\t},\\n\\n\\t\\tfromArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tthis.x = array[ offset ];\\n\\t\\t\\tthis.y = array[ offset + 1 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( array === undefined ) array = [];\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tarray[ offset ] = this.x;\\n\\t\\t\\tarray[ offset + 1 ] = this.y;\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t},\\n\\n\\t\\tfromBufferAttribute: function ( attribute, index, offset ) {\\n\\n\\t\\t\\tif ( offset !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector2: offset has been removed from .fromBufferAttribute().' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x = attribute.getX( index );\\n\\t\\t\\tthis.y = attribute.getY( index );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\trotateAround: function ( center, angle ) {\\n\\n\\t\\t\\tvar c = Math.cos( angle ), s = Math.sin( angle );\\n\\n\\t\\t\\tvar x = this.x - center.x;\\n\\t\\t\\tvar y = this.y - center.y;\\n\\n\\t\\t\\tthis.x = x * c - y * s + center.x;\\n\\t\\t\\tthis.y = x * s + y * c + center.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author supereggbert / http://www.paulbrunt.co.uk/\\n\\t * @author philogb / http://blog.thejit.org/\\n\\t * @author jordi_ros / http://plattsoft.com\\n\\t * @author D1plo1d / http://github.com/D1plo1d\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author timknip / http://www.floorplanner.com/\\n\\t * @author bhouston / http://clara.io\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction Matrix4() {\\n\\n\\t\\tthis.elements = [\\n\\n\\t\\t\\t1, 0, 0, 0,\\n\\t\\t\\t0, 1, 0, 0,\\n\\t\\t\\t0, 0, 1, 0,\\n\\t\\t\\t0, 0, 0, 1\\n\\n\\t\\t];\\n\\n\\t\\tif ( arguments.length > 0 ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.' );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tObject.assign( Matrix4.prototype, {\\n\\n\\t\\tisMatrix4: true,\\n\\n\\t\\tset: function ( n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44 ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tte[ 0 ] = n11; te[ 4 ] = n12; te[ 8 ] = n13; te[ 12 ] = n14;\\n\\t\\t\\tte[ 1 ] = n21; te[ 5 ] = n22; te[ 9 ] = n23; te[ 13 ] = n24;\\n\\t\\t\\tte[ 2 ] = n31; te[ 6 ] = n32; te[ 10 ] = n33; te[ 14 ] = n34;\\n\\t\\t\\tte[ 3 ] = n41; te[ 7 ] = n42; te[ 11 ] = n43; te[ 15 ] = n44;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tidentity: function () {\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\t1, 0, 0, 0,\\n\\t\\t\\t\\t0, 1, 0, 0,\\n\\t\\t\\t\\t0, 0, 1, 0,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new Matrix4().fromArray( this.elements );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( m ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\t\\t\\tvar me = m.elements;\\n\\n\\t\\t\\tte[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ]; te[ 3 ] = me[ 3 ];\\n\\t\\t\\tte[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ]; te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ];\\n\\t\\t\\tte[ 8 ] = me[ 8 ]; te[ 9 ] = me[ 9 ]; te[ 10 ] = me[ 10 ]; te[ 11 ] = me[ 11 ];\\n\\t\\t\\tte[ 12 ] = me[ 12 ]; te[ 13 ] = me[ 13 ]; te[ 14 ] = me[ 14 ]; te[ 15 ] = me[ 15 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyPosition: function ( m ) {\\n\\n\\t\\t\\tvar te = this.elements, me = m.elements;\\n\\n\\t\\t\\tte[ 12 ] = me[ 12 ];\\n\\t\\t\\tte[ 13 ] = me[ 13 ];\\n\\t\\t\\tte[ 14 ] = me[ 14 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\textractBasis: function ( xAxis, yAxis, zAxis ) {\\n\\n\\t\\t\\txAxis.setFromMatrixColumn( this, 0 );\\n\\t\\t\\tyAxis.setFromMatrixColumn( this, 1 );\\n\\t\\t\\tzAxis.setFromMatrixColumn( this, 2 );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeBasis: function ( xAxis, yAxis, zAxis ) {\\n\\n\\t\\t\\tthis.set(\\n\\t\\t\\t\\txAxis.x, yAxis.x, zAxis.x, 0,\\n\\t\\t\\t\\txAxis.y, yAxis.y, zAxis.y, 0,\\n\\t\\t\\t\\txAxis.z, yAxis.z, zAxis.z, 0,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\textractRotation: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function extractRotation( m ) {\\n\\n\\t\\t\\t\\tvar te = this.elements;\\n\\t\\t\\t\\tvar me = m.elements;\\n\\n\\t\\t\\t\\tvar scaleX = 1 / v1.setFromMatrixColumn( m, 0 ).length();\\n\\t\\t\\t\\tvar scaleY = 1 / v1.setFromMatrixColumn( m, 1 ).length();\\n\\t\\t\\t\\tvar scaleZ = 1 / v1.setFromMatrixColumn( m, 2 ).length();\\n\\n\\t\\t\\t\\tte[ 0 ] = me[ 0 ] * scaleX;\\n\\t\\t\\t\\tte[ 1 ] = me[ 1 ] * scaleX;\\n\\t\\t\\t\\tte[ 2 ] = me[ 2 ] * scaleX;\\n\\n\\t\\t\\t\\tte[ 4 ] = me[ 4 ] * scaleY;\\n\\t\\t\\t\\tte[ 5 ] = me[ 5 ] * scaleY;\\n\\t\\t\\t\\tte[ 6 ] = me[ 6 ] * scaleY;\\n\\n\\t\\t\\t\\tte[ 8 ] = me[ 8 ] * scaleZ;\\n\\t\\t\\t\\tte[ 9 ] = me[ 9 ] * scaleZ;\\n\\t\\t\\t\\tte[ 10 ] = me[ 10 ] * scaleZ;\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tmakeRotationFromEuler: function ( euler ) {\\n\\n\\t\\t\\tif ( ! ( euler && euler.isEuler ) ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tvar x = euler.x, y = euler.y, z = euler.z;\\n\\t\\t\\tvar a = Math.cos( x ), b = Math.sin( x );\\n\\t\\t\\tvar c = Math.cos( y ), d = Math.sin( y );\\n\\t\\t\\tvar e = Math.cos( z ), f = Math.sin( z );\\n\\n\\t\\t\\tif ( euler.order === 'XYZ' ) {\\n\\n\\t\\t\\t\\tvar ae = a * e, af = a * f, be = b * e, bf = b * f;\\n\\n\\t\\t\\t\\tte[ 0 ] = c * e;\\n\\t\\t\\t\\tte[ 4 ] = - c * f;\\n\\t\\t\\t\\tte[ 8 ] = d;\\n\\n\\t\\t\\t\\tte[ 1 ] = af + be * d;\\n\\t\\t\\t\\tte[ 5 ] = ae - bf * d;\\n\\t\\t\\t\\tte[ 9 ] = - b * c;\\n\\n\\t\\t\\t\\tte[ 2 ] = bf - ae * d;\\n\\t\\t\\t\\tte[ 6 ] = be + af * d;\\n\\t\\t\\t\\tte[ 10 ] = a * c;\\n\\n\\t\\t\\t} else if ( euler.order === 'YXZ' ) {\\n\\n\\t\\t\\t\\tvar ce = c * e, cf = c * f, de = d * e, df = d * f;\\n\\n\\t\\t\\t\\tte[ 0 ] = ce + df * b;\\n\\t\\t\\t\\tte[ 4 ] = de * b - cf;\\n\\t\\t\\t\\tte[ 8 ] = a * d;\\n\\n\\t\\t\\t\\tte[ 1 ] = a * f;\\n\\t\\t\\t\\tte[ 5 ] = a * e;\\n\\t\\t\\t\\tte[ 9 ] = - b;\\n\\n\\t\\t\\t\\tte[ 2 ] = cf * b - de;\\n\\t\\t\\t\\tte[ 6 ] = df + ce * b;\\n\\t\\t\\t\\tte[ 10 ] = a * c;\\n\\n\\t\\t\\t} else if ( euler.order === 'ZXY' ) {\\n\\n\\t\\t\\t\\tvar ce = c * e, cf = c * f, de = d * e, df = d * f;\\n\\n\\t\\t\\t\\tte[ 0 ] = ce - df * b;\\n\\t\\t\\t\\tte[ 4 ] = - a * f;\\n\\t\\t\\t\\tte[ 8 ] = de + cf * b;\\n\\n\\t\\t\\t\\tte[ 1 ] = cf + de * b;\\n\\t\\t\\t\\tte[ 5 ] = a * e;\\n\\t\\t\\t\\tte[ 9 ] = df - ce * b;\\n\\n\\t\\t\\t\\tte[ 2 ] = - a * d;\\n\\t\\t\\t\\tte[ 6 ] = b;\\n\\t\\t\\t\\tte[ 10 ] = a * c;\\n\\n\\t\\t\\t} else if ( euler.order === 'ZYX' ) {\\n\\n\\t\\t\\t\\tvar ae = a * e, af = a * f, be = b * e, bf = b * f;\\n\\n\\t\\t\\t\\tte[ 0 ] = c * e;\\n\\t\\t\\t\\tte[ 4 ] = be * d - af;\\n\\t\\t\\t\\tte[ 8 ] = ae * d + bf;\\n\\n\\t\\t\\t\\tte[ 1 ] = c * f;\\n\\t\\t\\t\\tte[ 5 ] = bf * d + ae;\\n\\t\\t\\t\\tte[ 9 ] = af * d - be;\\n\\n\\t\\t\\t\\tte[ 2 ] = - d;\\n\\t\\t\\t\\tte[ 6 ] = b * c;\\n\\t\\t\\t\\tte[ 10 ] = a * c;\\n\\n\\t\\t\\t} else if ( euler.order === 'YZX' ) {\\n\\n\\t\\t\\t\\tvar ac = a * c, ad = a * d, bc = b * c, bd = b * d;\\n\\n\\t\\t\\t\\tte[ 0 ] = c * e;\\n\\t\\t\\t\\tte[ 4 ] = bd - ac * f;\\n\\t\\t\\t\\tte[ 8 ] = bc * f + ad;\\n\\n\\t\\t\\t\\tte[ 1 ] = f;\\n\\t\\t\\t\\tte[ 5 ] = a * e;\\n\\t\\t\\t\\tte[ 9 ] = - b * e;\\n\\n\\t\\t\\t\\tte[ 2 ] = - d * e;\\n\\t\\t\\t\\tte[ 6 ] = ad * f + bc;\\n\\t\\t\\t\\tte[ 10 ] = ac - bd * f;\\n\\n\\t\\t\\t} else if ( euler.order === 'XZY' ) {\\n\\n\\t\\t\\t\\tvar ac = a * c, ad = a * d, bc = b * c, bd = b * d;\\n\\n\\t\\t\\t\\tte[ 0 ] = c * e;\\n\\t\\t\\t\\tte[ 4 ] = - f;\\n\\t\\t\\t\\tte[ 8 ] = d * e;\\n\\n\\t\\t\\t\\tte[ 1 ] = ac * f + bd;\\n\\t\\t\\t\\tte[ 5 ] = a * e;\\n\\t\\t\\t\\tte[ 9 ] = ad * f - bc;\\n\\n\\t\\t\\t\\tte[ 2 ] = bc * f - ad;\\n\\t\\t\\t\\tte[ 6 ] = b * e;\\n\\t\\t\\t\\tte[ 10 ] = bd * f + ac;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// last column\\n\\t\\t\\tte[ 3 ] = 0;\\n\\t\\t\\tte[ 7 ] = 0;\\n\\t\\t\\tte[ 11 ] = 0;\\n\\n\\t\\t\\t// bottom row\\n\\t\\t\\tte[ 12 ] = 0;\\n\\t\\t\\tte[ 13 ] = 0;\\n\\t\\t\\tte[ 14 ] = 0;\\n\\t\\t\\tte[ 15 ] = 1;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeRotationFromQuaternion: function ( q ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tvar x = q._x, y = q._y, z = q._z, w = q._w;\\n\\t\\t\\tvar x2 = x + x, y2 = y + y, z2 = z + z;\\n\\t\\t\\tvar xx = x * x2, xy = x * y2, xz = x * z2;\\n\\t\\t\\tvar yy = y * y2, yz = y * z2, zz = z * z2;\\n\\t\\t\\tvar wx = w * x2, wy = w * y2, wz = w * z2;\\n\\n\\t\\t\\tte[ 0 ] = 1 - ( yy + zz );\\n\\t\\t\\tte[ 4 ] = xy - wz;\\n\\t\\t\\tte[ 8 ] = xz + wy;\\n\\n\\t\\t\\tte[ 1 ] = xy + wz;\\n\\t\\t\\tte[ 5 ] = 1 - ( xx + zz );\\n\\t\\t\\tte[ 9 ] = yz - wx;\\n\\n\\t\\t\\tte[ 2 ] = xz - wy;\\n\\t\\t\\tte[ 6 ] = yz + wx;\\n\\t\\t\\tte[ 10 ] = 1 - ( xx + yy );\\n\\n\\t\\t\\t// last column\\n\\t\\t\\tte[ 3 ] = 0;\\n\\t\\t\\tte[ 7 ] = 0;\\n\\t\\t\\tte[ 11 ] = 0;\\n\\n\\t\\t\\t// bottom row\\n\\t\\t\\tte[ 12 ] = 0;\\n\\t\\t\\tte[ 13 ] = 0;\\n\\t\\t\\tte[ 14 ] = 0;\\n\\t\\t\\tte[ 15 ] = 1;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tlookAt: function () {\\n\\n\\t\\t\\tvar x = new Vector3();\\n\\t\\t\\tvar y = new Vector3();\\n\\t\\t\\tvar z = new Vector3();\\n\\n\\t\\t\\treturn function lookAt( eye, target, up ) {\\n\\n\\t\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\t\\tz.subVectors( eye, target );\\n\\n\\t\\t\\t\\tif ( z.lengthSq() === 0 ) {\\n\\n\\t\\t\\t\\t\\t// eye and target are in the same position\\n\\n\\t\\t\\t\\t\\tz.z = 1;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tz.normalize();\\n\\t\\t\\t\\tx.crossVectors( up, z );\\n\\n\\t\\t\\t\\tif ( x.lengthSq() === 0 ) {\\n\\n\\t\\t\\t\\t\\t// up and z are parallel\\n\\n\\t\\t\\t\\t\\tif ( Math.abs( up.z ) === 1 ) {\\n\\n\\t\\t\\t\\t\\t\\tz.x += 0.0001;\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tz.z += 0.0001;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tz.normalize();\\n\\t\\t\\t\\t\\tx.crossVectors( up, z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tx.normalize();\\n\\t\\t\\t\\ty.crossVectors( z, x );\\n\\n\\t\\t\\t\\tte[ 0 ] = x.x; te[ 4 ] = y.x; te[ 8 ] = z.x;\\n\\t\\t\\t\\tte[ 1 ] = x.y; te[ 5 ] = y.y; te[ 9 ] = z.y;\\n\\t\\t\\t\\tte[ 2 ] = x.z; te[ 6 ] = y.z; te[ 10 ] = z.z;\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tmultiply: function ( m, n ) {\\n\\n\\t\\t\\tif ( n !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.multiplyMatrices( m, n );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this.multiplyMatrices( this, m );\\n\\n\\t\\t},\\n\\n\\t\\tpremultiply: function ( m ) {\\n\\n\\t\\t\\treturn this.multiplyMatrices( m, this );\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyMatrices: function ( a, b ) {\\n\\n\\t\\t\\tvar ae = a.elements;\\n\\t\\t\\tvar be = b.elements;\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tvar a11 = ae[ 0 ], a12 = ae[ 4 ], a13 = ae[ 8 ], a14 = ae[ 12 ];\\n\\t\\t\\tvar a21 = ae[ 1 ], a22 = ae[ 5 ], a23 = ae[ 9 ], a24 = ae[ 13 ];\\n\\t\\t\\tvar a31 = ae[ 2 ], a32 = ae[ 6 ], a33 = ae[ 10 ], a34 = ae[ 14 ];\\n\\t\\t\\tvar a41 = ae[ 3 ], a42 = ae[ 7 ], a43 = ae[ 11 ], a44 = ae[ 15 ];\\n\\n\\t\\t\\tvar b11 = be[ 0 ], b12 = be[ 4 ], b13 = be[ 8 ], b14 = be[ 12 ];\\n\\t\\t\\tvar b21 = be[ 1 ], b22 = be[ 5 ], b23 = be[ 9 ], b24 = be[ 13 ];\\n\\t\\t\\tvar b31 = be[ 2 ], b32 = be[ 6 ], b33 = be[ 10 ], b34 = be[ 14 ];\\n\\t\\t\\tvar b41 = be[ 3 ], b42 = be[ 7 ], b43 = be[ 11 ], b44 = be[ 15 ];\\n\\n\\t\\t\\tte[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;\\n\\t\\t\\tte[ 4 ] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;\\n\\t\\t\\tte[ 8 ] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;\\n\\t\\t\\tte[ 12 ] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;\\n\\n\\t\\t\\tte[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;\\n\\t\\t\\tte[ 5 ] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;\\n\\t\\t\\tte[ 9 ] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;\\n\\t\\t\\tte[ 13 ] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;\\n\\n\\t\\t\\tte[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;\\n\\t\\t\\tte[ 6 ] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;\\n\\t\\t\\tte[ 10 ] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;\\n\\t\\t\\tte[ 14 ] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;\\n\\n\\t\\t\\tte[ 3 ] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;\\n\\t\\t\\tte[ 7 ] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;\\n\\t\\t\\tte[ 11 ] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;\\n\\t\\t\\tte[ 15 ] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyScalar: function ( s ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tte[ 0 ] *= s; te[ 4 ] *= s; te[ 8 ] *= s; te[ 12 ] *= s;\\n\\t\\t\\tte[ 1 ] *= s; te[ 5 ] *= s; te[ 9 ] *= s; te[ 13 ] *= s;\\n\\t\\t\\tte[ 2 ] *= s; te[ 6 ] *= s; te[ 10 ] *= s; te[ 14 ] *= s;\\n\\t\\t\\tte[ 3 ] *= s; te[ 7 ] *= s; te[ 11 ] *= s; te[ 15 ] *= s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tapplyToBufferAttribute: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function applyToBufferAttribute( attribute ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = attribute.count; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tv1.x = attribute.getX( i );\\n\\t\\t\\t\\t\\tv1.y = attribute.getY( i );\\n\\t\\t\\t\\t\\tv1.z = attribute.getZ( i );\\n\\n\\t\\t\\t\\t\\tv1.applyMatrix4( this );\\n\\n\\t\\t\\t\\t\\tattribute.setXYZ( i, v1.x, v1.y, v1.z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn attribute;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tdeterminant: function () {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tvar n11 = te[ 0 ], n12 = te[ 4 ], n13 = te[ 8 ], n14 = te[ 12 ];\\n\\t\\t\\tvar n21 = te[ 1 ], n22 = te[ 5 ], n23 = te[ 9 ], n24 = te[ 13 ];\\n\\t\\t\\tvar n31 = te[ 2 ], n32 = te[ 6 ], n33 = te[ 10 ], n34 = te[ 14 ];\\n\\t\\t\\tvar n41 = te[ 3 ], n42 = te[ 7 ], n43 = te[ 11 ], n44 = te[ 15 ];\\n\\n\\t\\t\\t//TODO: make this more efficient\\n\\t\\t\\t//( based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm )\\n\\n\\t\\t\\treturn (\\n\\t\\t\\t\\tn41 * (\\n\\t\\t\\t\\t\\t+ n14 * n23 * n32\\n\\t\\t\\t\\t\\t - n13 * n24 * n32\\n\\t\\t\\t\\t\\t - n14 * n22 * n33\\n\\t\\t\\t\\t\\t + n12 * n24 * n33\\n\\t\\t\\t\\t\\t + n13 * n22 * n34\\n\\t\\t\\t\\t\\t - n12 * n23 * n34\\n\\t\\t\\t\\t) +\\n\\t\\t\\t\\tn42 * (\\n\\t\\t\\t\\t\\t+ n11 * n23 * n34\\n\\t\\t\\t\\t\\t - n11 * n24 * n33\\n\\t\\t\\t\\t\\t + n14 * n21 * n33\\n\\t\\t\\t\\t\\t - n13 * n21 * n34\\n\\t\\t\\t\\t\\t + n13 * n24 * n31\\n\\t\\t\\t\\t\\t - n14 * n23 * n31\\n\\t\\t\\t\\t) +\\n\\t\\t\\t\\tn43 * (\\n\\t\\t\\t\\t\\t+ n11 * n24 * n32\\n\\t\\t\\t\\t\\t - n11 * n22 * n34\\n\\t\\t\\t\\t\\t - n14 * n21 * n32\\n\\t\\t\\t\\t\\t + n12 * n21 * n34\\n\\t\\t\\t\\t\\t + n14 * n22 * n31\\n\\t\\t\\t\\t\\t - n12 * n24 * n31\\n\\t\\t\\t\\t) +\\n\\t\\t\\t\\tn44 * (\\n\\t\\t\\t\\t\\t- n13 * n22 * n31\\n\\t\\t\\t\\t\\t - n11 * n23 * n32\\n\\t\\t\\t\\t\\t + n11 * n22 * n33\\n\\t\\t\\t\\t\\t + n13 * n21 * n32\\n\\t\\t\\t\\t\\t - n12 * n21 * n33\\n\\t\\t\\t\\t\\t + n12 * n23 * n31\\n\\t\\t\\t\\t)\\n\\n\\t\\t\\t);\\n\\n\\t\\t},\\n\\n\\t\\ttranspose: function () {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\t\\t\\tvar tmp;\\n\\n\\t\\t\\ttmp = te[ 1 ]; te[ 1 ] = te[ 4 ]; te[ 4 ] = tmp;\\n\\t\\t\\ttmp = te[ 2 ]; te[ 2 ] = te[ 8 ]; te[ 8 ] = tmp;\\n\\t\\t\\ttmp = te[ 6 ]; te[ 6 ] = te[ 9 ]; te[ 9 ] = tmp;\\n\\n\\t\\t\\ttmp = te[ 3 ]; te[ 3 ] = te[ 12 ]; te[ 12 ] = tmp;\\n\\t\\t\\ttmp = te[ 7 ]; te[ 7 ] = te[ 13 ]; te[ 13 ] = tmp;\\n\\t\\t\\ttmp = te[ 11 ]; te[ 11 ] = te[ 14 ]; te[ 14 ] = tmp;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetPosition: function ( v ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tte[ 12 ] = v.x;\\n\\t\\t\\tte[ 13 ] = v.y;\\n\\t\\t\\tte[ 14 ] = v.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetInverse: function ( m, throwOnDegenerate ) {\\n\\n\\t\\t\\t// based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm\\n\\t\\t\\tvar te = this.elements,\\n\\t\\t\\t\\tme = m.elements,\\n\\n\\t\\t\\t\\tn11 = me[ 0 ], n21 = me[ 1 ], n31 = me[ 2 ], n41 = me[ 3 ],\\n\\t\\t\\t\\tn12 = me[ 4 ], n22 = me[ 5 ], n32 = me[ 6 ], n42 = me[ 7 ],\\n\\t\\t\\t\\tn13 = me[ 8 ], n23 = me[ 9 ], n33 = me[ 10 ], n43 = me[ 11 ],\\n\\t\\t\\t\\tn14 = me[ 12 ], n24 = me[ 13 ], n34 = me[ 14 ], n44 = me[ 15 ],\\n\\n\\t\\t\\t\\tt11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44,\\n\\t\\t\\t\\tt12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44,\\n\\t\\t\\t\\tt13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44,\\n\\t\\t\\t\\tt14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;\\n\\n\\t\\t\\tvar det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;\\n\\n\\t\\t\\tif ( det === 0 ) {\\n\\n\\t\\t\\t\\tvar msg = \\\"THREE.Matrix4: .getInverse() can't invert matrix, determinant is 0\\\";\\n\\n\\t\\t\\t\\tif ( throwOnDegenerate === true ) {\\n\\n\\t\\t\\t\\t\\tthrow new Error( msg );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tconsole.warn( msg );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn this.identity();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar detInv = 1 / det;\\n\\n\\t\\t\\tte[ 0 ] = t11 * detInv;\\n\\t\\t\\tte[ 1 ] = ( n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44 ) * detInv;\\n\\t\\t\\tte[ 2 ] = ( n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44 ) * detInv;\\n\\t\\t\\tte[ 3 ] = ( n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43 ) * detInv;\\n\\n\\t\\t\\tte[ 4 ] = t12 * detInv;\\n\\t\\t\\tte[ 5 ] = ( n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44 ) * detInv;\\n\\t\\t\\tte[ 6 ] = ( n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44 ) * detInv;\\n\\t\\t\\tte[ 7 ] = ( n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43 ) * detInv;\\n\\n\\t\\t\\tte[ 8 ] = t13 * detInv;\\n\\t\\t\\tte[ 9 ] = ( n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44 ) * detInv;\\n\\t\\t\\tte[ 10 ] = ( n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44 ) * detInv;\\n\\t\\t\\tte[ 11 ] = ( n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43 ) * detInv;\\n\\n\\t\\t\\tte[ 12 ] = t14 * detInv;\\n\\t\\t\\tte[ 13 ] = ( n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34 ) * detInv;\\n\\t\\t\\tte[ 14 ] = ( n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34 ) * detInv;\\n\\t\\t\\tte[ 15 ] = ( n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33 ) * detInv;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tscale: function ( v ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\t\\t\\tvar x = v.x, y = v.y, z = v.z;\\n\\n\\t\\t\\tte[ 0 ] *= x; te[ 4 ] *= y; te[ 8 ] *= z;\\n\\t\\t\\tte[ 1 ] *= x; te[ 5 ] *= y; te[ 9 ] *= z;\\n\\t\\t\\tte[ 2 ] *= x; te[ 6 ] *= y; te[ 10 ] *= z;\\n\\t\\t\\tte[ 3 ] *= x; te[ 7 ] *= y; te[ 11 ] *= z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetMaxScaleOnAxis: function () {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tvar scaleXSq = te[ 0 ] * te[ 0 ] + te[ 1 ] * te[ 1 ] + te[ 2 ] * te[ 2 ];\\n\\t\\t\\tvar scaleYSq = te[ 4 ] * te[ 4 ] + te[ 5 ] * te[ 5 ] + te[ 6 ] * te[ 6 ];\\n\\t\\t\\tvar scaleZSq = te[ 8 ] * te[ 8 ] + te[ 9 ] * te[ 9 ] + te[ 10 ] * te[ 10 ];\\n\\n\\t\\t\\treturn Math.sqrt( Math.max( scaleXSq, scaleYSq, scaleZSq ) );\\n\\n\\t\\t},\\n\\n\\t\\tmakeTranslation: function ( x, y, z ) {\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\t1, 0, 0, x,\\n\\t\\t\\t\\t0, 1, 0, y,\\n\\t\\t\\t\\t0, 0, 1, z,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeRotationX: function ( theta ) {\\n\\n\\t\\t\\tvar c = Math.cos( theta ), s = Math.sin( theta );\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\t1, 0, 0, 0,\\n\\t\\t\\t\\t0, c, - s, 0,\\n\\t\\t\\t\\t0, s, c, 0,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeRotationY: function ( theta ) {\\n\\n\\t\\t\\tvar c = Math.cos( theta ), s = Math.sin( theta );\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\t c, 0, s, 0,\\n\\t\\t\\t\\t 0, 1, 0, 0,\\n\\t\\t\\t\\t- s, 0, c, 0,\\n\\t\\t\\t\\t 0, 0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeRotationZ: function ( theta ) {\\n\\n\\t\\t\\tvar c = Math.cos( theta ), s = Math.sin( theta );\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\tc, - s, 0, 0,\\n\\t\\t\\t\\ts, c, 0, 0,\\n\\t\\t\\t\\t0, 0, 1, 0,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeRotationAxis: function ( axis, angle ) {\\n\\n\\t\\t\\t// Based on http://www.gamedev.net/reference/articles/article1199.asp\\n\\n\\t\\t\\tvar c = Math.cos( angle );\\n\\t\\t\\tvar s = Math.sin( angle );\\n\\t\\t\\tvar t = 1 - c;\\n\\t\\t\\tvar x = axis.x, y = axis.y, z = axis.z;\\n\\t\\t\\tvar tx = t * x, ty = t * y;\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\ttx * x + c, tx * y - s * z, tx * z + s * y, 0,\\n\\t\\t\\t\\ttx * y + s * z, ty * y + c, ty * z - s * x, 0,\\n\\t\\t\\t\\ttx * z - s * y, ty * z + s * x, t * z * z + c, 0,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\t return this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeScale: function ( x, y, z ) {\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\tx, 0, 0, 0,\\n\\t\\t\\t\\t0, y, 0, 0,\\n\\t\\t\\t\\t0, 0, z, 0,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeShear: function ( x, y, z ) {\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\t1, y, z, 0,\\n\\t\\t\\t\\tx, 1, z, 0,\\n\\t\\t\\t\\tx, y, 1, 0,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcompose: function ( position, quaternion, scale ) {\\n\\n\\t\\t\\tthis.makeRotationFromQuaternion( quaternion );\\n\\t\\t\\tthis.scale( scale );\\n\\t\\t\\tthis.setPosition( position );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdecompose: function () {\\n\\n\\t\\t\\tvar vector = new Vector3();\\n\\t\\t\\tvar matrix = new Matrix4();\\n\\n\\t\\t\\treturn function decompose( position, quaternion, scale ) {\\n\\n\\t\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\t\\tvar sx = vector.set( te[ 0 ], te[ 1 ], te[ 2 ] ).length();\\n\\t\\t\\t\\tvar sy = vector.set( te[ 4 ], te[ 5 ], te[ 6 ] ).length();\\n\\t\\t\\t\\tvar sz = vector.set( te[ 8 ], te[ 9 ], te[ 10 ] ).length();\\n\\n\\t\\t\\t\\t// if determine is negative, we need to invert one scale\\n\\t\\t\\t\\tvar det = this.determinant();\\n\\t\\t\\t\\tif ( det < 0 ) sx = - sx;\\n\\n\\t\\t\\t\\tposition.x = te[ 12 ];\\n\\t\\t\\t\\tposition.y = te[ 13 ];\\n\\t\\t\\t\\tposition.z = te[ 14 ];\\n\\n\\t\\t\\t\\t// scale the rotation part\\n\\t\\t\\t\\tmatrix.copy( this );\\n\\n\\t\\t\\t\\tvar invSX = 1 / sx;\\n\\t\\t\\t\\tvar invSY = 1 / sy;\\n\\t\\t\\t\\tvar invSZ = 1 / sz;\\n\\n\\t\\t\\t\\tmatrix.elements[ 0 ] *= invSX;\\n\\t\\t\\t\\tmatrix.elements[ 1 ] *= invSX;\\n\\t\\t\\t\\tmatrix.elements[ 2 ] *= invSX;\\n\\n\\t\\t\\t\\tmatrix.elements[ 4 ] *= invSY;\\n\\t\\t\\t\\tmatrix.elements[ 5 ] *= invSY;\\n\\t\\t\\t\\tmatrix.elements[ 6 ] *= invSY;\\n\\n\\t\\t\\t\\tmatrix.elements[ 8 ] *= invSZ;\\n\\t\\t\\t\\tmatrix.elements[ 9 ] *= invSZ;\\n\\t\\t\\t\\tmatrix.elements[ 10 ] *= invSZ;\\n\\n\\t\\t\\t\\tquaternion.setFromRotationMatrix( matrix );\\n\\n\\t\\t\\t\\tscale.x = sx;\\n\\t\\t\\t\\tscale.y = sy;\\n\\t\\t\\t\\tscale.z = sz;\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tmakePerspective: function ( left, right, top, bottom, near, far ) {\\n\\n\\t\\t\\tif ( far === undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar te = this.elements;\\n\\t\\t\\tvar x = 2 * near / ( right - left );\\n\\t\\t\\tvar y = 2 * near / ( top - bottom );\\n\\n\\t\\t\\tvar a = ( right + left ) / ( right - left );\\n\\t\\t\\tvar b = ( top + bottom ) / ( top - bottom );\\n\\t\\t\\tvar c = - ( far + near ) / ( far - near );\\n\\t\\t\\tvar d = - 2 * far * near / ( far - near );\\n\\n\\t\\t\\tte[ 0 ] = x;\\tte[ 4 ] = 0;\\tte[ 8 ] = a;\\tte[ 12 ] = 0;\\n\\t\\t\\tte[ 1 ] = 0;\\tte[ 5 ] = y;\\tte[ 9 ] = b;\\tte[ 13 ] = 0;\\n\\t\\t\\tte[ 2 ] = 0;\\tte[ 6 ] = 0;\\tte[ 10 ] = c;\\tte[ 14 ] = d;\\n\\t\\t\\tte[ 3 ] = 0;\\tte[ 7 ] = 0;\\tte[ 11 ] = - 1;\\tte[ 15 ] = 0;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeOrthographic: function ( left, right, top, bottom, near, far ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\t\\t\\tvar w = 1.0 / ( right - left );\\n\\t\\t\\tvar h = 1.0 / ( top - bottom );\\n\\t\\t\\tvar p = 1.0 / ( far - near );\\n\\n\\t\\t\\tvar x = ( right + left ) * w;\\n\\t\\t\\tvar y = ( top + bottom ) * h;\\n\\t\\t\\tvar z = ( far + near ) * p;\\n\\n\\t\\t\\tte[ 0 ] = 2 * w;\\tte[ 4 ] = 0;\\tte[ 8 ] = 0;\\tte[ 12 ] = - x;\\n\\t\\t\\tte[ 1 ] = 0;\\tte[ 5 ] = 2 * h;\\tte[ 9 ] = 0;\\tte[ 13 ] = - y;\\n\\t\\t\\tte[ 2 ] = 0;\\tte[ 6 ] = 0;\\tte[ 10 ] = - 2 * p;\\tte[ 14 ] = - z;\\n\\t\\t\\tte[ 3 ] = 0;\\tte[ 7 ] = 0;\\tte[ 11 ] = 0;\\tte[ 15 ] = 1;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( matrix ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\t\\t\\tvar me = matrix.elements;\\n\\n\\t\\t\\tfor ( var i = 0; i < 16; i ++ ) {\\n\\n\\t\\t\\t\\tif ( te[ i ] !== me[ i ] ) return false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn true;\\n\\n\\t\\t},\\n\\n\\t\\tfromArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tfor ( var i = 0; i < 16; i ++ ) {\\n\\n\\t\\t\\t\\tthis.elements[ i ] = array[ i + offset ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( array === undefined ) array = [];\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tarray[ offset ] = te[ 0 ];\\n\\t\\t\\tarray[ offset + 1 ] = te[ 1 ];\\n\\t\\t\\tarray[ offset + 2 ] = te[ 2 ];\\n\\t\\t\\tarray[ offset + 3 ] = te[ 3 ];\\n\\n\\t\\t\\tarray[ offset + 4 ] = te[ 4 ];\\n\\t\\t\\tarray[ offset + 5 ] = te[ 5 ];\\n\\t\\t\\tarray[ offset + 6 ] = te[ 6 ];\\n\\t\\t\\tarray[ offset + 7 ] = te[ 7 ];\\n\\n\\t\\t\\tarray[ offset + 8 ] = te[ 8 ];\\n\\t\\t\\tarray[ offset + 9 ] = te[ 9 ];\\n\\t\\t\\tarray[ offset + 10 ] = te[ 10 ];\\n\\t\\t\\tarray[ offset + 11 ] = te[ 11 ];\\n\\n\\t\\t\\tarray[ offset + 12 ] = te[ 12 ];\\n\\t\\t\\tarray[ offset + 13 ] = te[ 13 ];\\n\\t\\t\\tarray[ offset + 14 ] = te[ 14 ];\\n\\t\\t\\tarray[ offset + 15 ] = te[ 15 ];\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t * @author bhouston / http://clara.io\\n\\t */\\n\\n\\tfunction Quaternion( x, y, z, w ) {\\n\\n\\t\\tthis._x = x || 0;\\n\\t\\tthis._y = y || 0;\\n\\t\\tthis._z = z || 0;\\n\\t\\tthis._w = ( w !== undefined ) ? w : 1;\\n\\n\\t}\\n\\n\\tObject.assign( Quaternion, {\\n\\n\\t\\tslerp: function ( qa, qb, qm, t ) {\\n\\n\\t\\t\\treturn qm.copy( qa ).slerp( qb, t );\\n\\n\\t\\t},\\n\\n\\t\\tslerpFlat: function ( dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t ) {\\n\\n\\t\\t\\t// fuzz-free, array-based Quaternion SLERP operation\\n\\n\\t\\t\\tvar x0 = src0[ srcOffset0 + 0 ],\\n\\t\\t\\t\\ty0 = src0[ srcOffset0 + 1 ],\\n\\t\\t\\t\\tz0 = src0[ srcOffset0 + 2 ],\\n\\t\\t\\t\\tw0 = src0[ srcOffset0 + 3 ],\\n\\n\\t\\t\\t\\tx1 = src1[ srcOffset1 + 0 ],\\n\\t\\t\\t\\ty1 = src1[ srcOffset1 + 1 ],\\n\\t\\t\\t\\tz1 = src1[ srcOffset1 + 2 ],\\n\\t\\t\\t\\tw1 = src1[ srcOffset1 + 3 ];\\n\\n\\t\\t\\tif ( w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1 ) {\\n\\n\\t\\t\\t\\tvar s = 1 - t,\\n\\n\\t\\t\\t\\t\\tcos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,\\n\\n\\t\\t\\t\\t\\tdir = ( cos >= 0 ? 1 : - 1 ),\\n\\t\\t\\t\\t\\tsqrSin = 1 - cos * cos;\\n\\n\\t\\t\\t\\t// Skip the Slerp for tiny steps to avoid numeric problems:\\n\\t\\t\\t\\tif ( sqrSin > Number.EPSILON ) {\\n\\n\\t\\t\\t\\t\\tvar sin = Math.sqrt( sqrSin ),\\n\\t\\t\\t\\t\\t\\tlen = Math.atan2( sin, cos * dir );\\n\\n\\t\\t\\t\\t\\ts = Math.sin( s * len ) / sin;\\n\\t\\t\\t\\t\\tt = Math.sin( t * len ) / sin;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar tDir = t * dir;\\n\\n\\t\\t\\t\\tx0 = x0 * s + x1 * tDir;\\n\\t\\t\\t\\ty0 = y0 * s + y1 * tDir;\\n\\t\\t\\t\\tz0 = z0 * s + z1 * tDir;\\n\\t\\t\\t\\tw0 = w0 * s + w1 * tDir;\\n\\n\\t\\t\\t\\t// Normalize in case we just did a lerp:\\n\\t\\t\\t\\tif ( s === 1 - t ) {\\n\\n\\t\\t\\t\\t\\tvar f = 1 / Math.sqrt( x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0 );\\n\\n\\t\\t\\t\\t\\tx0 *= f;\\n\\t\\t\\t\\t\\ty0 *= f;\\n\\t\\t\\t\\t\\tz0 *= f;\\n\\t\\t\\t\\t\\tw0 *= f;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tdst[ dstOffset ] = x0;\\n\\t\\t\\tdst[ dstOffset + 1 ] = y0;\\n\\t\\t\\tdst[ dstOffset + 2 ] = z0;\\n\\t\\t\\tdst[ dstOffset + 3 ] = w0;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperties( Quaternion.prototype, {\\n\\n\\t\\tx: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this._x;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis._x = value;\\n\\t\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\ty: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this._y;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis._y = value;\\n\\t\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tz: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this._z;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis._z = value;\\n\\t\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tw: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this._w;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis._w = value;\\n\\t\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Quaternion.prototype, {\\n\\n\\t\\tset: function ( x, y, z, w ) {\\n\\n\\t\\t\\tthis._x = x;\\n\\t\\t\\tthis._y = y;\\n\\t\\t\\tthis._z = z;\\n\\t\\t\\tthis._w = w;\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this._x, this._y, this._z, this._w );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( quaternion ) {\\n\\n\\t\\t\\tthis._x = quaternion.x;\\n\\t\\t\\tthis._y = quaternion.y;\\n\\t\\t\\tthis._z = quaternion.z;\\n\\t\\t\\tthis._w = quaternion.w;\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromEuler: function ( euler, update ) {\\n\\n\\t\\t\\tif ( ! ( euler && euler.isEuler ) ) {\\n\\n\\t\\t\\t\\tthrow new Error( 'THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar x = euler._x, y = euler._y, z = euler._z, order = euler.order;\\n\\n\\t\\t\\t// http://www.mathworks.com/matlabcentral/fileexchange/\\n\\t\\t\\t// \\t20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/\\n\\t\\t\\t//\\tcontent/SpinCalc.m\\n\\n\\t\\t\\tvar cos = Math.cos;\\n\\t\\t\\tvar sin = Math.sin;\\n\\n\\t\\t\\tvar c1 = cos( x / 2 );\\n\\t\\t\\tvar c2 = cos( y / 2 );\\n\\t\\t\\tvar c3 = cos( z / 2 );\\n\\n\\t\\t\\tvar s1 = sin( x / 2 );\\n\\t\\t\\tvar s2 = sin( y / 2 );\\n\\t\\t\\tvar s3 = sin( z / 2 );\\n\\n\\t\\t\\tif ( order === 'XYZ' ) {\\n\\n\\t\\t\\t\\tthis._x = s1 * c2 * c3 + c1 * s2 * s3;\\n\\t\\t\\t\\tthis._y = c1 * s2 * c3 - s1 * c2 * s3;\\n\\t\\t\\t\\tthis._z = c1 * c2 * s3 + s1 * s2 * c3;\\n\\t\\t\\t\\tthis._w = c1 * c2 * c3 - s1 * s2 * s3;\\n\\n\\t\\t\\t} else if ( order === 'YXZ' ) {\\n\\n\\t\\t\\t\\tthis._x = s1 * c2 * c3 + c1 * s2 * s3;\\n\\t\\t\\t\\tthis._y = c1 * s2 * c3 - s1 * c2 * s3;\\n\\t\\t\\t\\tthis._z = c1 * c2 * s3 - s1 * s2 * c3;\\n\\t\\t\\t\\tthis._w = c1 * c2 * c3 + s1 * s2 * s3;\\n\\n\\t\\t\\t} else if ( order === 'ZXY' ) {\\n\\n\\t\\t\\t\\tthis._x = s1 * c2 * c3 - c1 * s2 * s3;\\n\\t\\t\\t\\tthis._y = c1 * s2 * c3 + s1 * c2 * s3;\\n\\t\\t\\t\\tthis._z = c1 * c2 * s3 + s1 * s2 * c3;\\n\\t\\t\\t\\tthis._w = c1 * c2 * c3 - s1 * s2 * s3;\\n\\n\\t\\t\\t} else if ( order === 'ZYX' ) {\\n\\n\\t\\t\\t\\tthis._x = s1 * c2 * c3 - c1 * s2 * s3;\\n\\t\\t\\t\\tthis._y = c1 * s2 * c3 + s1 * c2 * s3;\\n\\t\\t\\t\\tthis._z = c1 * c2 * s3 - s1 * s2 * c3;\\n\\t\\t\\t\\tthis._w = c1 * c2 * c3 + s1 * s2 * s3;\\n\\n\\t\\t\\t} else if ( order === 'YZX' ) {\\n\\n\\t\\t\\t\\tthis._x = s1 * c2 * c3 + c1 * s2 * s3;\\n\\t\\t\\t\\tthis._y = c1 * s2 * c3 + s1 * c2 * s3;\\n\\t\\t\\t\\tthis._z = c1 * c2 * s3 - s1 * s2 * c3;\\n\\t\\t\\t\\tthis._w = c1 * c2 * c3 - s1 * s2 * s3;\\n\\n\\t\\t\\t} else if ( order === 'XZY' ) {\\n\\n\\t\\t\\t\\tthis._x = s1 * c2 * c3 - c1 * s2 * s3;\\n\\t\\t\\t\\tthis._y = c1 * s2 * c3 - s1 * c2 * s3;\\n\\t\\t\\t\\tthis._z = c1 * c2 * s3 + s1 * s2 * c3;\\n\\t\\t\\t\\tthis._w = c1 * c2 * c3 + s1 * s2 * s3;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( update !== false ) this.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromAxisAngle: function ( axis, angle ) {\\n\\n\\t\\t\\t// http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm\\n\\n\\t\\t\\t// assumes axis is normalized\\n\\n\\t\\t\\tvar halfAngle = angle / 2, s = Math.sin( halfAngle );\\n\\n\\t\\t\\tthis._x = axis.x * s;\\n\\t\\t\\tthis._y = axis.y * s;\\n\\t\\t\\tthis._z = axis.z * s;\\n\\t\\t\\tthis._w = Math.cos( halfAngle );\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromRotationMatrix: function ( m ) {\\n\\n\\t\\t\\t// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm\\n\\n\\t\\t\\t// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)\\n\\n\\t\\t\\tvar te = m.elements,\\n\\n\\t\\t\\t\\tm11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],\\n\\t\\t\\t\\tm21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],\\n\\t\\t\\t\\tm31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ],\\n\\n\\t\\t\\t\\ttrace = m11 + m22 + m33,\\n\\t\\t\\t\\ts;\\n\\n\\t\\t\\tif ( trace > 0 ) {\\n\\n\\t\\t\\t\\ts = 0.5 / Math.sqrt( trace + 1.0 );\\n\\n\\t\\t\\t\\tthis._w = 0.25 / s;\\n\\t\\t\\t\\tthis._x = ( m32 - m23 ) * s;\\n\\t\\t\\t\\tthis._y = ( m13 - m31 ) * s;\\n\\t\\t\\t\\tthis._z = ( m21 - m12 ) * s;\\n\\n\\t\\t\\t} else if ( m11 > m22 && m11 > m33 ) {\\n\\n\\t\\t\\t\\ts = 2.0 * Math.sqrt( 1.0 + m11 - m22 - m33 );\\n\\n\\t\\t\\t\\tthis._w = ( m32 - m23 ) / s;\\n\\t\\t\\t\\tthis._x = 0.25 * s;\\n\\t\\t\\t\\tthis._y = ( m12 + m21 ) / s;\\n\\t\\t\\t\\tthis._z = ( m13 + m31 ) / s;\\n\\n\\t\\t\\t} else if ( m22 > m33 ) {\\n\\n\\t\\t\\t\\ts = 2.0 * Math.sqrt( 1.0 + m22 - m11 - m33 );\\n\\n\\t\\t\\t\\tthis._w = ( m13 - m31 ) / s;\\n\\t\\t\\t\\tthis._x = ( m12 + m21 ) / s;\\n\\t\\t\\t\\tthis._y = 0.25 * s;\\n\\t\\t\\t\\tthis._z = ( m23 + m32 ) / s;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\ts = 2.0 * Math.sqrt( 1.0 + m33 - m11 - m22 );\\n\\n\\t\\t\\t\\tthis._w = ( m21 - m12 ) / s;\\n\\t\\t\\t\\tthis._x = ( m13 + m31 ) / s;\\n\\t\\t\\t\\tthis._y = ( m23 + m32 ) / s;\\n\\t\\t\\t\\tthis._z = 0.25 * s;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromUnitVectors: function () {\\n\\n\\t\\t\\t// assumes direction vectors vFrom and vTo are normalized\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\t\\t\\tvar r;\\n\\n\\t\\t\\tvar EPS = 0.000001;\\n\\n\\t\\t\\treturn function setFromUnitVectors( vFrom, vTo ) {\\n\\n\\t\\t\\t\\tif ( v1 === undefined ) v1 = new Vector3();\\n\\n\\t\\t\\t\\tr = vFrom.dot( vTo ) + 1;\\n\\n\\t\\t\\t\\tif ( r < EPS ) {\\n\\n\\t\\t\\t\\t\\tr = 0;\\n\\n\\t\\t\\t\\t\\tif ( Math.abs( vFrom.x ) > Math.abs( vFrom.z ) ) {\\n\\n\\t\\t\\t\\t\\t\\tv1.set( - vFrom.y, vFrom.x, 0 );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tv1.set( 0, - vFrom.z, vFrom.y );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tv1.crossVectors( vFrom, vTo );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis._x = v1.x;\\n\\t\\t\\t\\tthis._y = v1.y;\\n\\t\\t\\t\\tthis._z = v1.z;\\n\\t\\t\\t\\tthis._w = r;\\n\\n\\t\\t\\t\\treturn this.normalize();\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tinverse: function () {\\n\\n\\t\\t\\treturn this.conjugate().normalize();\\n\\n\\t\\t},\\n\\n\\t\\tconjugate: function () {\\n\\n\\t\\t\\tthis._x *= - 1;\\n\\t\\t\\tthis._y *= - 1;\\n\\t\\t\\tthis._z *= - 1;\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdot: function ( v ) {\\n\\n\\t\\t\\treturn this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;\\n\\n\\t\\t},\\n\\n\\t\\tlengthSq: function () {\\n\\n\\t\\t\\treturn this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;\\n\\n\\t\\t},\\n\\n\\t\\tlength: function () {\\n\\n\\t\\t\\treturn Math.sqrt( this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w );\\n\\n\\t\\t},\\n\\n\\t\\tnormalize: function () {\\n\\n\\t\\t\\tvar l = this.length();\\n\\n\\t\\t\\tif ( l === 0 ) {\\n\\n\\t\\t\\t\\tthis._x = 0;\\n\\t\\t\\t\\tthis._y = 0;\\n\\t\\t\\t\\tthis._z = 0;\\n\\t\\t\\t\\tthis._w = 1;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tl = 1 / l;\\n\\n\\t\\t\\t\\tthis._x = this._x * l;\\n\\t\\t\\t\\tthis._y = this._y * l;\\n\\t\\t\\t\\tthis._z = this._z * l;\\n\\t\\t\\t\\tthis._w = this._w * l;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiply: function ( q, p ) {\\n\\n\\t\\t\\tif ( p !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.multiplyQuaternions( q, p );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this.multiplyQuaternions( this, q );\\n\\n\\t\\t},\\n\\n\\t\\tpremultiply: function ( q ) {\\n\\n\\t\\t\\treturn this.multiplyQuaternions( q, this );\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyQuaternions: function ( a, b ) {\\n\\n\\t\\t\\t// from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm\\n\\n\\t\\t\\tvar qax = a._x, qay = a._y, qaz = a._z, qaw = a._w;\\n\\t\\t\\tvar qbx = b._x, qby = b._y, qbz = b._z, qbw = b._w;\\n\\n\\t\\t\\tthis._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;\\n\\t\\t\\tthis._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;\\n\\t\\t\\tthis._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;\\n\\t\\t\\tthis._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tslerp: function ( qb, t ) {\\n\\n\\t\\t\\tif ( t === 0 ) return this;\\n\\t\\t\\tif ( t === 1 ) return this.copy( qb );\\n\\n\\t\\t\\tvar x = this._x, y = this._y, z = this._z, w = this._w;\\n\\n\\t\\t\\t// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/\\n\\n\\t\\t\\tvar cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;\\n\\n\\t\\t\\tif ( cosHalfTheta < 0 ) {\\n\\n\\t\\t\\t\\tthis._w = - qb._w;\\n\\t\\t\\t\\tthis._x = - qb._x;\\n\\t\\t\\t\\tthis._y = - qb._y;\\n\\t\\t\\t\\tthis._z = - qb._z;\\n\\n\\t\\t\\t\\tcosHalfTheta = - cosHalfTheta;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.copy( qb );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( cosHalfTheta >= 1.0 ) {\\n\\n\\t\\t\\t\\tthis._w = w;\\n\\t\\t\\t\\tthis._x = x;\\n\\t\\t\\t\\tthis._y = y;\\n\\t\\t\\t\\tthis._z = z;\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar sinHalfTheta = Math.sqrt( 1.0 - cosHalfTheta * cosHalfTheta );\\n\\n\\t\\t\\tif ( Math.abs( sinHalfTheta ) < 0.001 ) {\\n\\n\\t\\t\\t\\tthis._w = 0.5 * ( w + this._w );\\n\\t\\t\\t\\tthis._x = 0.5 * ( x + this._x );\\n\\t\\t\\t\\tthis._y = 0.5 * ( y + this._y );\\n\\t\\t\\t\\tthis._z = 0.5 * ( z + this._z );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar halfTheta = Math.atan2( sinHalfTheta, cosHalfTheta );\\n\\t\\t\\tvar ratioA = Math.sin( ( 1 - t ) * halfTheta ) / sinHalfTheta,\\n\\t\\t\\t\\tratioB = Math.sin( t * halfTheta ) / sinHalfTheta;\\n\\n\\t\\t\\tthis._w = ( w * ratioA + this._w * ratioB );\\n\\t\\t\\tthis._x = ( x * ratioA + this._x * ratioB );\\n\\t\\t\\tthis._y = ( y * ratioA + this._y * ratioB );\\n\\t\\t\\tthis._z = ( z * ratioA + this._z * ratioB );\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( quaternion ) {\\n\\n\\t\\t\\treturn ( quaternion._x === this._x ) && ( quaternion._y === this._y ) && ( quaternion._z === this._z ) && ( quaternion._w === this._w );\\n\\n\\t\\t},\\n\\n\\t\\tfromArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tthis._x = array[ offset ];\\n\\t\\t\\tthis._y = array[ offset + 1 ];\\n\\t\\t\\tthis._z = array[ offset + 2 ];\\n\\t\\t\\tthis._w = array[ offset + 3 ];\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( array === undefined ) array = [];\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tarray[ offset ] = this._x;\\n\\t\\t\\tarray[ offset + 1 ] = this._y;\\n\\t\\t\\tarray[ offset + 2 ] = this._z;\\n\\t\\t\\tarray[ offset + 3 ] = this._w;\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t},\\n\\n\\t\\tonChange: function ( callback ) {\\n\\n\\t\\t\\tthis.onChangeCallback = callback;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tonChangeCallback: function () {}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author kile / http://kile.stravaganza.org/\\n\\t * @author philogb / http://blog.thejit.org/\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author egraether / http://egraether.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction Vector3( x, y, z ) {\\n\\n\\t\\tthis.x = x || 0;\\n\\t\\tthis.y = y || 0;\\n\\t\\tthis.z = z || 0;\\n\\n\\t}\\n\\n\\tObject.assign( Vector3.prototype, {\\n\\n\\t\\tisVector3: true,\\n\\n\\t\\tset: function ( x, y, z ) {\\n\\n\\t\\t\\tthis.x = x;\\n\\t\\t\\tthis.y = y;\\n\\t\\t\\tthis.z = z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.x = scalar;\\n\\t\\t\\tthis.y = scalar;\\n\\t\\t\\tthis.z = scalar;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetX: function ( x ) {\\n\\n\\t\\t\\tthis.x = x;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetY: function ( y ) {\\n\\n\\t\\t\\tthis.y = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetZ: function ( z ) {\\n\\n\\t\\t\\tthis.z = z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetComponent: function ( index, value ) {\\n\\n\\t\\t\\tswitch ( index ) {\\n\\n\\t\\t\\t\\tcase 0: this.x = value; break;\\n\\t\\t\\t\\tcase 1: this.y = value; break;\\n\\t\\t\\t\\tcase 2: this.z = value; break;\\n\\t\\t\\t\\tdefault: throw new Error( 'index is out of range: ' + index );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetComponent: function ( index ) {\\n\\n\\t\\t\\tswitch ( index ) {\\n\\n\\t\\t\\t\\tcase 0: return this.x;\\n\\t\\t\\t\\tcase 1: return this.y;\\n\\t\\t\\t\\tcase 2: return this.z;\\n\\t\\t\\t\\tdefault: throw new Error( 'index is out of range: ' + index );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.x, this.y, this.z );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( v ) {\\n\\n\\t\\t\\tthis.x = v.x;\\n\\t\\t\\tthis.y = v.y;\\n\\t\\t\\tthis.z = v.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tadd: function ( v, w ) {\\n\\n\\t\\t\\tif ( w !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.addVectors( v, w );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x += v.x;\\n\\t\\t\\tthis.y += v.y;\\n\\t\\t\\tthis.z += v.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddScalar: function ( s ) {\\n\\n\\t\\t\\tthis.x += s;\\n\\t\\t\\tthis.y += s;\\n\\t\\t\\tthis.z += s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddVectors: function ( a, b ) {\\n\\n\\t\\t\\tthis.x = a.x + b.x;\\n\\t\\t\\tthis.y = a.y + b.y;\\n\\t\\t\\tthis.z = a.z + b.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddScaledVector: function ( v, s ) {\\n\\n\\t\\t\\tthis.x += v.x * s;\\n\\t\\t\\tthis.y += v.y * s;\\n\\t\\t\\tthis.z += v.z * s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsub: function ( v, w ) {\\n\\n\\t\\t\\tif ( w !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.subVectors( v, w );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x -= v.x;\\n\\t\\t\\tthis.y -= v.y;\\n\\t\\t\\tthis.z -= v.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsubScalar: function ( s ) {\\n\\n\\t\\t\\tthis.x -= s;\\n\\t\\t\\tthis.y -= s;\\n\\t\\t\\tthis.z -= s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsubVectors: function ( a, b ) {\\n\\n\\t\\t\\tthis.x = a.x - b.x;\\n\\t\\t\\tthis.y = a.y - b.y;\\n\\t\\t\\tthis.z = a.z - b.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiply: function ( v, w ) {\\n\\n\\t\\t\\tif ( w !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.multiplyVectors( v, w );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x *= v.x;\\n\\t\\t\\tthis.y *= v.y;\\n\\t\\t\\tthis.z *= v.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.x *= scalar;\\n\\t\\t\\tthis.y *= scalar;\\n\\t\\t\\tthis.z *= scalar;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyVectors: function ( a, b ) {\\n\\n\\t\\t\\tthis.x = a.x * b.x;\\n\\t\\t\\tthis.y = a.y * b.y;\\n\\t\\t\\tthis.z = a.z * b.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tapplyEuler: function () {\\n\\n\\t\\t\\tvar quaternion = new Quaternion();\\n\\n\\t\\t\\treturn function applyEuler( euler ) {\\n\\n\\t\\t\\t\\tif ( ! ( euler && euler.isEuler ) ) {\\n\\n\\t\\t\\t\\t\\tconsole.error( 'THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order.' );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn this.applyQuaternion( quaternion.setFromEuler( euler ) );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tapplyAxisAngle: function () {\\n\\n\\t\\t\\tvar quaternion = new Quaternion();\\n\\n\\t\\t\\treturn function applyAxisAngle( axis, angle ) {\\n\\n\\t\\t\\t\\treturn this.applyQuaternion( quaternion.setFromAxisAngle( axis, angle ) );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tapplyMatrix3: function ( m ) {\\n\\n\\t\\t\\tvar x = this.x, y = this.y, z = this.z;\\n\\t\\t\\tvar e = m.elements;\\n\\n\\t\\t\\tthis.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ] * z;\\n\\t\\t\\tthis.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ] * z;\\n\\t\\t\\tthis.z = e[ 2 ] * x + e[ 5 ] * y + e[ 8 ] * z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tapplyMatrix4: function ( m ) {\\n\\n\\t\\t\\tvar x = this.x, y = this.y, z = this.z;\\n\\t\\t\\tvar e = m.elements;\\n\\n\\t\\t\\tvar w = 1 / ( e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] );\\n\\n\\t\\t\\tthis.x = ( e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] ) * w;\\n\\t\\t\\tthis.y = ( e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] ) * w;\\n\\t\\t\\tthis.z = ( e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] ) * w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tapplyQuaternion: function ( q ) {\\n\\n\\t\\t\\tvar x = this.x, y = this.y, z = this.z;\\n\\t\\t\\tvar qx = q.x, qy = q.y, qz = q.z, qw = q.w;\\n\\n\\t\\t\\t// calculate quat * vector\\n\\n\\t\\t\\tvar ix = qw * x + qy * z - qz * y;\\n\\t\\t\\tvar iy = qw * y + qz * x - qx * z;\\n\\t\\t\\tvar iz = qw * z + qx * y - qy * x;\\n\\t\\t\\tvar iw = - qx * x - qy * y - qz * z;\\n\\n\\t\\t\\t// calculate result * inverse quat\\n\\n\\t\\t\\tthis.x = ix * qw + iw * - qx + iy * - qz - iz * - qy;\\n\\t\\t\\tthis.y = iy * qw + iw * - qy + iz * - qx - ix * - qz;\\n\\t\\t\\tthis.z = iz * qw + iw * - qz + ix * - qy - iy * - qx;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tproject: function () {\\n\\n\\t\\t\\tvar matrix = new Matrix4();\\n\\n\\t\\t\\treturn function project( camera ) {\\n\\n\\t\\t\\t\\tmatrix.multiplyMatrices( camera.projectionMatrix, matrix.getInverse( camera.matrixWorld ) );\\n\\t\\t\\t\\treturn this.applyMatrix4( matrix );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tunproject: function () {\\n\\n\\t\\t\\tvar matrix = new Matrix4();\\n\\n\\t\\t\\treturn function unproject( camera ) {\\n\\n\\t\\t\\t\\tmatrix.multiplyMatrices( camera.matrixWorld, matrix.getInverse( camera.projectionMatrix ) );\\n\\t\\t\\t\\treturn this.applyMatrix4( matrix );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttransformDirection: function ( m ) {\\n\\n\\t\\t\\t// input: THREE.Matrix4 affine matrix\\n\\t\\t\\t// vector interpreted as a direction\\n\\n\\t\\t\\tvar x = this.x, y = this.y, z = this.z;\\n\\t\\t\\tvar e = m.elements;\\n\\n\\t\\t\\tthis.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z;\\n\\t\\t\\tthis.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z;\\n\\t\\t\\tthis.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z;\\n\\n\\t\\t\\treturn this.normalize();\\n\\n\\t\\t},\\n\\n\\t\\tdivide: function ( v ) {\\n\\n\\t\\t\\tthis.x /= v.x;\\n\\t\\t\\tthis.y /= v.y;\\n\\t\\t\\tthis.z /= v.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdivideScalar: function ( scalar ) {\\n\\n\\t\\t\\treturn this.multiplyScalar( 1 / scalar );\\n\\n\\t\\t},\\n\\n\\t\\tmin: function ( v ) {\\n\\n\\t\\t\\tthis.x = Math.min( this.x, v.x );\\n\\t\\t\\tthis.y = Math.min( this.y, v.y );\\n\\t\\t\\tthis.z = Math.min( this.z, v.z );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmax: function ( v ) {\\n\\n\\t\\t\\tthis.x = Math.max( this.x, v.x );\\n\\t\\t\\tthis.y = Math.max( this.y, v.y );\\n\\t\\t\\tthis.z = Math.max( this.z, v.z );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclamp: function ( min, max ) {\\n\\n\\t\\t\\t// assumes min < max, componentwise\\n\\n\\t\\t\\tthis.x = Math.max( min.x, Math.min( max.x, this.x ) );\\n\\t\\t\\tthis.y = Math.max( min.y, Math.min( max.y, this.y ) );\\n\\t\\t\\tthis.z = Math.max( min.z, Math.min( max.z, this.z ) );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclampScalar: function () {\\n\\n\\t\\t\\tvar min = new Vector3();\\n\\t\\t\\tvar max = new Vector3();\\n\\n\\t\\t\\treturn function clampScalar( minVal, maxVal ) {\\n\\n\\t\\t\\t\\tmin.set( minVal, minVal, minVal );\\n\\t\\t\\t\\tmax.set( maxVal, maxVal, maxVal );\\n\\n\\t\\t\\t\\treturn this.clamp( min, max );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tclampLength: function ( min, max ) {\\n\\n\\t\\t\\tvar length = this.length();\\n\\n\\t\\t\\treturn this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );\\n\\n\\t\\t},\\n\\n\\t\\tfloor: function () {\\n\\n\\t\\t\\tthis.x = Math.floor( this.x );\\n\\t\\t\\tthis.y = Math.floor( this.y );\\n\\t\\t\\tthis.z = Math.floor( this.z );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tceil: function () {\\n\\n\\t\\t\\tthis.x = Math.ceil( this.x );\\n\\t\\t\\tthis.y = Math.ceil( this.y );\\n\\t\\t\\tthis.z = Math.ceil( this.z );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tround: function () {\\n\\n\\t\\t\\tthis.x = Math.round( this.x );\\n\\t\\t\\tthis.y = Math.round( this.y );\\n\\t\\t\\tthis.z = Math.round( this.z );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\troundToZero: function () {\\n\\n\\t\\t\\tthis.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );\\n\\t\\t\\tthis.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );\\n\\t\\t\\tthis.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tnegate: function () {\\n\\n\\t\\t\\tthis.x = - this.x;\\n\\t\\t\\tthis.y = - this.y;\\n\\t\\t\\tthis.z = - this.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdot: function ( v ) {\\n\\n\\t\\t\\treturn this.x * v.x + this.y * v.y + this.z * v.z;\\n\\n\\t\\t},\\n\\n\\t\\t// TODO lengthSquared?\\n\\n\\t\\tlengthSq: function () {\\n\\n\\t\\t\\treturn this.x * this.x + this.y * this.y + this.z * this.z;\\n\\n\\t\\t},\\n\\n\\t\\tlength: function () {\\n\\n\\t\\t\\treturn Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z );\\n\\n\\t\\t},\\n\\n\\t\\tmanhattanLength: function () {\\n\\n\\t\\t\\treturn Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z );\\n\\n\\t\\t},\\n\\n\\t\\tnormalize: function () {\\n\\n\\t\\t\\treturn this.divideScalar( this.length() || 1 );\\n\\n\\t\\t},\\n\\n\\t\\tsetLength: function ( length ) {\\n\\n\\t\\t\\treturn this.normalize().multiplyScalar( length );\\n\\n\\t\\t},\\n\\n\\t\\tlerp: function ( v, alpha ) {\\n\\n\\t\\t\\tthis.x += ( v.x - this.x ) * alpha;\\n\\t\\t\\tthis.y += ( v.y - this.y ) * alpha;\\n\\t\\t\\tthis.z += ( v.z - this.z ) * alpha;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tlerpVectors: function ( v1, v2, alpha ) {\\n\\n\\t\\t\\treturn this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );\\n\\n\\t\\t},\\n\\n\\t\\tcross: function ( v, w ) {\\n\\n\\t\\t\\tif ( w !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.crossVectors( v, w );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this.crossVectors( this, v );\\n\\n\\t\\t},\\n\\n\\t\\tcrossVectors: function ( a, b ) {\\n\\n\\t\\t\\tvar ax = a.x, ay = a.y, az = a.z;\\n\\t\\t\\tvar bx = b.x, by = b.y, bz = b.z;\\n\\n\\t\\t\\tthis.x = ay * bz - az * by;\\n\\t\\t\\tthis.y = az * bx - ax * bz;\\n\\t\\t\\tthis.z = ax * by - ay * bx;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tprojectOnVector: function ( vector ) {\\n\\n\\t\\t\\tvar scalar = vector.dot( this ) / vector.lengthSq();\\n\\n\\t\\t\\treturn this.copy( vector ).multiplyScalar( scalar );\\n\\n\\t\\t},\\n\\n\\t\\tprojectOnPlane: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function projectOnPlane( planeNormal ) {\\n\\n\\t\\t\\t\\tv1.copy( this ).projectOnVector( planeNormal );\\n\\n\\t\\t\\t\\treturn this.sub( v1 );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\treflect: function () {\\n\\n\\t\\t\\t// reflect incident vector off plane orthogonal to normal\\n\\t\\t\\t// normal is assumed to have unit length\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function reflect( normal ) {\\n\\n\\t\\t\\t\\treturn this.sub( v1.copy( normal ).multiplyScalar( 2 * this.dot( normal ) ) );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tangleTo: function ( v ) {\\n\\n\\t\\t\\tvar theta = this.dot( v ) / ( Math.sqrt( this.lengthSq() * v.lengthSq() ) );\\n\\n\\t\\t\\t// clamp, to handle numerical problems\\n\\n\\t\\t\\treturn Math.acos( _Math.clamp( theta, - 1, 1 ) );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceTo: function ( v ) {\\n\\n\\t\\t\\treturn Math.sqrt( this.distanceToSquared( v ) );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToSquared: function ( v ) {\\n\\n\\t\\t\\tvar dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;\\n\\n\\t\\t\\treturn dx * dx + dy * dy + dz * dz;\\n\\n\\t\\t},\\n\\n\\t\\tmanhattanDistanceTo: function ( v ) {\\n\\n\\t\\t\\treturn Math.abs( this.x - v.x ) + Math.abs( this.y - v.y ) + Math.abs( this.z - v.z );\\n\\n\\t\\t},\\n\\n\\t\\tsetFromSpherical: function ( s ) {\\n\\n\\t\\t\\tvar sinPhiRadius = Math.sin( s.phi ) * s.radius;\\n\\n\\t\\t\\tthis.x = sinPhiRadius * Math.sin( s.theta );\\n\\t\\t\\tthis.y = Math.cos( s.phi ) * s.radius;\\n\\t\\t\\tthis.z = sinPhiRadius * Math.cos( s.theta );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromCylindrical: function ( c ) {\\n\\n\\t\\t\\tthis.x = c.radius * Math.sin( c.theta );\\n\\t\\t\\tthis.y = c.y;\\n\\t\\t\\tthis.z = c.radius * Math.cos( c.theta );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromMatrixPosition: function ( m ) {\\n\\n\\t\\t\\tvar e = m.elements;\\n\\n\\t\\t\\tthis.x = e[ 12 ];\\n\\t\\t\\tthis.y = e[ 13 ];\\n\\t\\t\\tthis.z = e[ 14 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromMatrixScale: function ( m ) {\\n\\n\\t\\t\\tvar sx = this.setFromMatrixColumn( m, 0 ).length();\\n\\t\\t\\tvar sy = this.setFromMatrixColumn( m, 1 ).length();\\n\\t\\t\\tvar sz = this.setFromMatrixColumn( m, 2 ).length();\\n\\n\\t\\t\\tthis.x = sx;\\n\\t\\t\\tthis.y = sy;\\n\\t\\t\\tthis.z = sz;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromMatrixColumn: function ( m, index ) {\\n\\n\\t\\t\\treturn this.fromArray( m.elements, index * 4 );\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( v ) {\\n\\n\\t\\t\\treturn ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) );\\n\\n\\t\\t},\\n\\n\\t\\tfromArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tthis.x = array[ offset ];\\n\\t\\t\\tthis.y = array[ offset + 1 ];\\n\\t\\t\\tthis.z = array[ offset + 2 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( array === undefined ) array = [];\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tarray[ offset ] = this.x;\\n\\t\\t\\tarray[ offset + 1 ] = this.y;\\n\\t\\t\\tarray[ offset + 2 ] = this.z;\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t},\\n\\n\\t\\tfromBufferAttribute: function ( attribute, index, offset ) {\\n\\n\\t\\t\\tif ( offset !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector3: offset has been removed from .fromBufferAttribute().' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x = attribute.getX( index );\\n\\t\\t\\tthis.y = attribute.getY( index );\\n\\t\\t\\tthis.z = attribute.getZ( index );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t * @author bhouston / http://clara.io\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction Matrix3() {\\n\\n\\t\\tthis.elements = [\\n\\n\\t\\t\\t1, 0, 0,\\n\\t\\t\\t0, 1, 0,\\n\\t\\t\\t0, 0, 1\\n\\n\\t\\t];\\n\\n\\t\\tif ( arguments.length > 0 ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.' );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tObject.assign( Matrix3.prototype, {\\n\\n\\t\\tisMatrix3: true,\\n\\n\\t\\tset: function ( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tte[ 0 ] = n11; te[ 1 ] = n21; te[ 2 ] = n31;\\n\\t\\t\\tte[ 3 ] = n12; te[ 4 ] = n22; te[ 5 ] = n32;\\n\\t\\t\\tte[ 6 ] = n13; te[ 7 ] = n23; te[ 8 ] = n33;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tidentity: function () {\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\t1, 0, 0,\\n\\t\\t\\t\\t0, 1, 0,\\n\\t\\t\\t\\t0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().fromArray( this.elements );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( m ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\t\\t\\tvar me = m.elements;\\n\\n\\t\\t\\tte[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ];\\n\\t\\t\\tte[ 3 ] = me[ 3 ]; te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ];\\n\\t\\t\\tte[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ]; te[ 8 ] = me[ 8 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromMatrix4: function ( m ) {\\n\\n\\t\\t\\tvar me = m.elements;\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\tme[ 0 ], me[ 4 ], me[ 8 ],\\n\\t\\t\\t\\tme[ 1 ], me[ 5 ], me[ 9 ],\\n\\t\\t\\t\\tme[ 2 ], me[ 6 ], me[ 10 ]\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tapplyToBufferAttribute: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function applyToBufferAttribute( attribute ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = attribute.count; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tv1.x = attribute.getX( i );\\n\\t\\t\\t\\t\\tv1.y = attribute.getY( i );\\n\\t\\t\\t\\t\\tv1.z = attribute.getZ( i );\\n\\n\\t\\t\\t\\t\\tv1.applyMatrix3( this );\\n\\n\\t\\t\\t\\t\\tattribute.setXYZ( i, v1.x, v1.y, v1.z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn attribute;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tmultiply: function ( m ) {\\n\\n\\t\\t\\treturn this.multiplyMatrices( this, m );\\n\\n\\t\\t},\\n\\n\\t\\tpremultiply: function ( m ) {\\n\\n\\t\\t\\treturn this.multiplyMatrices( m, this );\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyMatrices: function ( a, b ) {\\n\\n\\t\\t\\tvar ae = a.elements;\\n\\t\\t\\tvar be = b.elements;\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tvar a11 = ae[ 0 ], a12 = ae[ 3 ], a13 = ae[ 6 ];\\n\\t\\t\\tvar a21 = ae[ 1 ], a22 = ae[ 4 ], a23 = ae[ 7 ];\\n\\t\\t\\tvar a31 = ae[ 2 ], a32 = ae[ 5 ], a33 = ae[ 8 ];\\n\\n\\t\\t\\tvar b11 = be[ 0 ], b12 = be[ 3 ], b13 = be[ 6 ];\\n\\t\\t\\tvar b21 = be[ 1 ], b22 = be[ 4 ], b23 = be[ 7 ];\\n\\t\\t\\tvar b31 = be[ 2 ], b32 = be[ 5 ], b33 = be[ 8 ];\\n\\n\\t\\t\\tte[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31;\\n\\t\\t\\tte[ 3 ] = a11 * b12 + a12 * b22 + a13 * b32;\\n\\t\\t\\tte[ 6 ] = a11 * b13 + a12 * b23 + a13 * b33;\\n\\n\\t\\t\\tte[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31;\\n\\t\\t\\tte[ 4 ] = a21 * b12 + a22 * b22 + a23 * b32;\\n\\t\\t\\tte[ 7 ] = a21 * b13 + a22 * b23 + a23 * b33;\\n\\n\\t\\t\\tte[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31;\\n\\t\\t\\tte[ 5 ] = a31 * b12 + a32 * b22 + a33 * b32;\\n\\t\\t\\tte[ 8 ] = a31 * b13 + a32 * b23 + a33 * b33;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyScalar: function ( s ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tte[ 0 ] *= s; te[ 3 ] *= s; te[ 6 ] *= s;\\n\\t\\t\\tte[ 1 ] *= s; te[ 4 ] *= s; te[ 7 ] *= s;\\n\\t\\t\\tte[ 2 ] *= s; te[ 5 ] *= s; te[ 8 ] *= s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdeterminant: function () {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tvar a = te[ 0 ], b = te[ 1 ], c = te[ 2 ],\\n\\t\\t\\t\\td = te[ 3 ], e = te[ 4 ], f = te[ 5 ],\\n\\t\\t\\t\\tg = te[ 6 ], h = te[ 7 ], i = te[ 8 ];\\n\\n\\t\\t\\treturn a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g;\\n\\n\\t\\t},\\n\\n\\t\\tgetInverse: function ( matrix, throwOnDegenerate ) {\\n\\n\\t\\t\\tif ( matrix && matrix.isMatrix4 ) {\\n\\n\\t\\t\\t\\tconsole.error( \\\"THREE.Matrix3: .getInverse() no longer takes a Matrix4 argument.\\\" );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar me = matrix.elements,\\n\\t\\t\\t\\tte = this.elements,\\n\\n\\t\\t\\t\\tn11 = me[ 0 ], n21 = me[ 1 ], n31 = me[ 2 ],\\n\\t\\t\\t\\tn12 = me[ 3 ], n22 = me[ 4 ], n32 = me[ 5 ],\\n\\t\\t\\t\\tn13 = me[ 6 ], n23 = me[ 7 ], n33 = me[ 8 ],\\n\\n\\t\\t\\t\\tt11 = n33 * n22 - n32 * n23,\\n\\t\\t\\t\\tt12 = n32 * n13 - n33 * n12,\\n\\t\\t\\t\\tt13 = n23 * n12 - n22 * n13,\\n\\n\\t\\t\\t\\tdet = n11 * t11 + n21 * t12 + n31 * t13;\\n\\n\\t\\t\\tif ( det === 0 ) {\\n\\n\\t\\t\\t\\tvar msg = \\\"THREE.Matrix3: .getInverse() can't invert matrix, determinant is 0\\\";\\n\\n\\t\\t\\t\\tif ( throwOnDegenerate === true ) {\\n\\n\\t\\t\\t\\t\\tthrow new Error( msg );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tconsole.warn( msg );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn this.identity();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar detInv = 1 / det;\\n\\n\\t\\t\\tte[ 0 ] = t11 * detInv;\\n\\t\\t\\tte[ 1 ] = ( n31 * n23 - n33 * n21 ) * detInv;\\n\\t\\t\\tte[ 2 ] = ( n32 * n21 - n31 * n22 ) * detInv;\\n\\n\\t\\t\\tte[ 3 ] = t12 * detInv;\\n\\t\\t\\tte[ 4 ] = ( n33 * n11 - n31 * n13 ) * detInv;\\n\\t\\t\\tte[ 5 ] = ( n31 * n12 - n32 * n11 ) * detInv;\\n\\n\\t\\t\\tte[ 6 ] = t13 * detInv;\\n\\t\\t\\tte[ 7 ] = ( n21 * n13 - n23 * n11 ) * detInv;\\n\\t\\t\\tte[ 8 ] = ( n22 * n11 - n21 * n12 ) * detInv;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttranspose: function () {\\n\\n\\t\\t\\tvar tmp, m = this.elements;\\n\\n\\t\\t\\ttmp = m[ 1 ]; m[ 1 ] = m[ 3 ]; m[ 3 ] = tmp;\\n\\t\\t\\ttmp = m[ 2 ]; m[ 2 ] = m[ 6 ]; m[ 6 ] = tmp;\\n\\t\\t\\ttmp = m[ 5 ]; m[ 5 ] = m[ 7 ]; m[ 7 ] = tmp;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetNormalMatrix: function ( matrix4 ) {\\n\\n\\t\\t\\treturn this.setFromMatrix4( matrix4 ).getInverse( this ).transpose();\\n\\n\\t\\t},\\n\\n\\t\\ttransposeIntoArray: function ( r ) {\\n\\n\\t\\t\\tvar m = this.elements;\\n\\n\\t\\t\\tr[ 0 ] = m[ 0 ];\\n\\t\\t\\tr[ 1 ] = m[ 3 ];\\n\\t\\t\\tr[ 2 ] = m[ 6 ];\\n\\t\\t\\tr[ 3 ] = m[ 1 ];\\n\\t\\t\\tr[ 4 ] = m[ 4 ];\\n\\t\\t\\tr[ 5 ] = m[ 7 ];\\n\\t\\t\\tr[ 6 ] = m[ 2 ];\\n\\t\\t\\tr[ 7 ] = m[ 5 ];\\n\\t\\t\\tr[ 8 ] = m[ 8 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetUvTransform: function ( tx, ty, sx, sy, rotation, cx, cy ) {\\n\\n\\t\\t\\tvar c = Math.cos( rotation );\\n\\t\\t\\tvar s = Math.sin( rotation );\\n\\n\\t\\t\\tthis.set(\\n\\t\\t\\t\\tsx * c, sx * s, - sx * ( c * cx + s * cy ) + cx + tx,\\n\\t\\t\\t\\t- sy * s, sy * c, - sy * ( - s * cx + c * cy ) + cy + ty,\\n\\t\\t\\t\\t0, 0, 1\\n\\t\\t\\t);\\n\\n\\t\\t},\\n\\n\\t\\tscale: function ( sx, sy ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tte[ 0 ] *= sx; te[ 3 ] *= sx; te[ 6 ] *= sx;\\n\\t\\t\\tte[ 1 ] *= sy; te[ 4 ] *= sy; te[ 7 ] *= sy;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\trotate: function ( theta ) {\\n\\n\\t\\t\\tvar c = Math.cos( theta );\\n\\t\\t\\tvar s = Math.sin( theta );\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tvar a11 = te[ 0 ], a12 = te[ 3 ], a13 = te[ 6 ];\\n\\t\\t\\tvar a21 = te[ 1 ], a22 = te[ 4 ], a23 = te[ 7 ];\\n\\n\\t\\t\\tte[ 0 ] = c * a11 + s * a21;\\n\\t\\t\\tte[ 3 ] = c * a12 + s * a22;\\n\\t\\t\\tte[ 6 ] = c * a13 + s * a23;\\n\\n\\t\\t\\tte[ 1 ] = - s * a11 + c * a21;\\n\\t\\t\\tte[ 4 ] = - s * a12 + c * a22;\\n\\t\\t\\tte[ 7 ] = - s * a13 + c * a23;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttranslate: function ( tx, ty ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tte[ 0 ] += tx * te[ 2 ]; te[ 3 ] += tx * te[ 5 ]; te[ 6 ] += tx * te[ 8 ];\\n\\t\\t\\tte[ 1 ] += ty * te[ 2 ]; te[ 4 ] += ty * te[ 5 ]; te[ 7 ] += ty * te[ 8 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( matrix ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\t\\t\\tvar me = matrix.elements;\\n\\n\\t\\t\\tfor ( var i = 0; i < 9; i ++ ) {\\n\\n\\t\\t\\t\\tif ( te[ i ] !== me[ i ] ) return false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn true;\\n\\n\\t\\t},\\n\\n\\t\\tfromArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tfor ( var i = 0; i < 9; i ++ ) {\\n\\n\\t\\t\\t\\tthis.elements[ i ] = array[ i + offset ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( array === undefined ) array = [];\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tarray[ offset ] = te[ 0 ];\\n\\t\\t\\tarray[ offset + 1 ] = te[ 1 ];\\n\\t\\t\\tarray[ offset + 2 ] = te[ 2 ];\\n\\n\\t\\t\\tarray[ offset + 3 ] = te[ 3 ];\\n\\t\\t\\tarray[ offset + 4 ] = te[ 4 ];\\n\\t\\t\\tarray[ offset + 5 ] = te[ 5 ];\\n\\n\\t\\t\\tarray[ offset + 6 ] = te[ 6 ];\\n\\t\\t\\tarray[ offset + 7 ] = te[ 7 ];\\n\\t\\t\\tarray[ offset + 8 ] = te[ 8 ];\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author szimek / https://github.com/szimek/\\n\\t */\\n\\n\\tvar textureId = 0;\\n\\n\\tfunction Texture( image, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding ) {\\n\\n\\t\\tObject.defineProperty( this, 'id', { value: textureId ++ } );\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.name = '';\\n\\n\\t\\tthis.image = image !== undefined ? image : Texture.DEFAULT_IMAGE;\\n\\t\\tthis.mipmaps = [];\\n\\n\\t\\tthis.mapping = mapping !== undefined ? mapping : Texture.DEFAULT_MAPPING;\\n\\n\\t\\tthis.wrapS = wrapS !== undefined ? wrapS : ClampToEdgeWrapping;\\n\\t\\tthis.wrapT = wrapT !== undefined ? wrapT : ClampToEdgeWrapping;\\n\\n\\t\\tthis.magFilter = magFilter !== undefined ? magFilter : LinearFilter;\\n\\t\\tthis.minFilter = minFilter !== undefined ? minFilter : LinearMipMapLinearFilter;\\n\\n\\t\\tthis.anisotropy = anisotropy !== undefined ? anisotropy : 1;\\n\\n\\t\\tthis.format = format !== undefined ? format : RGBAFormat;\\n\\t\\tthis.type = type !== undefined ? type : UnsignedByteType;\\n\\n\\t\\tthis.offset = new Vector2( 0, 0 );\\n\\t\\tthis.repeat = new Vector2( 1, 1 );\\n\\t\\tthis.center = new Vector2( 0, 0 );\\n\\t\\tthis.rotation = 0;\\n\\n\\t\\tthis.matrixAutoUpdate = true;\\n\\t\\tthis.matrix = new Matrix3();\\n\\n\\t\\tthis.generateMipmaps = true;\\n\\t\\tthis.premultiplyAlpha = false;\\n\\t\\tthis.flipY = true;\\n\\t\\tthis.unpackAlignment = 4;\\t// valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)\\n\\n\\t\\t// Values of encoding !== THREE.LinearEncoding only supported on map, envMap and emissiveMap.\\n\\t\\t//\\n\\t\\t// Also changing the encoding after already used by a Material will not automatically make the Material\\n\\t\\t// update. You need to explicitly call Material.needsUpdate to trigger it to recompile.\\n\\t\\tthis.encoding = encoding !== undefined ? encoding : LinearEncoding;\\n\\n\\t\\tthis.version = 0;\\n\\t\\tthis.onUpdate = null;\\n\\n\\t}\\n\\n\\tTexture.DEFAULT_IMAGE = undefined;\\n\\tTexture.DEFAULT_MAPPING = UVMapping;\\n\\n\\tTexture.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {\\n\\n\\t\\tconstructor: Texture,\\n\\n\\t\\tisTexture: true,\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tthis.name = source.name;\\n\\n\\t\\t\\tthis.image = source.image;\\n\\t\\t\\tthis.mipmaps = source.mipmaps.slice( 0 );\\n\\n\\t\\t\\tthis.mapping = source.mapping;\\n\\n\\t\\t\\tthis.wrapS = source.wrapS;\\n\\t\\t\\tthis.wrapT = source.wrapT;\\n\\n\\t\\t\\tthis.magFilter = source.magFilter;\\n\\t\\t\\tthis.minFilter = source.minFilter;\\n\\n\\t\\t\\tthis.anisotropy = source.anisotropy;\\n\\n\\t\\t\\tthis.format = source.format;\\n\\t\\t\\tthis.type = source.type;\\n\\n\\t\\t\\tthis.offset.copy( source.offset );\\n\\t\\t\\tthis.repeat.copy( source.repeat );\\n\\t\\t\\tthis.center.copy( source.center );\\n\\t\\t\\tthis.rotation = source.rotation;\\n\\n\\t\\t\\tthis.matrixAutoUpdate = source.matrixAutoUpdate;\\n\\t\\t\\tthis.matrix.copy( source.matrix );\\n\\n\\t\\t\\tthis.generateMipmaps = source.generateMipmaps;\\n\\t\\t\\tthis.premultiplyAlpha = source.premultiplyAlpha;\\n\\t\\t\\tthis.flipY = source.flipY;\\n\\t\\t\\tthis.unpackAlignment = source.unpackAlignment;\\n\\t\\t\\tthis.encoding = source.encoding;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\tvar isRootObject = ( meta === undefined || typeof meta === 'string' );\\n\\n\\t\\t\\tif ( ! isRootObject && meta.textures[ this.uuid ] !== undefined ) {\\n\\n\\t\\t\\t\\treturn meta.textures[ this.uuid ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction getDataURL( image ) {\\n\\n\\t\\t\\t\\tvar canvas;\\n\\n\\t\\t\\t\\tif ( image instanceof HTMLCanvasElement ) {\\n\\n\\t\\t\\t\\t\\tcanvas = image;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tcanvas = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' );\\n\\t\\t\\t\\t\\tcanvas.width = image.width;\\n\\t\\t\\t\\t\\tcanvas.height = image.height;\\n\\n\\t\\t\\t\\t\\tvar context = canvas.getContext( '2d' );\\n\\n\\t\\t\\t\\t\\tif ( image instanceof ImageData ) {\\n\\n\\t\\t\\t\\t\\t\\tcontext.putImageData( image, 0, 0 );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tcontext.drawImage( image, 0, 0, image.width, image.height );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( canvas.width > 2048 || canvas.height > 2048 ) {\\n\\n\\t\\t\\t\\t\\treturn canvas.toDataURL( 'image/jpeg', 0.6 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\treturn canvas.toDataURL( 'image/png' );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar output = {\\n\\t\\t\\t\\tmetadata: {\\n\\t\\t\\t\\t\\tversion: 4.5,\\n\\t\\t\\t\\t\\ttype: 'Texture',\\n\\t\\t\\t\\t\\tgenerator: 'Texture.toJSON'\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tuuid: this.uuid,\\n\\t\\t\\t\\tname: this.name,\\n\\n\\t\\t\\t\\tmapping: this.mapping,\\n\\n\\t\\t\\t\\trepeat: [ this.repeat.x, this.repeat.y ],\\n\\t\\t\\t\\toffset: [ this.offset.x, this.offset.y ],\\n\\t\\t\\t\\tcenter: [ this.center.x, this.center.y ],\\n\\t\\t\\t\\trotation: this.rotation,\\n\\n\\t\\t\\t\\twrap: [ this.wrapS, this.wrapT ],\\n\\n\\t\\t\\t\\tminFilter: this.minFilter,\\n\\t\\t\\t\\tmagFilter: this.magFilter,\\n\\t\\t\\t\\tanisotropy: this.anisotropy,\\n\\n\\t\\t\\t\\tflipY: this.flipY\\n\\t\\t\\t};\\n\\n\\t\\t\\tif ( this.image !== undefined ) {\\n\\n\\t\\t\\t\\t// TODO: Move to THREE.Image\\n\\n\\t\\t\\t\\tvar image = this.image;\\n\\n\\t\\t\\t\\tif ( image.uuid === undefined ) {\\n\\n\\t\\t\\t\\t\\timage.uuid = _Math.generateUUID(); // UGH\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( ! isRootObject && meta.images[ image.uuid ] === undefined ) {\\n\\n\\t\\t\\t\\t\\tmeta.images[ image.uuid ] = {\\n\\t\\t\\t\\t\\t\\tuuid: image.uuid,\\n\\t\\t\\t\\t\\t\\turl: getDataURL( image )\\n\\t\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\toutput.image = image.uuid;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( ! isRootObject ) {\\n\\n\\t\\t\\t\\tmeta.textures[ this.uuid ] = output;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn output;\\n\\n\\t\\t},\\n\\n\\t\\tdispose: function () {\\n\\n\\t\\t\\tthis.dispatchEvent( { type: 'dispose' } );\\n\\n\\t\\t},\\n\\n\\t\\ttransformUv: function ( uv ) {\\n\\n\\t\\t\\tif ( this.mapping !== UVMapping ) return;\\n\\n\\t\\t\\tuv.applyMatrix3( this.matrix );\\n\\n\\t\\t\\tif ( uv.x < 0 || uv.x > 1 ) {\\n\\n\\t\\t\\t\\tswitch ( this.wrapS ) {\\n\\n\\t\\t\\t\\t\\tcase RepeatWrapping:\\n\\n\\t\\t\\t\\t\\t\\tuv.x = uv.x - Math.floor( uv.x );\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase ClampToEdgeWrapping:\\n\\n\\t\\t\\t\\t\\t\\tuv.x = uv.x < 0 ? 0 : 1;\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase MirroredRepeatWrapping:\\n\\n\\t\\t\\t\\t\\t\\tif ( Math.abs( Math.floor( uv.x ) % 2 ) === 1 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tuv.x = Math.ceil( uv.x ) - uv.x;\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tuv.x = uv.x - Math.floor( uv.x );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( uv.y < 0 || uv.y > 1 ) {\\n\\n\\t\\t\\t\\tswitch ( this.wrapT ) {\\n\\n\\t\\t\\t\\t\\tcase RepeatWrapping:\\n\\n\\t\\t\\t\\t\\t\\tuv.y = uv.y - Math.floor( uv.y );\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase ClampToEdgeWrapping:\\n\\n\\t\\t\\t\\t\\t\\tuv.y = uv.y < 0 ? 0 : 1;\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase MirroredRepeatWrapping:\\n\\n\\t\\t\\t\\t\\t\\tif ( Math.abs( Math.floor( uv.y ) % 2 ) === 1 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tuv.y = Math.ceil( uv.y ) - uv.y;\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tuv.y = uv.y - Math.floor( uv.y );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.flipY ) {\\n\\n\\t\\t\\t\\tuv.y = 1 - uv.y;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperty( Texture.prototype, \\\"needsUpdate\\\", {\\n\\n\\t\\tset: function ( value ) {\\n\\n\\t\\t\\tif ( value === true ) this.version ++;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author supereggbert / http://www.paulbrunt.co.uk/\\n\\t * @author philogb / http://blog.thejit.org/\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author egraether / http://egraether.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction Vector4( x, y, z, w ) {\\n\\n\\t\\tthis.x = x || 0;\\n\\t\\tthis.y = y || 0;\\n\\t\\tthis.z = z || 0;\\n\\t\\tthis.w = ( w !== undefined ) ? w : 1;\\n\\n\\t}\\n\\n\\tObject.assign( Vector4.prototype, {\\n\\n\\t\\tisVector4: true,\\n\\n\\t\\tset: function ( x, y, z, w ) {\\n\\n\\t\\t\\tthis.x = x;\\n\\t\\t\\tthis.y = y;\\n\\t\\t\\tthis.z = z;\\n\\t\\t\\tthis.w = w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.x = scalar;\\n\\t\\t\\tthis.y = scalar;\\n\\t\\t\\tthis.z = scalar;\\n\\t\\t\\tthis.w = scalar;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetX: function ( x ) {\\n\\n\\t\\t\\tthis.x = x;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetY: function ( y ) {\\n\\n\\t\\t\\tthis.y = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetZ: function ( z ) {\\n\\n\\t\\t\\tthis.z = z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetW: function ( w ) {\\n\\n\\t\\t\\tthis.w = w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetComponent: function ( index, value ) {\\n\\n\\t\\t\\tswitch ( index ) {\\n\\n\\t\\t\\t\\tcase 0: this.x = value; break;\\n\\t\\t\\t\\tcase 1: this.y = value; break;\\n\\t\\t\\t\\tcase 2: this.z = value; break;\\n\\t\\t\\t\\tcase 3: this.w = value; break;\\n\\t\\t\\t\\tdefault: throw new Error( 'index is out of range: ' + index );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetComponent: function ( index ) {\\n\\n\\t\\t\\tswitch ( index ) {\\n\\n\\t\\t\\t\\tcase 0: return this.x;\\n\\t\\t\\t\\tcase 1: return this.y;\\n\\t\\t\\t\\tcase 2: return this.z;\\n\\t\\t\\t\\tcase 3: return this.w;\\n\\t\\t\\t\\tdefault: throw new Error( 'index is out of range: ' + index );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.x, this.y, this.z, this.w );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( v ) {\\n\\n\\t\\t\\tthis.x = v.x;\\n\\t\\t\\tthis.y = v.y;\\n\\t\\t\\tthis.z = v.z;\\n\\t\\t\\tthis.w = ( v.w !== undefined ) ? v.w : 1;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tadd: function ( v, w ) {\\n\\n\\t\\t\\tif ( w !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.addVectors( v, w );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x += v.x;\\n\\t\\t\\tthis.y += v.y;\\n\\t\\t\\tthis.z += v.z;\\n\\t\\t\\tthis.w += v.w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddScalar: function ( s ) {\\n\\n\\t\\t\\tthis.x += s;\\n\\t\\t\\tthis.y += s;\\n\\t\\t\\tthis.z += s;\\n\\t\\t\\tthis.w += s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddVectors: function ( a, b ) {\\n\\n\\t\\t\\tthis.x = a.x + b.x;\\n\\t\\t\\tthis.y = a.y + b.y;\\n\\t\\t\\tthis.z = a.z + b.z;\\n\\t\\t\\tthis.w = a.w + b.w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddScaledVector: function ( v, s ) {\\n\\n\\t\\t\\tthis.x += v.x * s;\\n\\t\\t\\tthis.y += v.y * s;\\n\\t\\t\\tthis.z += v.z * s;\\n\\t\\t\\tthis.w += v.w * s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsub: function ( v, w ) {\\n\\n\\t\\t\\tif ( w !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.subVectors( v, w );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x -= v.x;\\n\\t\\t\\tthis.y -= v.y;\\n\\t\\t\\tthis.z -= v.z;\\n\\t\\t\\tthis.w -= v.w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsubScalar: function ( s ) {\\n\\n\\t\\t\\tthis.x -= s;\\n\\t\\t\\tthis.y -= s;\\n\\t\\t\\tthis.z -= s;\\n\\t\\t\\tthis.w -= s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsubVectors: function ( a, b ) {\\n\\n\\t\\t\\tthis.x = a.x - b.x;\\n\\t\\t\\tthis.y = a.y - b.y;\\n\\t\\t\\tthis.z = a.z - b.z;\\n\\t\\t\\tthis.w = a.w - b.w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.x *= scalar;\\n\\t\\t\\tthis.y *= scalar;\\n\\t\\t\\tthis.z *= scalar;\\n\\t\\t\\tthis.w *= scalar;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tapplyMatrix4: function ( m ) {\\n\\n\\t\\t\\tvar x = this.x, y = this.y, z = this.z, w = this.w;\\n\\t\\t\\tvar e = m.elements;\\n\\n\\t\\t\\tthis.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] * w;\\n\\t\\t\\tthis.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] * w;\\n\\t\\t\\tthis.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] * w;\\n\\t\\t\\tthis.w = e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] * w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdivideScalar: function ( scalar ) {\\n\\n\\t\\t\\treturn this.multiplyScalar( 1 / scalar );\\n\\n\\t\\t},\\n\\n\\t\\tsetAxisAngleFromQuaternion: function ( q ) {\\n\\n\\t\\t\\t// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm\\n\\n\\t\\t\\t// q is assumed to be normalized\\n\\n\\t\\t\\tthis.w = 2 * Math.acos( q.w );\\n\\n\\t\\t\\tvar s = Math.sqrt( 1 - q.w * q.w );\\n\\n\\t\\t\\tif ( s < 0.0001 ) {\\n\\n\\t\\t\\t\\tthis.x = 1;\\n\\t\\t\\t\\tthis.y = 0;\\n\\t\\t\\t\\tthis.z = 0;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.x = q.x / s;\\n\\t\\t\\t\\tthis.y = q.y / s;\\n\\t\\t\\t\\tthis.z = q.z / s;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetAxisAngleFromRotationMatrix: function ( m ) {\\n\\n\\t\\t\\t// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm\\n\\n\\t\\t\\t// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)\\n\\n\\t\\t\\tvar angle, x, y, z,\\t\\t// variables for result\\n\\t\\t\\t\\tepsilon = 0.01,\\t\\t// margin to allow for rounding errors\\n\\t\\t\\t\\tepsilon2 = 0.1,\\t\\t// margin to distinguish between 0 and 180 degrees\\n\\n\\t\\t\\t\\tte = m.elements,\\n\\n\\t\\t\\t\\tm11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],\\n\\t\\t\\t\\tm21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],\\n\\t\\t\\t\\tm31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];\\n\\n\\t\\t\\tif ( ( Math.abs( m12 - m21 ) < epsilon ) &&\\n\\t\\t\\t ( Math.abs( m13 - m31 ) < epsilon ) &&\\n\\t\\t\\t ( Math.abs( m23 - m32 ) < epsilon ) ) {\\n\\n\\t\\t\\t\\t// singularity found\\n\\t\\t\\t\\t// first check for identity matrix which must have +1 for all terms\\n\\t\\t\\t\\t// in leading diagonal and zero in other terms\\n\\n\\t\\t\\t\\tif ( ( Math.abs( m12 + m21 ) < epsilon2 ) &&\\n\\t\\t\\t\\t ( Math.abs( m13 + m31 ) < epsilon2 ) &&\\n\\t\\t\\t\\t ( Math.abs( m23 + m32 ) < epsilon2 ) &&\\n\\t\\t\\t\\t ( Math.abs( m11 + m22 + m33 - 3 ) < epsilon2 ) ) {\\n\\n\\t\\t\\t\\t\\t// this singularity is identity matrix so angle = 0\\n\\n\\t\\t\\t\\t\\tthis.set( 1, 0, 0, 0 );\\n\\n\\t\\t\\t\\t\\treturn this; // zero angle, arbitrary axis\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// otherwise this singularity is angle = 180\\n\\n\\t\\t\\t\\tangle = Math.PI;\\n\\n\\t\\t\\t\\tvar xx = ( m11 + 1 ) / 2;\\n\\t\\t\\t\\tvar yy = ( m22 + 1 ) / 2;\\n\\t\\t\\t\\tvar zz = ( m33 + 1 ) / 2;\\n\\t\\t\\t\\tvar xy = ( m12 + m21 ) / 4;\\n\\t\\t\\t\\tvar xz = ( m13 + m31 ) / 4;\\n\\t\\t\\t\\tvar yz = ( m23 + m32 ) / 4;\\n\\n\\t\\t\\t\\tif ( ( xx > yy ) && ( xx > zz ) ) {\\n\\n\\t\\t\\t\\t\\t// m11 is the largest diagonal term\\n\\n\\t\\t\\t\\t\\tif ( xx < epsilon ) {\\n\\n\\t\\t\\t\\t\\t\\tx = 0;\\n\\t\\t\\t\\t\\t\\ty = 0.707106781;\\n\\t\\t\\t\\t\\t\\tz = 0.707106781;\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tx = Math.sqrt( xx );\\n\\t\\t\\t\\t\\t\\ty = xy / x;\\n\\t\\t\\t\\t\\t\\tz = xz / x;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( yy > zz ) {\\n\\n\\t\\t\\t\\t\\t// m22 is the largest diagonal term\\n\\n\\t\\t\\t\\t\\tif ( yy < epsilon ) {\\n\\n\\t\\t\\t\\t\\t\\tx = 0.707106781;\\n\\t\\t\\t\\t\\t\\ty = 0;\\n\\t\\t\\t\\t\\t\\tz = 0.707106781;\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\ty = Math.sqrt( yy );\\n\\t\\t\\t\\t\\t\\tx = xy / y;\\n\\t\\t\\t\\t\\t\\tz = yz / y;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// m33 is the largest diagonal term so base result on this\\n\\n\\t\\t\\t\\t\\tif ( zz < epsilon ) {\\n\\n\\t\\t\\t\\t\\t\\tx = 0.707106781;\\n\\t\\t\\t\\t\\t\\ty = 0.707106781;\\n\\t\\t\\t\\t\\t\\tz = 0;\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tz = Math.sqrt( zz );\\n\\t\\t\\t\\t\\t\\tx = xz / z;\\n\\t\\t\\t\\t\\t\\ty = yz / z;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.set( x, y, z, angle );\\n\\n\\t\\t\\t\\treturn this; // return 180 deg rotation\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// as we have reached here there are no singularities so we can handle normally\\n\\n\\t\\t\\tvar s = Math.sqrt( ( m32 - m23 ) * ( m32 - m23 ) +\\n\\t\\t\\t ( m13 - m31 ) * ( m13 - m31 ) +\\n\\t\\t\\t ( m21 - m12 ) * ( m21 - m12 ) ); // used to normalize\\n\\n\\t\\t\\tif ( Math.abs( s ) < 0.001 ) s = 1;\\n\\n\\t\\t\\t// prevent divide by zero, should not happen if matrix is orthogonal and should be\\n\\t\\t\\t// caught by singularity test above, but I've left it in just in case\\n\\n\\t\\t\\tthis.x = ( m32 - m23 ) / s;\\n\\t\\t\\tthis.y = ( m13 - m31 ) / s;\\n\\t\\t\\tthis.z = ( m21 - m12 ) / s;\\n\\t\\t\\tthis.w = Math.acos( ( m11 + m22 + m33 - 1 ) / 2 );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmin: function ( v ) {\\n\\n\\t\\t\\tthis.x = Math.min( this.x, v.x );\\n\\t\\t\\tthis.y = Math.min( this.y, v.y );\\n\\t\\t\\tthis.z = Math.min( this.z, v.z );\\n\\t\\t\\tthis.w = Math.min( this.w, v.w );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmax: function ( v ) {\\n\\n\\t\\t\\tthis.x = Math.max( this.x, v.x );\\n\\t\\t\\tthis.y = Math.max( this.y, v.y );\\n\\t\\t\\tthis.z = Math.max( this.z, v.z );\\n\\t\\t\\tthis.w = Math.max( this.w, v.w );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclamp: function ( min, max ) {\\n\\n\\t\\t\\t// assumes min < max, componentwise\\n\\n\\t\\t\\tthis.x = Math.max( min.x, Math.min( max.x, this.x ) );\\n\\t\\t\\tthis.y = Math.max( min.y, Math.min( max.y, this.y ) );\\n\\t\\t\\tthis.z = Math.max( min.z, Math.min( max.z, this.z ) );\\n\\t\\t\\tthis.w = Math.max( min.w, Math.min( max.w, this.w ) );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclampScalar: function () {\\n\\n\\t\\t\\tvar min, max;\\n\\n\\t\\t\\treturn function clampScalar( minVal, maxVal ) {\\n\\n\\t\\t\\t\\tif ( min === undefined ) {\\n\\n\\t\\t\\t\\t\\tmin = new Vector4();\\n\\t\\t\\t\\t\\tmax = new Vector4();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tmin.set( minVal, minVal, minVal, minVal );\\n\\t\\t\\t\\tmax.set( maxVal, maxVal, maxVal, maxVal );\\n\\n\\t\\t\\t\\treturn this.clamp( min, max );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tclampLength: function ( min, max ) {\\n\\n\\t\\t\\tvar length = this.length();\\n\\n\\t\\t\\treturn this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );\\n\\n\\t\\t},\\n\\n\\t\\tfloor: function () {\\n\\n\\t\\t\\tthis.x = Math.floor( this.x );\\n\\t\\t\\tthis.y = Math.floor( this.y );\\n\\t\\t\\tthis.z = Math.floor( this.z );\\n\\t\\t\\tthis.w = Math.floor( this.w );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tceil: function () {\\n\\n\\t\\t\\tthis.x = Math.ceil( this.x );\\n\\t\\t\\tthis.y = Math.ceil( this.y );\\n\\t\\t\\tthis.z = Math.ceil( this.z );\\n\\t\\t\\tthis.w = Math.ceil( this.w );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tround: function () {\\n\\n\\t\\t\\tthis.x = Math.round( this.x );\\n\\t\\t\\tthis.y = Math.round( this.y );\\n\\t\\t\\tthis.z = Math.round( this.z );\\n\\t\\t\\tthis.w = Math.round( this.w );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\troundToZero: function () {\\n\\n\\t\\t\\tthis.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );\\n\\t\\t\\tthis.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );\\n\\t\\t\\tthis.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );\\n\\t\\t\\tthis.w = ( this.w < 0 ) ? Math.ceil( this.w ) : Math.floor( this.w );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tnegate: function () {\\n\\n\\t\\t\\tthis.x = - this.x;\\n\\t\\t\\tthis.y = - this.y;\\n\\t\\t\\tthis.z = - this.z;\\n\\t\\t\\tthis.w = - this.w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdot: function ( v ) {\\n\\n\\t\\t\\treturn this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;\\n\\n\\t\\t},\\n\\n\\t\\tlengthSq: function () {\\n\\n\\t\\t\\treturn this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;\\n\\n\\t\\t},\\n\\n\\t\\tlength: function () {\\n\\n\\t\\t\\treturn Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w );\\n\\n\\t\\t},\\n\\n\\t\\tmanhattanLength: function () {\\n\\n\\t\\t\\treturn Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z ) + Math.abs( this.w );\\n\\n\\t\\t},\\n\\n\\t\\tnormalize: function () {\\n\\n\\t\\t\\treturn this.divideScalar( this.length() || 1 );\\n\\n\\t\\t},\\n\\n\\t\\tsetLength: function ( length ) {\\n\\n\\t\\t\\treturn this.normalize().multiplyScalar( length );\\n\\n\\t\\t},\\n\\n\\t\\tlerp: function ( v, alpha ) {\\n\\n\\t\\t\\tthis.x += ( v.x - this.x ) * alpha;\\n\\t\\t\\tthis.y += ( v.y - this.y ) * alpha;\\n\\t\\t\\tthis.z += ( v.z - this.z ) * alpha;\\n\\t\\t\\tthis.w += ( v.w - this.w ) * alpha;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tlerpVectors: function ( v1, v2, alpha ) {\\n\\n\\t\\t\\treturn this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( v ) {\\n\\n\\t\\t\\treturn ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) && ( v.w === this.w ) );\\n\\n\\t\\t},\\n\\n\\t\\tfromArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tthis.x = array[ offset ];\\n\\t\\t\\tthis.y = array[ offset + 1 ];\\n\\t\\t\\tthis.z = array[ offset + 2 ];\\n\\t\\t\\tthis.w = array[ offset + 3 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( array === undefined ) array = [];\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tarray[ offset ] = this.x;\\n\\t\\t\\tarray[ offset + 1 ] = this.y;\\n\\t\\t\\tarray[ offset + 2 ] = this.z;\\n\\t\\t\\tarray[ offset + 3 ] = this.w;\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t},\\n\\n\\t\\tfromBufferAttribute: function ( attribute, index, offset ) {\\n\\n\\t\\t\\tif ( offset !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector4: offset has been removed from .fromBufferAttribute().' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x = attribute.getX( index );\\n\\t\\t\\tthis.y = attribute.getY( index );\\n\\t\\t\\tthis.z = attribute.getZ( index );\\n\\t\\t\\tthis.w = attribute.getW( index );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author szimek / https://github.com/szimek/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author Marius Kintel / https://github.com/kintel\\n\\t */\\n\\n\\t/*\\n\\t In options, we can specify:\\n\\t * Texture parameters for an auto-generated target texture\\n\\t * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers\\n\\t*/\\n\\tfunction WebGLRenderTarget( width, height, options ) {\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.width = width;\\n\\t\\tthis.height = height;\\n\\n\\t\\tthis.scissor = new Vector4( 0, 0, width, height );\\n\\t\\tthis.scissorTest = false;\\n\\n\\t\\tthis.viewport = new Vector4( 0, 0, width, height );\\n\\n\\t\\toptions = options || {};\\n\\n\\t\\tif ( options.minFilter === undefined ) options.minFilter = LinearFilter;\\n\\n\\t\\tthis.texture = new Texture( undefined, undefined, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.encoding );\\n\\n\\t\\tthis.depthBuffer = options.depthBuffer !== undefined ? options.depthBuffer : true;\\n\\t\\tthis.stencilBuffer = options.stencilBuffer !== undefined ? options.stencilBuffer : true;\\n\\t\\tthis.depthTexture = options.depthTexture !== undefined ? options.depthTexture : null;\\n\\n\\t}\\n\\n\\tWebGLRenderTarget.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {\\n\\n\\t\\tconstructor: WebGLRenderTarget,\\n\\n\\t\\tisWebGLRenderTarget: true,\\n\\n\\t\\tsetSize: function ( width, height ) {\\n\\n\\t\\t\\tif ( this.width !== width || this.height !== height ) {\\n\\n\\t\\t\\t\\tthis.width = width;\\n\\t\\t\\t\\tthis.height = height;\\n\\n\\t\\t\\t\\tthis.dispose();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.viewport.set( 0, 0, width, height );\\n\\t\\t\\tthis.scissor.set( 0, 0, width, height );\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tthis.width = source.width;\\n\\t\\t\\tthis.height = source.height;\\n\\n\\t\\t\\tthis.viewport.copy( source.viewport );\\n\\n\\t\\t\\tthis.texture = source.texture.clone();\\n\\n\\t\\t\\tthis.depthBuffer = source.depthBuffer;\\n\\t\\t\\tthis.stencilBuffer = source.stencilBuffer;\\n\\t\\t\\tthis.depthTexture = source.depthTexture;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdispose: function () {\\n\\n\\t\\t\\tthis.dispatchEvent( { type: 'dispose' } );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com\\n\\t */\\n\\n\\tfunction WebGLRenderTargetCube( width, height, options ) {\\n\\n\\t\\tWebGLRenderTarget.call( this, width, height, options );\\n\\n\\t\\tthis.activeCubeFace = 0; // PX 0, NX 1, PY 2, NY 3, PZ 4, NZ 5\\n\\t\\tthis.activeMipMapLevel = 0;\\n\\n\\t}\\n\\n\\tWebGLRenderTargetCube.prototype = Object.create( WebGLRenderTarget.prototype );\\n\\tWebGLRenderTargetCube.prototype.constructor = WebGLRenderTargetCube;\\n\\n\\tWebGLRenderTargetCube.prototype.isWebGLRenderTargetCube = true;\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction DataTexture( data, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, encoding ) {\\n\\n\\t\\tTexture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding );\\n\\n\\t\\tthis.image = { data: data, width: width, height: height };\\n\\n\\t\\tthis.magFilter = magFilter !== undefined ? magFilter : NearestFilter;\\n\\t\\tthis.minFilter = minFilter !== undefined ? minFilter : NearestFilter;\\n\\n\\t\\tthis.generateMipmaps = false;\\n\\t\\tthis.flipY = false;\\n\\t\\tthis.unpackAlignment = 1;\\n\\n\\t}\\n\\n\\tDataTexture.prototype = Object.create( Texture.prototype );\\n\\tDataTexture.prototype.constructor = DataTexture;\\n\\n\\tDataTexture.prototype.isDataTexture = true;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction CubeTexture( images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding ) {\\n\\n\\t\\timages = images !== undefined ? images : [];\\n\\t\\tmapping = mapping !== undefined ? mapping : CubeReflectionMapping;\\n\\n\\t\\tTexture.call( this, images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding );\\n\\n\\t\\tthis.flipY = false;\\n\\n\\t}\\n\\n\\tCubeTexture.prototype = Object.create( Texture.prototype );\\n\\tCubeTexture.prototype.constructor = CubeTexture;\\n\\n\\tCubeTexture.prototype.isCubeTexture = true;\\n\\n\\tObject.defineProperty( CubeTexture.prototype, 'images', {\\n\\n\\t\\tget: function () {\\n\\n\\t\\t\\treturn this.image;\\n\\n\\t\\t},\\n\\n\\t\\tset: function ( value ) {\\n\\n\\t\\t\\tthis.image = value;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author tschw\\n\\t *\\n\\t * Uniforms of a program.\\n\\t * Those form a tree structure with a special top-level container for the root,\\n\\t * which you get by calling 'new WebGLUniforms( gl, program, renderer )'.\\n\\t *\\n\\t *\\n\\t * Properties of inner nodes including the top-level container:\\n\\t *\\n\\t * .seq - array of nested uniforms\\n\\t * .map - nested uniforms by name\\n\\t *\\n\\t *\\n\\t * Methods of all nodes except the top-level container:\\n\\t *\\n\\t * .setValue( gl, value, [renderer] )\\n\\t *\\n\\t * \\t\\tuploads a uniform value(s)\\n\\t * \\tthe 'renderer' parameter is needed for sampler uniforms\\n\\t *\\n\\t *\\n\\t * Static methods of the top-level container (renderer factorizations):\\n\\t *\\n\\t * .upload( gl, seq, values, renderer )\\n\\t *\\n\\t * \\t\\tsets uniforms in 'seq' to 'values[id].value'\\n\\t *\\n\\t * .seqWithValue( seq, values ) : filteredSeq\\n\\t *\\n\\t * \\t\\tfilters 'seq' entries with corresponding entry in values\\n\\t *\\n\\t *\\n\\t * Methods of the top-level container (renderer factorizations):\\n\\t *\\n\\t * .setValue( gl, name, value )\\n\\t *\\n\\t * \\t\\tsets uniform with name 'name' to 'value'\\n\\t *\\n\\t * .set( gl, obj, prop )\\n\\t *\\n\\t * \\t\\tsets uniform from object and property with same name than uniform\\n\\t *\\n\\t * .setOptional( gl, obj, prop )\\n\\t *\\n\\t * \\t\\tlike .set for an optional property of the object\\n\\t *\\n\\t */\\n\\n\\tvar emptyTexture = new Texture();\\n\\tvar emptyCubeTexture = new CubeTexture();\\n\\n\\t// --- Base for inner nodes (including the root) ---\\n\\n\\tfunction UniformContainer() {\\n\\n\\t\\tthis.seq = [];\\n\\t\\tthis.map = {};\\n\\n\\t}\\n\\n\\t// --- Utilities ---\\n\\n\\t// Array Caches (provide typed arrays for temporary by size)\\n\\n\\tvar arrayCacheF32 = [];\\n\\tvar arrayCacheI32 = [];\\n\\n\\t// Float32Array caches used for uploading Matrix uniforms\\n\\n\\tvar mat4array = new Float32Array( 16 );\\n\\tvar mat3array = new Float32Array( 9 );\\n\\n\\t// Flattening for arrays of vectors and matrices\\n\\n\\tfunction flatten( array, nBlocks, blockSize ) {\\n\\n\\t\\tvar firstElem = array[ 0 ];\\n\\n\\t\\tif ( firstElem <= 0 || firstElem > 0 ) return array;\\n\\t\\t// unoptimized: ! isNaN( firstElem )\\n\\t\\t// see http://jacksondunstan.com/articles/983\\n\\n\\t\\tvar n = nBlocks * blockSize,\\n\\t\\t\\tr = arrayCacheF32[ n ];\\n\\n\\t\\tif ( r === undefined ) {\\n\\n\\t\\t\\tr = new Float32Array( n );\\n\\t\\t\\tarrayCacheF32[ n ] = r;\\n\\n\\t\\t}\\n\\n\\t\\tif ( nBlocks !== 0 ) {\\n\\n\\t\\t\\tfirstElem.toArray( r, 0 );\\n\\n\\t\\t\\tfor ( var i = 1, offset = 0; i !== nBlocks; ++ i ) {\\n\\n\\t\\t\\t\\toffset += blockSize;\\n\\t\\t\\t\\tarray[ i ].toArray( r, offset );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\treturn r;\\n\\n\\t}\\n\\n\\t// Texture unit allocation\\n\\n\\tfunction allocTexUnits( renderer, n ) {\\n\\n\\t\\tvar r = arrayCacheI32[ n ];\\n\\n\\t\\tif ( r === undefined ) {\\n\\n\\t\\t\\tr = new Int32Array( n );\\n\\t\\t\\tarrayCacheI32[ n ] = r;\\n\\n\\t\\t}\\n\\n\\t\\tfor ( var i = 0; i !== n; ++ i )\\n\\t\\t\\tr[ i ] = renderer.allocTextureUnit();\\n\\n\\t\\treturn r;\\n\\n\\t}\\n\\n\\t// --- Setters ---\\n\\n\\t// Note: Defining these methods externally, because they come in a bunch\\n\\t// and this way their names minify.\\n\\n\\t// Single scalar\\n\\n\\tfunction setValue1f( gl, v ) {\\n\\n\\t\\tgl.uniform1f( this.addr, v );\\n\\n\\t}\\n\\n\\tfunction setValue1i( gl, v ) {\\n\\n\\t\\tgl.uniform1i( this.addr, v );\\n\\n\\t}\\n\\n\\t// Single float vector (from flat array or THREE.VectorN)\\n\\n\\tfunction setValue2fv( gl, v ) {\\n\\n\\t\\tif ( v.x === undefined ) {\\n\\n\\t\\t\\tgl.uniform2fv( this.addr, v );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tgl.uniform2f( this.addr, v.x, v.y );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tfunction setValue3fv( gl, v ) {\\n\\n\\t\\tif ( v.x !== undefined ) {\\n\\n\\t\\t\\tgl.uniform3f( this.addr, v.x, v.y, v.z );\\n\\n\\t\\t} else if ( v.r !== undefined ) {\\n\\n\\t\\t\\tgl.uniform3f( this.addr, v.r, v.g, v.b );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tgl.uniform3fv( this.addr, v );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tfunction setValue4fv( gl, v ) {\\n\\n\\t\\tif ( v.x === undefined ) {\\n\\n\\t\\t\\tgl.uniform4fv( this.addr, v );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\t gl.uniform4f( this.addr, v.x, v.y, v.z, v.w );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t// Single matrix (from flat array or MatrixN)\\n\\n\\tfunction setValue2fm( gl, v ) {\\n\\n\\t\\tgl.uniformMatrix2fv( this.addr, false, v.elements || v );\\n\\n\\t}\\n\\n\\tfunction setValue3fm( gl, v ) {\\n\\n\\t\\tif ( v.elements === undefined ) {\\n\\n\\t\\t\\tgl.uniformMatrix3fv( this.addr, false, v );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tmat3array.set( v.elements );\\n\\t\\t\\tgl.uniformMatrix3fv( this.addr, false, mat3array );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tfunction setValue4fm( gl, v ) {\\n\\n\\t\\tif ( v.elements === undefined ) {\\n\\n\\t\\t\\tgl.uniformMatrix4fv( this.addr, false, v );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tmat4array.set( v.elements );\\n\\t\\t\\tgl.uniformMatrix4fv( this.addr, false, mat4array );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t// Single texture (2D / Cube)\\n\\n\\tfunction setValueT1( gl, v, renderer ) {\\n\\n\\t\\tvar unit = renderer.allocTextureUnit();\\n\\t\\tgl.uniform1i( this.addr, unit );\\n\\t\\trenderer.setTexture2D( v || emptyTexture, unit );\\n\\n\\t}\\n\\n\\tfunction setValueT6( gl, v, renderer ) {\\n\\n\\t\\tvar unit = renderer.allocTextureUnit();\\n\\t\\tgl.uniform1i( this.addr, unit );\\n\\t\\trenderer.setTextureCube( v || emptyCubeTexture, unit );\\n\\n\\t}\\n\\n\\t// Integer / Boolean vectors or arrays thereof (always flat arrays)\\n\\n\\tfunction setValue2iv( gl, v ) {\\n\\n\\t\\tgl.uniform2iv( this.addr, v );\\n\\n\\t}\\n\\n\\tfunction setValue3iv( gl, v ) {\\n\\n\\t\\tgl.uniform3iv( this.addr, v );\\n\\n\\t}\\n\\n\\tfunction setValue4iv( gl, v ) {\\n\\n\\t\\tgl.uniform4iv( this.addr, v );\\n\\n\\t}\\n\\n\\t// Helper to pick the right setter for the singular case\\n\\n\\tfunction getSingularSetter( type ) {\\n\\n\\t\\tswitch ( type ) {\\n\\n\\t\\t\\tcase 0x1406: return setValue1f; // FLOAT\\n\\t\\t\\tcase 0x8b50: return setValue2fv; // _VEC2\\n\\t\\t\\tcase 0x8b51: return setValue3fv; // _VEC3\\n\\t\\t\\tcase 0x8b52: return setValue4fv; // _VEC4\\n\\n\\t\\t\\tcase 0x8b5a: return setValue2fm; // _MAT2\\n\\t\\t\\tcase 0x8b5b: return setValue3fm; // _MAT3\\n\\t\\t\\tcase 0x8b5c: return setValue4fm; // _MAT4\\n\\n\\t\\t\\tcase 0x8b5e: case 0x8d66: return setValueT1; // SAMPLER_2D, SAMPLER_EXTERNAL_OES\\n\\t\\t\\tcase 0x8b60: return setValueT6; // SAMPLER_CUBE\\n\\n\\t\\t\\tcase 0x1404: case 0x8b56: return setValue1i; // INT, BOOL\\n\\t\\t\\tcase 0x8b53: case 0x8b57: return setValue2iv; // _VEC2\\n\\t\\t\\tcase 0x8b54: case 0x8b58: return setValue3iv; // _VEC3\\n\\t\\t\\tcase 0x8b55: case 0x8b59: return setValue4iv; // _VEC4\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t// Array of scalars\\n\\n\\tfunction setValue1fv( gl, v ) {\\n\\n\\t\\tgl.uniform1fv( this.addr, v );\\n\\n\\t}\\n\\tfunction setValue1iv( gl, v ) {\\n\\n\\t\\tgl.uniform1iv( this.addr, v );\\n\\n\\t}\\n\\n\\t// Array of vectors (flat or from THREE classes)\\n\\n\\tfunction setValueV2a( gl, v ) {\\n\\n\\t\\tgl.uniform2fv( this.addr, flatten( v, this.size, 2 ) );\\n\\n\\t}\\n\\n\\tfunction setValueV3a( gl, v ) {\\n\\n\\t\\tgl.uniform3fv( this.addr, flatten( v, this.size, 3 ) );\\n\\n\\t}\\n\\n\\tfunction setValueV4a( gl, v ) {\\n\\n\\t\\tgl.uniform4fv( this.addr, flatten( v, this.size, 4 ) );\\n\\n\\t}\\n\\n\\t// Array of matrices (flat or from THREE clases)\\n\\n\\tfunction setValueM2a( gl, v ) {\\n\\n\\t\\tgl.uniformMatrix2fv( this.addr, false, flatten( v, this.size, 4 ) );\\n\\n\\t}\\n\\n\\tfunction setValueM3a( gl, v ) {\\n\\n\\t\\tgl.uniformMatrix3fv( this.addr, false, flatten( v, this.size, 9 ) );\\n\\n\\t}\\n\\n\\tfunction setValueM4a( gl, v ) {\\n\\n\\t\\tgl.uniformMatrix4fv( this.addr, false, flatten( v, this.size, 16 ) );\\n\\n\\t}\\n\\n\\t// Array of textures (2D / Cube)\\n\\n\\tfunction setValueT1a( gl, v, renderer ) {\\n\\n\\t\\tvar n = v.length,\\n\\t\\t\\tunits = allocTexUnits( renderer, n );\\n\\n\\t\\tgl.uniform1iv( this.addr, units );\\n\\n\\t\\tfor ( var i = 0; i !== n; ++ i ) {\\n\\n\\t\\t\\trenderer.setTexture2D( v[ i ] || emptyTexture, units[ i ] );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tfunction setValueT6a( gl, v, renderer ) {\\n\\n\\t\\tvar n = v.length,\\n\\t\\t\\tunits = allocTexUnits( renderer, n );\\n\\n\\t\\tgl.uniform1iv( this.addr, units );\\n\\n\\t\\tfor ( var i = 0; i !== n; ++ i ) {\\n\\n\\t\\t\\trenderer.setTextureCube( v[ i ] || emptyCubeTexture, units[ i ] );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t// Helper to pick the right setter for a pure (bottom-level) array\\n\\n\\tfunction getPureArraySetter( type ) {\\n\\n\\t\\tswitch ( type ) {\\n\\n\\t\\t\\tcase 0x1406: return setValue1fv; // FLOAT\\n\\t\\t\\tcase 0x8b50: return setValueV2a; // _VEC2\\n\\t\\t\\tcase 0x8b51: return setValueV3a; // _VEC3\\n\\t\\t\\tcase 0x8b52: return setValueV4a; // _VEC4\\n\\n\\t\\t\\tcase 0x8b5a: return setValueM2a; // _MAT2\\n\\t\\t\\tcase 0x8b5b: return setValueM3a; // _MAT3\\n\\t\\t\\tcase 0x8b5c: return setValueM4a; // _MAT4\\n\\n\\t\\t\\tcase 0x8b5e: return setValueT1a; // SAMPLER_2D\\n\\t\\t\\tcase 0x8b60: return setValueT6a; // SAMPLER_CUBE\\n\\n\\t\\t\\tcase 0x1404: case 0x8b56: return setValue1iv; // INT, BOOL\\n\\t\\t\\tcase 0x8b53: case 0x8b57: return setValue2iv; // _VEC2\\n\\t\\t\\tcase 0x8b54: case 0x8b58: return setValue3iv; // _VEC3\\n\\t\\t\\tcase 0x8b55: case 0x8b59: return setValue4iv; // _VEC4\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t// --- Uniform Classes ---\\n\\n\\tfunction SingleUniform( id, activeInfo, addr ) {\\n\\n\\t\\tthis.id = id;\\n\\t\\tthis.addr = addr;\\n\\t\\tthis.setValue = getSingularSetter( activeInfo.type );\\n\\n\\t\\t// this.path = activeInfo.name; // DEBUG\\n\\n\\t}\\n\\n\\tfunction PureArrayUniform( id, activeInfo, addr ) {\\n\\n\\t\\tthis.id = id;\\n\\t\\tthis.addr = addr;\\n\\t\\tthis.size = activeInfo.size;\\n\\t\\tthis.setValue = getPureArraySetter( activeInfo.type );\\n\\n\\t\\t// this.path = activeInfo.name; // DEBUG\\n\\n\\t}\\n\\n\\tfunction StructuredUniform( id ) {\\n\\n\\t\\tthis.id = id;\\n\\n\\t\\tUniformContainer.call( this ); // mix-in\\n\\n\\t}\\n\\n\\tStructuredUniform.prototype.setValue = function ( gl, value ) {\\n\\n\\t\\t// Note: Don't need an extra 'renderer' parameter, since samplers\\n\\t\\t// are not allowed in structured uniforms.\\n\\n\\t\\tvar seq = this.seq;\\n\\n\\t\\tfor ( var i = 0, n = seq.length; i !== n; ++ i ) {\\n\\n\\t\\t\\tvar u = seq[ i ];\\n\\t\\t\\tu.setValue( gl, value[ u.id ] );\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t// --- Top-level ---\\n\\n\\t// Parser - builds up the property tree from the path strings\\n\\n\\tvar RePathPart = /([\\\\w\\\\d_]+)(\\\\])?(\\\\[|\\\\.)?/g;\\n\\n\\t// extracts\\n\\t// \\t- the identifier (member name or array index)\\n\\t// - followed by an optional right bracket (found when array index)\\n\\t// - followed by an optional left bracket or dot (type of subscript)\\n\\t//\\n\\t// Note: These portions can be read in a non-overlapping fashion and\\n\\t// allow straightforward parsing of the hierarchy that WebGL encodes\\n\\t// in the uniform names.\\n\\n\\tfunction addUniform( container, uniformObject ) {\\n\\n\\t\\tcontainer.seq.push( uniformObject );\\n\\t\\tcontainer.map[ uniformObject.id ] = uniformObject;\\n\\n\\t}\\n\\n\\tfunction parseUniform( activeInfo, addr, container ) {\\n\\n\\t\\tvar path = activeInfo.name,\\n\\t\\t\\tpathLength = path.length;\\n\\n\\t\\t// reset RegExp object, because of the early exit of a previous run\\n\\t\\tRePathPart.lastIndex = 0;\\n\\n\\t\\tfor ( ; ; ) {\\n\\n\\t\\t\\tvar match = RePathPart.exec( path ),\\n\\t\\t\\t\\tmatchEnd = RePathPart.lastIndex,\\n\\n\\t\\t\\t\\tid = match[ 1 ],\\n\\t\\t\\t\\tidIsIndex = match[ 2 ] === ']',\\n\\t\\t\\t\\tsubscript = match[ 3 ];\\n\\n\\t\\t\\tif ( idIsIndex ) id = id | 0; // convert to integer\\n\\n\\t\\t\\tif ( subscript === undefined || subscript === '[' && matchEnd + 2 === pathLength ) {\\n\\n\\t\\t\\t\\t// bare name or \\\"pure\\\" bottom-level array \\\"[0]\\\" suffix\\n\\n\\t\\t\\t\\taddUniform( container, subscript === undefined ?\\n\\t\\t\\t\\t\\tnew SingleUniform( id, activeInfo, addr ) :\\n\\t\\t\\t\\t\\tnew PureArrayUniform( id, activeInfo, addr ) );\\n\\n\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// step into inner node / create it in case it doesn't exist\\n\\n\\t\\t\\t\\tvar map = container.map, next = map[ id ];\\n\\n\\t\\t\\t\\tif ( next === undefined ) {\\n\\n\\t\\t\\t\\t\\tnext = new StructuredUniform( id );\\n\\t\\t\\t\\t\\taddUniform( container, next );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tcontainer = next;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t// Root Container\\n\\n\\tfunction WebGLUniforms( gl, program, renderer ) {\\n\\n\\t\\tUniformContainer.call( this );\\n\\n\\t\\tthis.renderer = renderer;\\n\\n\\t\\tvar n = gl.getProgramParameter( program, gl.ACTIVE_UNIFORMS );\\n\\n\\t\\tfor ( var i = 0; i < n; ++ i ) {\\n\\n\\t\\t\\tvar info = gl.getActiveUniform( program, i ),\\n\\t\\t\\t\\tpath = info.name,\\n\\t\\t\\t\\taddr = gl.getUniformLocation( program, path );\\n\\n\\t\\t\\tparseUniform( info, addr, this );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tWebGLUniforms.prototype.setValue = function ( gl, name, value ) {\\n\\n\\t\\tvar u = this.map[ name ];\\n\\n\\t\\tif ( u !== undefined ) u.setValue( gl, value, this.renderer );\\n\\n\\t};\\n\\n\\tWebGLUniforms.prototype.setOptional = function ( gl, object, name ) {\\n\\n\\t\\tvar v = object[ name ];\\n\\n\\t\\tif ( v !== undefined ) this.setValue( gl, name, v );\\n\\n\\t};\\n\\n\\n\\t// Static interface\\n\\n\\tWebGLUniforms.upload = function ( gl, seq, values, renderer ) {\\n\\n\\t\\tfor ( var i = 0, n = seq.length; i !== n; ++ i ) {\\n\\n\\t\\t\\tvar u = seq[ i ],\\n\\t\\t\\t\\tv = values[ u.id ];\\n\\n\\t\\t\\tif ( v.needsUpdate !== false ) {\\n\\n\\t\\t\\t\\t// note: always updating when .needsUpdate is undefined\\n\\t\\t\\t\\tu.setValue( gl, v.value, renderer );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\tWebGLUniforms.seqWithValue = function ( seq, values ) {\\n\\n\\t\\tvar r = [];\\n\\n\\t\\tfor ( var i = 0, n = seq.length; i !== n; ++ i ) {\\n\\n\\t\\t\\tvar u = seq[ i ];\\n\\t\\t\\tif ( u.id in values ) r.push( u );\\n\\n\\t\\t}\\n\\n\\t\\treturn r;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tvar ColorKeywords = { 'aliceblue': 0xF0F8FF, 'antiquewhite': 0xFAEBD7, 'aqua': 0x00FFFF, 'aquamarine': 0x7FFFD4, 'azure': 0xF0FFFF,\\n\\t\\t'beige': 0xF5F5DC, 'bisque': 0xFFE4C4, 'black': 0x000000, 'blanchedalmond': 0xFFEBCD, 'blue': 0x0000FF, 'blueviolet': 0x8A2BE2,\\n\\t\\t'brown': 0xA52A2A, 'burlywood': 0xDEB887, 'cadetblue': 0x5F9EA0, 'chartreuse': 0x7FFF00, 'chocolate': 0xD2691E, 'coral': 0xFF7F50,\\n\\t\\t'cornflowerblue': 0x6495ED, 'cornsilk': 0xFFF8DC, 'crimson': 0xDC143C, 'cyan': 0x00FFFF, 'darkblue': 0x00008B, 'darkcyan': 0x008B8B,\\n\\t\\t'darkgoldenrod': 0xB8860B, 'darkgray': 0xA9A9A9, 'darkgreen': 0x006400, 'darkgrey': 0xA9A9A9, 'darkkhaki': 0xBDB76B, 'darkmagenta': 0x8B008B,\\n\\t\\t'darkolivegreen': 0x556B2F, 'darkorange': 0xFF8C00, 'darkorchid': 0x9932CC, 'darkred': 0x8B0000, 'darksalmon': 0xE9967A, 'darkseagreen': 0x8FBC8F,\\n\\t\\t'darkslateblue': 0x483D8B, 'darkslategray': 0x2F4F4F, 'darkslategrey': 0x2F4F4F, 'darkturquoise': 0x00CED1, 'darkviolet': 0x9400D3,\\n\\t\\t'deeppink': 0xFF1493, 'deepskyblue': 0x00BFFF, 'dimgray': 0x696969, 'dimgrey': 0x696969, 'dodgerblue': 0x1E90FF, 'firebrick': 0xB22222,\\n\\t\\t'floralwhite': 0xFFFAF0, 'forestgreen': 0x228B22, 'fuchsia': 0xFF00FF, 'gainsboro': 0xDCDCDC, 'ghostwhite': 0xF8F8FF, 'gold': 0xFFD700,\\n\\t\\t'goldenrod': 0xDAA520, 'gray': 0x808080, 'green': 0x008000, 'greenyellow': 0xADFF2F, 'grey': 0x808080, 'honeydew': 0xF0FFF0, 'hotpink': 0xFF69B4,\\n\\t\\t'indianred': 0xCD5C5C, 'indigo': 0x4B0082, 'ivory': 0xFFFFF0, 'khaki': 0xF0E68C, 'lavender': 0xE6E6FA, 'lavenderblush': 0xFFF0F5, 'lawngreen': 0x7CFC00,\\n\\t\\t'lemonchiffon': 0xFFFACD, 'lightblue': 0xADD8E6, 'lightcoral': 0xF08080, 'lightcyan': 0xE0FFFF, 'lightgoldenrodyellow': 0xFAFAD2, 'lightgray': 0xD3D3D3,\\n\\t\\t'lightgreen': 0x90EE90, 'lightgrey': 0xD3D3D3, 'lightpink': 0xFFB6C1, 'lightsalmon': 0xFFA07A, 'lightseagreen': 0x20B2AA, 'lightskyblue': 0x87CEFA,\\n\\t\\t'lightslategray': 0x778899, 'lightslategrey': 0x778899, 'lightsteelblue': 0xB0C4DE, 'lightyellow': 0xFFFFE0, 'lime': 0x00FF00, 'limegreen': 0x32CD32,\\n\\t\\t'linen': 0xFAF0E6, 'magenta': 0xFF00FF, 'maroon': 0x800000, 'mediumaquamarine': 0x66CDAA, 'mediumblue': 0x0000CD, 'mediumorchid': 0xBA55D3,\\n\\t\\t'mediumpurple': 0x9370DB, 'mediumseagreen': 0x3CB371, 'mediumslateblue': 0x7B68EE, 'mediumspringgreen': 0x00FA9A, 'mediumturquoise': 0x48D1CC,\\n\\t\\t'mediumvioletred': 0xC71585, 'midnightblue': 0x191970, 'mintcream': 0xF5FFFA, 'mistyrose': 0xFFE4E1, 'moccasin': 0xFFE4B5, 'navajowhite': 0xFFDEAD,\\n\\t\\t'navy': 0x000080, 'oldlace': 0xFDF5E6, 'olive': 0x808000, 'olivedrab': 0x6B8E23, 'orange': 0xFFA500, 'orangered': 0xFF4500, 'orchid': 0xDA70D6,\\n\\t\\t'palegoldenrod': 0xEEE8AA, 'palegreen': 0x98FB98, 'paleturquoise': 0xAFEEEE, 'palevioletred': 0xDB7093, 'papayawhip': 0xFFEFD5, 'peachpuff': 0xFFDAB9,\\n\\t\\t'peru': 0xCD853F, 'pink': 0xFFC0CB, 'plum': 0xDDA0DD, 'powderblue': 0xB0E0E6, 'purple': 0x800080, 'rebeccapurple': 0x663399, 'red': 0xFF0000, 'rosybrown': 0xBC8F8F,\\n\\t\\t'royalblue': 0x4169E1, 'saddlebrown': 0x8B4513, 'salmon': 0xFA8072, 'sandybrown': 0xF4A460, 'seagreen': 0x2E8B57, 'seashell': 0xFFF5EE,\\n\\t\\t'sienna': 0xA0522D, 'silver': 0xC0C0C0, 'skyblue': 0x87CEEB, 'slateblue': 0x6A5ACD, 'slategray': 0x708090, 'slategrey': 0x708090, 'snow': 0xFFFAFA,\\n\\t\\t'springgreen': 0x00FF7F, 'steelblue': 0x4682B4, 'tan': 0xD2B48C, 'teal': 0x008080, 'thistle': 0xD8BFD8, 'tomato': 0xFF6347, 'turquoise': 0x40E0D0,\\n\\t\\t'violet': 0xEE82EE, 'wheat': 0xF5DEB3, 'white': 0xFFFFFF, 'whitesmoke': 0xF5F5F5, 'yellow': 0xFFFF00, 'yellowgreen': 0x9ACD32 };\\n\\n\\tfunction Color( r, g, b ) {\\n\\n\\t\\tif ( g === undefined && b === undefined ) {\\n\\n\\t\\t\\t// r is THREE.Color, hex or string\\n\\t\\t\\treturn this.set( r );\\n\\n\\t\\t}\\n\\n\\t\\treturn this.setRGB( r, g, b );\\n\\n\\t}\\n\\n\\tObject.assign( Color.prototype, {\\n\\n\\t\\tisColor: true,\\n\\n\\t\\tr: 1, g: 1, b: 1,\\n\\n\\t\\tset: function ( value ) {\\n\\n\\t\\t\\tif ( value && value.isColor ) {\\n\\n\\t\\t\\t\\tthis.copy( value );\\n\\n\\t\\t\\t} else if ( typeof value === 'number' ) {\\n\\n\\t\\t\\t\\tthis.setHex( value );\\n\\n\\t\\t\\t} else if ( typeof value === 'string' ) {\\n\\n\\t\\t\\t\\tthis.setStyle( value );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.r = scalar;\\n\\t\\t\\tthis.g = scalar;\\n\\t\\t\\tthis.b = scalar;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetHex: function ( hex ) {\\n\\n\\t\\t\\thex = Math.floor( hex );\\n\\n\\t\\t\\tthis.r = ( hex >> 16 & 255 ) / 255;\\n\\t\\t\\tthis.g = ( hex >> 8 & 255 ) / 255;\\n\\t\\t\\tthis.b = ( hex & 255 ) / 255;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetRGB: function ( r, g, b ) {\\n\\n\\t\\t\\tthis.r = r;\\n\\t\\t\\tthis.g = g;\\n\\t\\t\\tthis.b = b;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetHSL: function () {\\n\\n\\t\\t\\tfunction hue2rgb( p, q, t ) {\\n\\n\\t\\t\\t\\tif ( t < 0 ) t += 1;\\n\\t\\t\\t\\tif ( t > 1 ) t -= 1;\\n\\t\\t\\t\\tif ( t < 1 / 6 ) return p + ( q - p ) * 6 * t;\\n\\t\\t\\t\\tif ( t < 1 / 2 ) return q;\\n\\t\\t\\t\\tif ( t < 2 / 3 ) return p + ( q - p ) * 6 * ( 2 / 3 - t );\\n\\t\\t\\t\\treturn p;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn function setHSL( h, s, l ) {\\n\\n\\t\\t\\t\\t// h,s,l ranges are in 0.0 - 1.0\\n\\t\\t\\t\\th = _Math.euclideanModulo( h, 1 );\\n\\t\\t\\t\\ts = _Math.clamp( s, 0, 1 );\\n\\t\\t\\t\\tl = _Math.clamp( l, 0, 1 );\\n\\n\\t\\t\\t\\tif ( s === 0 ) {\\n\\n\\t\\t\\t\\t\\tthis.r = this.g = this.b = l;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tvar p = l <= 0.5 ? l * ( 1 + s ) : l + s - ( l * s );\\n\\t\\t\\t\\t\\tvar q = ( 2 * l ) - p;\\n\\n\\t\\t\\t\\t\\tthis.r = hue2rgb( q, p, h + 1 / 3 );\\n\\t\\t\\t\\t\\tthis.g = hue2rgb( q, p, h );\\n\\t\\t\\t\\t\\tthis.b = hue2rgb( q, p, h - 1 / 3 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tsetStyle: function ( style ) {\\n\\n\\t\\t\\tfunction handleAlpha( string ) {\\n\\n\\t\\t\\t\\tif ( string === undefined ) return;\\n\\n\\t\\t\\t\\tif ( parseFloat( string ) < 1 ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.Color: Alpha component of ' + style + ' will be ignored.' );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\n\\t\\t\\tvar m;\\n\\n\\t\\t\\tif ( m = /^((?:rgb|hsl)a?)\\\\(\\\\s*([^\\\\)]*)\\\\)/.exec( style ) ) {\\n\\n\\t\\t\\t\\t// rgb / hsl\\n\\n\\t\\t\\t\\tvar color;\\n\\t\\t\\t\\tvar name = m[ 1 ];\\n\\t\\t\\t\\tvar components = m[ 2 ];\\n\\n\\t\\t\\t\\tswitch ( name ) {\\n\\n\\t\\t\\t\\t\\tcase 'rgb':\\n\\t\\t\\t\\t\\tcase 'rgba':\\n\\n\\t\\t\\t\\t\\t\\tif ( color = /^(\\\\d+)\\\\s*,\\\\s*(\\\\d+)\\\\s*,\\\\s*(\\\\d+)\\\\s*(,\\\\s*([0-9]*\\\\.?[0-9]+)\\\\s*)?$/.exec( components ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// rgb(255,0,0) rgba(255,0,0,0.5)\\n\\t\\t\\t\\t\\t\\t\\tthis.r = Math.min( 255, parseInt( color[ 1 ], 10 ) ) / 255;\\n\\t\\t\\t\\t\\t\\t\\tthis.g = Math.min( 255, parseInt( color[ 2 ], 10 ) ) / 255;\\n\\t\\t\\t\\t\\t\\t\\tthis.b = Math.min( 255, parseInt( color[ 3 ], 10 ) ) / 255;\\n\\n\\t\\t\\t\\t\\t\\t\\thandleAlpha( color[ 5 ] );\\n\\n\\t\\t\\t\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tif ( color = /^(\\\\d+)\\\\%\\\\s*,\\\\s*(\\\\d+)\\\\%\\\\s*,\\\\s*(\\\\d+)\\\\%\\\\s*(,\\\\s*([0-9]*\\\\.?[0-9]+)\\\\s*)?$/.exec( components ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// rgb(100%,0%,0%) rgba(100%,0%,0%,0.5)\\n\\t\\t\\t\\t\\t\\t\\tthis.r = Math.min( 100, parseInt( color[ 1 ], 10 ) ) / 100;\\n\\t\\t\\t\\t\\t\\t\\tthis.g = Math.min( 100, parseInt( color[ 2 ], 10 ) ) / 100;\\n\\t\\t\\t\\t\\t\\t\\tthis.b = Math.min( 100, parseInt( color[ 3 ], 10 ) ) / 100;\\n\\n\\t\\t\\t\\t\\t\\t\\thandleAlpha( color[ 5 ] );\\n\\n\\t\\t\\t\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'hsl':\\n\\t\\t\\t\\t\\tcase 'hsla':\\n\\n\\t\\t\\t\\t\\t\\tif ( color = /^([0-9]*\\\\.?[0-9]+)\\\\s*,\\\\s*(\\\\d+)\\\\%\\\\s*,\\\\s*(\\\\d+)\\\\%\\\\s*(,\\\\s*([0-9]*\\\\.?[0-9]+)\\\\s*)?$/.exec( components ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// hsl(120,50%,50%) hsla(120,50%,50%,0.5)\\n\\t\\t\\t\\t\\t\\t\\tvar h = parseFloat( color[ 1 ] ) / 360;\\n\\t\\t\\t\\t\\t\\t\\tvar s = parseInt( color[ 2 ], 10 ) / 100;\\n\\t\\t\\t\\t\\t\\t\\tvar l = parseInt( color[ 3 ], 10 ) / 100;\\n\\n\\t\\t\\t\\t\\t\\t\\thandleAlpha( color[ 5 ] );\\n\\n\\t\\t\\t\\t\\t\\t\\treturn this.setHSL( h, s, l );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( m = /^\\\\#([A-Fa-f0-9]+)$/.exec( style ) ) {\\n\\n\\t\\t\\t\\t// hex color\\n\\n\\t\\t\\t\\tvar hex = m[ 1 ];\\n\\t\\t\\t\\tvar size = hex.length;\\n\\n\\t\\t\\t\\tif ( size === 3 ) {\\n\\n\\t\\t\\t\\t\\t// #ff0\\n\\t\\t\\t\\t\\tthis.r = parseInt( hex.charAt( 0 ) + hex.charAt( 0 ), 16 ) / 255;\\n\\t\\t\\t\\t\\tthis.g = parseInt( hex.charAt( 1 ) + hex.charAt( 1 ), 16 ) / 255;\\n\\t\\t\\t\\t\\tthis.b = parseInt( hex.charAt( 2 ) + hex.charAt( 2 ), 16 ) / 255;\\n\\n\\t\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t\\t} else if ( size === 6 ) {\\n\\n\\t\\t\\t\\t\\t// #ff0000\\n\\t\\t\\t\\t\\tthis.r = parseInt( hex.charAt( 0 ) + hex.charAt( 1 ), 16 ) / 255;\\n\\t\\t\\t\\t\\tthis.g = parseInt( hex.charAt( 2 ) + hex.charAt( 3 ), 16 ) / 255;\\n\\t\\t\\t\\t\\tthis.b = parseInt( hex.charAt( 4 ) + hex.charAt( 5 ), 16 ) / 255;\\n\\n\\t\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( style && style.length > 0 ) {\\n\\n\\t\\t\\t\\t// color keywords\\n\\t\\t\\t\\tvar hex = ColorKeywords[ style ];\\n\\n\\t\\t\\t\\tif ( hex !== undefined ) {\\n\\n\\t\\t\\t\\t\\t// red\\n\\t\\t\\t\\t\\tthis.setHex( hex );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// unknown color\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.Color: Unknown color ' + style );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.r, this.g, this.b );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( color ) {\\n\\n\\t\\t\\tthis.r = color.r;\\n\\t\\t\\tthis.g = color.g;\\n\\t\\t\\tthis.b = color.b;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyGammaToLinear: function ( color, gammaFactor ) {\\n\\n\\t\\t\\tif ( gammaFactor === undefined ) gammaFactor = 2.0;\\n\\n\\t\\t\\tthis.r = Math.pow( color.r, gammaFactor );\\n\\t\\t\\tthis.g = Math.pow( color.g, gammaFactor );\\n\\t\\t\\tthis.b = Math.pow( color.b, gammaFactor );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyLinearToGamma: function ( color, gammaFactor ) {\\n\\n\\t\\t\\tif ( gammaFactor === undefined ) gammaFactor = 2.0;\\n\\n\\t\\t\\tvar safeInverse = ( gammaFactor > 0 ) ? ( 1.0 / gammaFactor ) : 1.0;\\n\\n\\t\\t\\tthis.r = Math.pow( color.r, safeInverse );\\n\\t\\t\\tthis.g = Math.pow( color.g, safeInverse );\\n\\t\\t\\tthis.b = Math.pow( color.b, safeInverse );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tconvertGammaToLinear: function () {\\n\\n\\t\\t\\tvar r = this.r, g = this.g, b = this.b;\\n\\n\\t\\t\\tthis.r = r * r;\\n\\t\\t\\tthis.g = g * g;\\n\\t\\t\\tthis.b = b * b;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tconvertLinearToGamma: function () {\\n\\n\\t\\t\\tthis.r = Math.sqrt( this.r );\\n\\t\\t\\tthis.g = Math.sqrt( this.g );\\n\\t\\t\\tthis.b = Math.sqrt( this.b );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetHex: function () {\\n\\n\\t\\t\\treturn ( this.r * 255 ) << 16 ^ ( this.g * 255 ) << 8 ^ ( this.b * 255 ) << 0;\\n\\n\\t\\t},\\n\\n\\t\\tgetHexString: function () {\\n\\n\\t\\t\\treturn ( '000000' + this.getHex().toString( 16 ) ).slice( - 6 );\\n\\n\\t\\t},\\n\\n\\t\\tgetHSL: function ( optionalTarget ) {\\n\\n\\t\\t\\t// h,s,l ranges are in 0.0 - 1.0\\n\\n\\t\\t\\tvar hsl = optionalTarget || { h: 0, s: 0, l: 0 };\\n\\n\\t\\t\\tvar r = this.r, g = this.g, b = this.b;\\n\\n\\t\\t\\tvar max = Math.max( r, g, b );\\n\\t\\t\\tvar min = Math.min( r, g, b );\\n\\n\\t\\t\\tvar hue, saturation;\\n\\t\\t\\tvar lightness = ( min + max ) / 2.0;\\n\\n\\t\\t\\tif ( min === max ) {\\n\\n\\t\\t\\t\\thue = 0;\\n\\t\\t\\t\\tsaturation = 0;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tvar delta = max - min;\\n\\n\\t\\t\\t\\tsaturation = lightness <= 0.5 ? delta / ( max + min ) : delta / ( 2 - max - min );\\n\\n\\t\\t\\t\\tswitch ( max ) {\\n\\n\\t\\t\\t\\t\\tcase r: hue = ( g - b ) / delta + ( g < b ? 6 : 0 ); break;\\n\\t\\t\\t\\t\\tcase g: hue = ( b - r ) / delta + 2; break;\\n\\t\\t\\t\\t\\tcase b: hue = ( r - g ) / delta + 4; break;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\thue /= 6;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\thsl.h = hue;\\n\\t\\t\\thsl.s = saturation;\\n\\t\\t\\thsl.l = lightness;\\n\\n\\t\\t\\treturn hsl;\\n\\n\\t\\t},\\n\\n\\t\\tgetStyle: function () {\\n\\n\\t\\t\\treturn 'rgb(' + ( ( this.r * 255 ) | 0 ) + ',' + ( ( this.g * 255 ) | 0 ) + ',' + ( ( this.b * 255 ) | 0 ) + ')';\\n\\n\\t\\t},\\n\\n\\t\\toffsetHSL: function ( h, s, l ) {\\n\\n\\t\\t\\tvar hsl = this.getHSL();\\n\\n\\t\\t\\thsl.h += h; hsl.s += s; hsl.l += l;\\n\\n\\t\\t\\tthis.setHSL( hsl.h, hsl.s, hsl.l );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tadd: function ( color ) {\\n\\n\\t\\t\\tthis.r += color.r;\\n\\t\\t\\tthis.g += color.g;\\n\\t\\t\\tthis.b += color.b;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddColors: function ( color1, color2 ) {\\n\\n\\t\\t\\tthis.r = color1.r + color2.r;\\n\\t\\t\\tthis.g = color1.g + color2.g;\\n\\t\\t\\tthis.b = color1.b + color2.b;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddScalar: function ( s ) {\\n\\n\\t\\t\\tthis.r += s;\\n\\t\\t\\tthis.g += s;\\n\\t\\t\\tthis.b += s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsub: function ( color ) {\\n\\n\\t\\t\\tthis.r = Math.max( 0, this.r - color.r );\\n\\t\\t\\tthis.g = Math.max( 0, this.g - color.g );\\n\\t\\t\\tthis.b = Math.max( 0, this.b - color.b );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiply: function ( color ) {\\n\\n\\t\\t\\tthis.r *= color.r;\\n\\t\\t\\tthis.g *= color.g;\\n\\t\\t\\tthis.b *= color.b;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyScalar: function ( s ) {\\n\\n\\t\\t\\tthis.r *= s;\\n\\t\\t\\tthis.g *= s;\\n\\t\\t\\tthis.b *= s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tlerp: function ( color, alpha ) {\\n\\n\\t\\t\\tthis.r += ( color.r - this.r ) * alpha;\\n\\t\\t\\tthis.g += ( color.g - this.g ) * alpha;\\n\\t\\t\\tthis.b += ( color.b - this.b ) * alpha;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( c ) {\\n\\n\\t\\t\\treturn ( c.r === this.r ) && ( c.g === this.g ) && ( c.b === this.b );\\n\\n\\t\\t},\\n\\n\\t\\tfromArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tthis.r = array[ offset ];\\n\\t\\t\\tthis.g = array[ offset + 1 ];\\n\\t\\t\\tthis.b = array[ offset + 2 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( array === undefined ) array = [];\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tarray[ offset ] = this.r;\\n\\t\\t\\tarray[ offset + 1 ] = this.g;\\n\\t\\t\\tarray[ offset + 2 ] = this.b;\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function () {\\n\\n\\t\\t\\treturn this.getHex();\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * Uniforms library for shared webgl shaders\\n\\t */\\n\\n\\tvar UniformsLib = {\\n\\n\\t\\tcommon: {\\n\\n\\t\\t\\tdiffuse: { value: new Color( 0xeeeeee ) },\\n\\t\\t\\topacity: { value: 1.0 },\\n\\n\\t\\t\\tmap: { value: null },\\n\\t\\t\\tuvTransform: { value: new Matrix3() },\\n\\n\\t\\t\\talphaMap: { value: null },\\n\\n\\t\\t},\\n\\n\\t\\tspecularmap: {\\n\\n\\t\\t\\tspecularMap: { value: null },\\n\\n\\t\\t},\\n\\n\\t\\tenvmap: {\\n\\n\\t\\t\\tenvMap: { value: null },\\n\\t\\t\\tflipEnvMap: { value: - 1 },\\n\\t\\t\\treflectivity: { value: 1.0 },\\n\\t\\t\\trefractionRatio: { value: 0.98 }\\n\\n\\t\\t},\\n\\n\\t\\taomap: {\\n\\n\\t\\t\\taoMap: { value: null },\\n\\t\\t\\taoMapIntensity: { value: 1 }\\n\\n\\t\\t},\\n\\n\\t\\tlightmap: {\\n\\n\\t\\t\\tlightMap: { value: null },\\n\\t\\t\\tlightMapIntensity: { value: 1 }\\n\\n\\t\\t},\\n\\n\\t\\temissivemap: {\\n\\n\\t\\t\\temissiveMap: { value: null }\\n\\n\\t\\t},\\n\\n\\t\\tbumpmap: {\\n\\n\\t\\t\\tbumpMap: { value: null },\\n\\t\\t\\tbumpScale: { value: 1 }\\n\\n\\t\\t},\\n\\n\\t\\tnormalmap: {\\n\\n\\t\\t\\tnormalMap: { value: null },\\n\\t\\t\\tnormalScale: { value: new Vector2( 1, 1 ) }\\n\\n\\t\\t},\\n\\n\\t\\tdisplacementmap: {\\n\\n\\t\\t\\tdisplacementMap: { value: null },\\n\\t\\t\\tdisplacementScale: { value: 1 },\\n\\t\\t\\tdisplacementBias: { value: 0 }\\n\\n\\t\\t},\\n\\n\\t\\troughnessmap: {\\n\\n\\t\\t\\troughnessMap: { value: null }\\n\\n\\t\\t},\\n\\n\\t\\tmetalnessmap: {\\n\\n\\t\\t\\tmetalnessMap: { value: null }\\n\\n\\t\\t},\\n\\n\\t\\tgradientmap: {\\n\\n\\t\\t\\tgradientMap: { value: null }\\n\\n\\t\\t},\\n\\n\\t\\tfog: {\\n\\n\\t\\t\\tfogDensity: { value: 0.00025 },\\n\\t\\t\\tfogNear: { value: 1 },\\n\\t\\t\\tfogFar: { value: 2000 },\\n\\t\\t\\tfogColor: { value: new Color( 0xffffff ) }\\n\\n\\t\\t},\\n\\n\\t\\tlights: {\\n\\n\\t\\t\\tambientLightColor: { value: [] },\\n\\n\\t\\t\\tdirectionalLights: { value: [], properties: {\\n\\t\\t\\t\\tdirection: {},\\n\\t\\t\\t\\tcolor: {},\\n\\n\\t\\t\\t\\tshadow: {},\\n\\t\\t\\t\\tshadowBias: {},\\n\\t\\t\\t\\tshadowRadius: {},\\n\\t\\t\\t\\tshadowMapSize: {}\\n\\t\\t\\t} },\\n\\n\\t\\t\\tdirectionalShadowMap: { value: [] },\\n\\t\\t\\tdirectionalShadowMatrix: { value: [] },\\n\\n\\t\\t\\tspotLights: { value: [], properties: {\\n\\t\\t\\t\\tcolor: {},\\n\\t\\t\\t\\tposition: {},\\n\\t\\t\\t\\tdirection: {},\\n\\t\\t\\t\\tdistance: {},\\n\\t\\t\\t\\tconeCos: {},\\n\\t\\t\\t\\tpenumbraCos: {},\\n\\t\\t\\t\\tdecay: {},\\n\\n\\t\\t\\t\\tshadow: {},\\n\\t\\t\\t\\tshadowBias: {},\\n\\t\\t\\t\\tshadowRadius: {},\\n\\t\\t\\t\\tshadowMapSize: {}\\n\\t\\t\\t} },\\n\\n\\t\\t\\tspotShadowMap: { value: [] },\\n\\t\\t\\tspotShadowMatrix: { value: [] },\\n\\n\\t\\t\\tpointLights: { value: [], properties: {\\n\\t\\t\\t\\tcolor: {},\\n\\t\\t\\t\\tposition: {},\\n\\t\\t\\t\\tdecay: {},\\n\\t\\t\\t\\tdistance: {},\\n\\n\\t\\t\\t\\tshadow: {},\\n\\t\\t\\t\\tshadowBias: {},\\n\\t\\t\\t\\tshadowRadius: {},\\n\\t\\t\\t\\tshadowMapSize: {},\\n\\t\\t\\t\\tshadowCameraNear: {},\\n\\t\\t\\t\\tshadowCameraFar: {}\\n\\t\\t\\t} },\\n\\n\\t\\t\\tpointShadowMap: { value: [] },\\n\\t\\t\\tpointShadowMatrix: { value: [] },\\n\\n\\t\\t\\themisphereLights: { value: [], properties: {\\n\\t\\t\\t\\tdirection: {},\\n\\t\\t\\t\\tskyColor: {},\\n\\t\\t\\t\\tgroundColor: {}\\n\\t\\t\\t} },\\n\\n\\t\\t\\t// TODO (abelnation): RectAreaLight BRDF data needs to be moved from example to main src\\n\\t\\t\\trectAreaLights: { value: [], properties: {\\n\\t\\t\\t\\tcolor: {},\\n\\t\\t\\t\\tposition: {},\\n\\t\\t\\t\\twidth: {},\\n\\t\\t\\t\\theight: {}\\n\\t\\t\\t} }\\n\\n\\t\\t},\\n\\n\\t\\tpoints: {\\n\\n\\t\\t\\tdiffuse: { value: new Color( 0xeeeeee ) },\\n\\t\\t\\topacity: { value: 1.0 },\\n\\t\\t\\tsize: { value: 1.0 },\\n\\t\\t\\tscale: { value: 1.0 },\\n\\t\\t\\tmap: { value: null },\\n\\t\\t\\tuvTransform: { value: new Matrix3() }\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * Uniform Utilities\\n\\t */\\n\\n\\tvar UniformsUtils = {\\n\\n\\t\\tmerge: function ( uniforms ) {\\n\\n\\t\\t\\tvar merged = {};\\n\\n\\t\\t\\tfor ( var u = 0; u < uniforms.length; u ++ ) {\\n\\n\\t\\t\\t\\tvar tmp = this.clone( uniforms[ u ] );\\n\\n\\t\\t\\t\\tfor ( var p in tmp ) {\\n\\n\\t\\t\\t\\t\\tmerged[ p ] = tmp[ p ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn merged;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function ( uniforms_src ) {\\n\\n\\t\\t\\tvar uniforms_dst = {};\\n\\n\\t\\t\\tfor ( var u in uniforms_src ) {\\n\\n\\t\\t\\t\\tuniforms_dst[ u ] = {};\\n\\n\\t\\t\\t\\tfor ( var p in uniforms_src[ u ] ) {\\n\\n\\t\\t\\t\\t\\tvar parameter_src = uniforms_src[ u ][ p ];\\n\\n\\t\\t\\t\\t\\tif ( parameter_src && ( parameter_src.isColor ||\\n\\t\\t\\t\\t\\t\\tparameter_src.isMatrix3 || parameter_src.isMatrix4 ||\\n\\t\\t\\t\\t\\t\\tparameter_src.isVector2 || parameter_src.isVector3 || parameter_src.isVector4 ||\\n\\t\\t\\t\\t\\t\\tparameter_src.isTexture ) ) {\\n\\n\\t\\t\\t\\t\\t\\tuniforms_dst[ u ][ p ] = parameter_src.clone();\\n\\n\\t\\t\\t\\t\\t} else if ( Array.isArray( parameter_src ) ) {\\n\\n\\t\\t\\t\\t\\t\\tuniforms_dst[ u ][ p ] = parameter_src.slice();\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tuniforms_dst[ u ][ p ] = parameter_src;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn uniforms_dst;\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\tvar alphamap_fragment = \\\"#ifdef USE_ALPHAMAP\\\\n\\\\tdiffuseColor.a *= texture2D( alphaMap, vUv ).g;\\\\n#endif\\\\n\\\";\\n\\n\\tvar alphamap_pars_fragment = \\\"#ifdef USE_ALPHAMAP\\\\n\\\\tuniform sampler2D alphaMap;\\\\n#endif\\\\n\\\";\\n\\n\\tvar alphatest_fragment = \\\"#ifdef ALPHATEST\\\\n\\\\tif ( diffuseColor.a < ALPHATEST ) discard;\\\\n#endif\\\\n\\\";\\n\\n\\tvar aomap_fragment = \\\"#ifdef USE_AOMAP\\\\n\\\\tfloat ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\\\\n\\\\treflectedLight.indirectDiffuse *= ambientOcclusion;\\\\n\\\\t#if defined( USE_ENVMAP ) && defined( PHYSICAL )\\\\n\\\\t\\\\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\\\\n\\\\t\\\\treflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.specularRoughness );\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar aomap_pars_fragment = \\\"#ifdef USE_AOMAP\\\\n\\\\tuniform sampler2D aoMap;\\\\n\\\\tuniform float aoMapIntensity;\\\\n#endif\\\";\\n\\n\\tvar begin_vertex = \\\"\\\\nvec3 transformed = vec3( position );\\\\n\\\";\\n\\n\\tvar beginnormal_vertex = \\\"\\\\nvec3 objectNormal = vec3( normal );\\\\n\\\";\\n\\n\\tvar bsdfs = \\\"float punctualLightIntensityToIrradianceFactor( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\\\\n\\\\tif( decayExponent > 0.0 ) {\\\\n#if defined ( PHYSICALLY_CORRECT_LIGHTS )\\\\n\\\\t\\\\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\\\\n\\\\t\\\\tfloat maxDistanceCutoffFactor = pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\\\\n\\\\t\\\\treturn distanceFalloff * maxDistanceCutoffFactor;\\\\n#else\\\\n\\\\t\\\\treturn pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );\\\\n#endif\\\\n\\\\t}\\\\n\\\\treturn 1.0;\\\\n}\\\\nvec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {\\\\n\\\\treturn RECIPROCAL_PI * diffuseColor;\\\\n}\\\\nvec3 F_Schlick( const in vec3 specularColor, const in float dotLH ) {\\\\n\\\\tfloat fresnel = exp2( ( -5.55473 * dotLH - 6.98316 ) * dotLH );\\\\n\\\\treturn ( 1.0 - specularColor ) * fresnel + specularColor;\\\\n}\\\\nfloat G_GGX_Smith( const in float alpha, const in float dotNL, const in float dotNV ) {\\\\n\\\\tfloat a2 = pow2( alpha );\\\\n\\\\tfloat gl = dotNL + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\\\\n\\\\tfloat gv = dotNV + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\\\\n\\\\treturn 1.0 / ( gl * gv );\\\\n}\\\\nfloat G_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\\\\n\\\\tfloat a2 = pow2( alpha );\\\\n\\\\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\\\\n\\\\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\\\\n\\\\treturn 0.5 / max( gv + gl, EPSILON );\\\\n}\\\\nfloat D_GGX( const in float alpha, const in float dotNH ) {\\\\n\\\\tfloat a2 = pow2( alpha );\\\\n\\\\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\\\\n\\\\treturn RECIPROCAL_PI * a2 / pow2( denom );\\\\n}\\\\nvec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float roughness ) {\\\\n\\\\tfloat alpha = pow2( roughness );\\\\n\\\\tvec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\\\\n\\\\tfloat dotNL = saturate( dot( geometry.normal, incidentLight.direction ) );\\\\n\\\\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\\\\n\\\\tfloat dotNH = saturate( dot( geometry.normal, halfDir ) );\\\\n\\\\tfloat dotLH = saturate( dot( incidentLight.direction, halfDir ) );\\\\n\\\\tvec3 F = F_Schlick( specularColor, dotLH );\\\\n\\\\tfloat G = G_GGX_SmithCorrelated( alpha, dotNL, dotNV );\\\\n\\\\tfloat D = D_GGX( alpha, dotNH );\\\\n\\\\treturn F * ( G * D );\\\\n}\\\\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\\\\n\\\\tconst float LUT_SIZE = 64.0;\\\\n\\\\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\\\\n\\\\tconst float LUT_BIAS = 0.5 / LUT_SIZE;\\\\n\\\\tfloat theta = acos( dot( N, V ) );\\\\n\\\\tvec2 uv = vec2(\\\\n\\\\t\\\\tsqrt( saturate( roughness ) ),\\\\n\\\\t\\\\tsaturate( theta / ( 0.5 * PI ) ) );\\\\n\\\\tuv = uv * LUT_SCALE + LUT_BIAS;\\\\n\\\\treturn uv;\\\\n}\\\\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\\\\n\\\\tfloat l = length( f );\\\\n\\\\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\\\\n}\\\\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\\\\n\\\\tfloat x = dot( v1, v2 );\\\\n\\\\tfloat y = abs( x );\\\\n\\\\tfloat a = 0.86267 + (0.49788 + 0.01436 * y ) * y;\\\\n\\\\tfloat b = 3.45068 + (4.18814 + y) * y;\\\\n\\\\tfloat v = a / b;\\\\n\\\\tfloat theta_sintheta = (x > 0.0) ? v : 0.5 * inversesqrt( 1.0 - x * x ) - v;\\\\n\\\\treturn cross( v1, v2 ) * theta_sintheta;\\\\n}\\\\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\\\\n\\\\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\\\\n\\\\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\\\\n\\\\tvec3 lightNormal = cross( v1, v2 );\\\\n\\\\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\\\\n\\\\tvec3 T1, T2;\\\\n\\\\tT1 = normalize( V - N * dot( V, N ) );\\\\n\\\\tT2 = - cross( N, T1 );\\\\n\\\\tmat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\\\\n\\\\tvec3 coords[ 4 ];\\\\n\\\\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\\\\n\\\\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\\\\n\\\\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\\\\n\\\\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\\\\n\\\\tcoords[ 0 ] = normalize( coords[ 0 ] );\\\\n\\\\tcoords[ 1 ] = normalize( coords[ 1 ] );\\\\n\\\\tcoords[ 2 ] = normalize( coords[ 2 ] );\\\\n\\\\tcoords[ 3 ] = normalize( coords[ 3 ] );\\\\n\\\\tvec3 vectorFormFactor = vec3( 0.0 );\\\\n\\\\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\\\\n\\\\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\\\\n\\\\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\\\\n\\\\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\\\\n\\\\tvec3 result = vec3( LTC_ClippedSphereFormFactor( vectorFormFactor ) );\\\\n\\\\treturn result;\\\\n}\\\\nvec3 BRDF_Specular_GGX_Environment( const in GeometricContext geometry, const in vec3 specularColor, const in float roughness ) {\\\\n\\\\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\\\\n\\\\tconst vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\\\\n\\\\tconst vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\\\\n\\\\tvec4 r = roughness * c0 + c1;\\\\n\\\\tfloat a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\\\\n\\\\tvec2 AB = vec2( -1.04, 1.04 ) * a004 + r.zw;\\\\n\\\\treturn specularColor * AB.x + AB.y;\\\\n}\\\\nfloat G_BlinnPhong_Implicit( ) {\\\\n\\\\treturn 0.25;\\\\n}\\\\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\\\\n\\\\treturn RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\\\\n}\\\\nvec3 BRDF_Specular_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess ) {\\\\n\\\\tvec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\\\\n\\\\tfloat dotNH = saturate( dot( geometry.normal, halfDir ) );\\\\n\\\\tfloat dotLH = saturate( dot( incidentLight.direction, halfDir ) );\\\\n\\\\tvec3 F = F_Schlick( specularColor, dotLH );\\\\n\\\\tfloat G = G_BlinnPhong_Implicit( );\\\\n\\\\tfloat D = D_BlinnPhong( shininess, dotNH );\\\\n\\\\treturn F * ( G * D );\\\\n}\\\\nfloat GGXRoughnessToBlinnExponent( const in float ggxRoughness ) {\\\\n\\\\treturn ( 2.0 / pow2( ggxRoughness + 0.0001 ) - 2.0 );\\\\n}\\\\nfloat BlinnExponentToGGXRoughness( const in float blinnExponent ) {\\\\n\\\\treturn sqrt( 2.0 / ( blinnExponent + 2.0 ) );\\\\n}\\\\n\\\";\\n\\n\\tvar bumpmap_pars_fragment = \\\"#ifdef USE_BUMPMAP\\\\n\\\\tuniform sampler2D bumpMap;\\\\n\\\\tuniform float bumpScale;\\\\n\\\\tvec2 dHdxy_fwd() {\\\\n\\\\t\\\\tvec2 dSTdx = dFdx( vUv );\\\\n\\\\t\\\\tvec2 dSTdy = dFdy( vUv );\\\\n\\\\t\\\\tfloat Hll = bumpScale * texture2D( bumpMap, vUv ).x;\\\\n\\\\t\\\\tfloat dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\\\\n\\\\t\\\\tfloat dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;\\\\n\\\\t\\\\treturn vec2( dBx, dBy );\\\\n\\\\t}\\\\n\\\\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy ) {\\\\n\\\\t\\\\tvec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );\\\\n\\\\t\\\\tvec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );\\\\n\\\\t\\\\tvec3 vN = surf_norm;\\\\n\\\\t\\\\tvec3 R1 = cross( vSigmaY, vN );\\\\n\\\\t\\\\tvec3 R2 = cross( vN, vSigmaX );\\\\n\\\\t\\\\tfloat fDet = dot( vSigmaX, R1 );\\\\n\\\\t\\\\tvec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\\\\n\\\\t\\\\treturn normalize( abs( fDet ) * surf_norm - vGrad );\\\\n\\\\t}\\\\n#endif\\\\n\\\";\\n\\n\\tvar clipping_planes_fragment = \\\"#if NUM_CLIPPING_PLANES > 0\\\\n\\\\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; ++ i ) {\\\\n\\\\t\\\\tvec4 plane = clippingPlanes[ i ];\\\\n\\\\t\\\\tif ( dot( vViewPosition, plane.xyz ) > plane.w ) discard;\\\\n\\\\t}\\\\n\\\\t\\\\t\\\\n\\\\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\\\\n\\\\t\\\\tbool clipped = true;\\\\n\\\\t\\\\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; ++ i ) {\\\\n\\\\t\\\\t\\\\tvec4 plane = clippingPlanes[ i ];\\\\n\\\\t\\\\t\\\\tclipped = ( dot( vViewPosition, plane.xyz ) > plane.w ) && clipped;\\\\n\\\\t\\\\t}\\\\n\\\\t\\\\tif ( clipped ) discard;\\\\n\\\\t\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar clipping_planes_pars_fragment = \\\"#if NUM_CLIPPING_PLANES > 0\\\\n\\\\t#if ! defined( PHYSICAL ) && ! defined( PHONG )\\\\n\\\\t\\\\tvarying vec3 vViewPosition;\\\\n\\\\t#endif\\\\n\\\\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\\\\n#endif\\\\n\\\";\\n\\n\\tvar clipping_planes_pars_vertex = \\\"#if NUM_CLIPPING_PLANES > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )\\\\n\\\\tvarying vec3 vViewPosition;\\\\n#endif\\\\n\\\";\\n\\n\\tvar clipping_planes_vertex = \\\"#if NUM_CLIPPING_PLANES > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )\\\\n\\\\tvViewPosition = - mvPosition.xyz;\\\\n#endif\\\\n\\\";\\n\\n\\tvar color_fragment = \\\"#ifdef USE_COLOR\\\\n\\\\tdiffuseColor.rgb *= vColor;\\\\n#endif\\\";\\n\\n\\tvar color_pars_fragment = \\\"#ifdef USE_COLOR\\\\n\\\\tvarying vec3 vColor;\\\\n#endif\\\\n\\\";\\n\\n\\tvar color_pars_vertex = \\\"#ifdef USE_COLOR\\\\n\\\\tvarying vec3 vColor;\\\\n#endif\\\";\\n\\n\\tvar color_vertex = \\\"#ifdef USE_COLOR\\\\n\\\\tvColor.xyz = color.xyz;\\\\n#endif\\\";\\n\\n\\tvar common = \\\"#define PI 3.14159265359\\\\n#define PI2 6.28318530718\\\\n#define PI_HALF 1.5707963267949\\\\n#define RECIPROCAL_PI 0.31830988618\\\\n#define RECIPROCAL_PI2 0.15915494\\\\n#define LOG2 1.442695\\\\n#define EPSILON 1e-6\\\\n#define saturate(a) clamp( a, 0.0, 1.0 )\\\\n#define whiteCompliment(a) ( 1.0 - saturate( a ) )\\\\nfloat pow2( const in float x ) { return x*x; }\\\\nfloat pow3( const in float x ) { return x*x*x; }\\\\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\\\\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\\\\nhighp float rand( const in vec2 uv ) {\\\\n\\\\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\\\\n\\\\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\\\\n\\\\treturn fract(sin(sn) * c);\\\\n}\\\\nstruct IncidentLight {\\\\n\\\\tvec3 color;\\\\n\\\\tvec3 direction;\\\\n\\\\tbool visible;\\\\n};\\\\nstruct ReflectedLight {\\\\n\\\\tvec3 directDiffuse;\\\\n\\\\tvec3 directSpecular;\\\\n\\\\tvec3 indirectDiffuse;\\\\n\\\\tvec3 indirectSpecular;\\\\n};\\\\nstruct GeometricContext {\\\\n\\\\tvec3 position;\\\\n\\\\tvec3 normal;\\\\n\\\\tvec3 viewDir;\\\\n};\\\\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\\\\n\\\\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\\\\n}\\\\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\\\\n\\\\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\\\\n}\\\\nvec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\\\\n\\\\tfloat distance = dot( planeNormal, point - pointOnPlane );\\\\n\\\\treturn - distance * planeNormal + point;\\\\n}\\\\nfloat sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\\\\n\\\\treturn sign( dot( point - pointOnPlane, planeNormal ) );\\\\n}\\\\nvec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {\\\\n\\\\treturn lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;\\\\n}\\\\nmat3 transposeMat3( const in mat3 m ) {\\\\n\\\\tmat3 tmp;\\\\n\\\\ttmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\\\\n\\\\ttmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\\\\n\\\\ttmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\\\\n\\\\treturn tmp;\\\\n}\\\\nfloat linearToRelativeLuminance( const in vec3 color ) {\\\\n\\\\tvec3 weights = vec3( 0.2126, 0.7152, 0.0722 );\\\\n\\\\treturn dot( weights, color.rgb );\\\\n}\\\\n\\\";\\n\\n\\tvar cube_uv_reflection_fragment = \\\"#ifdef ENVMAP_TYPE_CUBE_UV\\\\n#define cubeUV_textureSize (1024.0)\\\\nint getFaceFromDirection(vec3 direction) {\\\\n\\\\tvec3 absDirection = abs(direction);\\\\n\\\\tint face = -1;\\\\n\\\\tif( absDirection.x > absDirection.z ) {\\\\n\\\\t\\\\tif(absDirection.x > absDirection.y )\\\\n\\\\t\\\\t\\\\tface = direction.x > 0.0 ? 0 : 3;\\\\n\\\\t\\\\telse\\\\n\\\\t\\\\t\\\\tface = direction.y > 0.0 ? 1 : 4;\\\\n\\\\t}\\\\n\\\\telse {\\\\n\\\\t\\\\tif(absDirection.z > absDirection.y )\\\\n\\\\t\\\\t\\\\tface = direction.z > 0.0 ? 2 : 5;\\\\n\\\\t\\\\telse\\\\n\\\\t\\\\t\\\\tface = direction.y > 0.0 ? 1 : 4;\\\\n\\\\t}\\\\n\\\\treturn face;\\\\n}\\\\n#define cubeUV_maxLods1 (log2(cubeUV_textureSize*0.25) - 1.0)\\\\n#define cubeUV_rangeClamp (exp2((6.0 - 1.0) * 2.0))\\\\nvec2 MipLevelInfo( vec3 vec, float roughnessLevel, float roughness ) {\\\\n\\\\tfloat scale = exp2(cubeUV_maxLods1 - roughnessLevel);\\\\n\\\\tfloat dxRoughness = dFdx(roughness);\\\\n\\\\tfloat dyRoughness = dFdy(roughness);\\\\n\\\\tvec3 dx = dFdx( vec * scale * dxRoughness );\\\\n\\\\tvec3 dy = dFdy( vec * scale * dyRoughness );\\\\n\\\\tfloat d = max( dot( dx, dx ), dot( dy, dy ) );\\\\n\\\\td = clamp(d, 1.0, cubeUV_rangeClamp);\\\\n\\\\tfloat mipLevel = 0.5 * log2(d);\\\\n\\\\treturn vec2(floor(mipLevel), fract(mipLevel));\\\\n}\\\\n#define cubeUV_maxLods2 (log2(cubeUV_textureSize*0.25) - 2.0)\\\\n#define cubeUV_rcpTextureSize (1.0 / cubeUV_textureSize)\\\\nvec2 getCubeUV(vec3 direction, float roughnessLevel, float mipLevel) {\\\\n\\\\tmipLevel = roughnessLevel > cubeUV_maxLods2 - 3.0 ? 0.0 : mipLevel;\\\\n\\\\tfloat a = 16.0 * cubeUV_rcpTextureSize;\\\\n\\\\tvec2 exp2_packed = exp2( vec2( roughnessLevel, mipLevel ) );\\\\n\\\\tvec2 rcp_exp2_packed = vec2( 1.0 ) / exp2_packed;\\\\n\\\\tfloat powScale = exp2_packed.x * exp2_packed.y;\\\\n\\\\tfloat scale = rcp_exp2_packed.x * rcp_exp2_packed.y * 0.25;\\\\n\\\\tfloat mipOffset = 0.75*(1.0 - rcp_exp2_packed.y) * rcp_exp2_packed.x;\\\\n\\\\tbool bRes = mipLevel == 0.0;\\\\n\\\\tscale = bRes && (scale < a) ? a : scale;\\\\n\\\\tvec3 r;\\\\n\\\\tvec2 offset;\\\\n\\\\tint face = getFaceFromDirection(direction);\\\\n\\\\tfloat rcpPowScale = 1.0 / powScale;\\\\n\\\\tif( face == 0) {\\\\n\\\\t\\\\tr = vec3(direction.x, -direction.z, direction.y);\\\\n\\\\t\\\\toffset = vec2(0.0+mipOffset,0.75 * rcpPowScale);\\\\n\\\\t\\\\toffset.y = bRes && (offset.y < 2.0*a) ? a : offset.y;\\\\n\\\\t}\\\\n\\\\telse if( face == 1) {\\\\n\\\\t\\\\tr = vec3(direction.y, direction.x, direction.z);\\\\n\\\\t\\\\toffset = vec2(scale+mipOffset, 0.75 * rcpPowScale);\\\\n\\\\t\\\\toffset.y = bRes && (offset.y < 2.0*a) ? a : offset.y;\\\\n\\\\t}\\\\n\\\\telse if( face == 2) {\\\\n\\\\t\\\\tr = vec3(direction.z, direction.x, direction.y);\\\\n\\\\t\\\\toffset = vec2(2.0*scale+mipOffset, 0.75 * rcpPowScale);\\\\n\\\\t\\\\toffset.y = bRes && (offset.y < 2.0*a) ? a : offset.y;\\\\n\\\\t}\\\\n\\\\telse if( face == 3) {\\\\n\\\\t\\\\tr = vec3(direction.x, direction.z, direction.y);\\\\n\\\\t\\\\toffset = vec2(0.0+mipOffset,0.5 * rcpPowScale);\\\\n\\\\t\\\\toffset.y = bRes && (offset.y < 2.0*a) ? 0.0 : offset.y;\\\\n\\\\t}\\\\n\\\\telse if( face == 4) {\\\\n\\\\t\\\\tr = vec3(direction.y, direction.x, -direction.z);\\\\n\\\\t\\\\toffset = vec2(scale+mipOffset, 0.5 * rcpPowScale);\\\\n\\\\t\\\\toffset.y = bRes && (offset.y < 2.0*a) ? 0.0 : offset.y;\\\\n\\\\t}\\\\n\\\\telse {\\\\n\\\\t\\\\tr = vec3(direction.z, -direction.x, direction.y);\\\\n\\\\t\\\\toffset = vec2(2.0*scale+mipOffset, 0.5 * rcpPowScale);\\\\n\\\\t\\\\toffset.y = bRes && (offset.y < 2.0*a) ? 0.0 : offset.y;\\\\n\\\\t}\\\\n\\\\tr = normalize(r);\\\\n\\\\tfloat texelOffset = 0.5 * cubeUV_rcpTextureSize;\\\\n\\\\tvec2 s = ( r.yz / abs( r.x ) + vec2( 1.0 ) ) * 0.5;\\\\n\\\\tvec2 base = offset + vec2( texelOffset );\\\\n\\\\treturn base + s * ( scale - 2.0 * texelOffset );\\\\n}\\\\n#define cubeUV_maxLods3 (log2(cubeUV_textureSize*0.25) - 3.0)\\\\nvec4 textureCubeUV(vec3 reflectedDirection, float roughness ) {\\\\n\\\\tfloat roughnessVal = roughness* cubeUV_maxLods3;\\\\n\\\\tfloat r1 = floor(roughnessVal);\\\\n\\\\tfloat r2 = r1 + 1.0;\\\\n\\\\tfloat t = fract(roughnessVal);\\\\n\\\\tvec2 mipInfo = MipLevelInfo(reflectedDirection, r1, roughness);\\\\n\\\\tfloat s = mipInfo.y;\\\\n\\\\tfloat level0 = mipInfo.x;\\\\n\\\\tfloat level1 = level0 + 1.0;\\\\n\\\\tlevel1 = level1 > 5.0 ? 5.0 : level1;\\\\n\\\\tlevel0 += min( floor( s + 0.5 ), 5.0 );\\\\n\\\\tvec2 uv_10 = getCubeUV(reflectedDirection, r1, level0);\\\\n\\\\tvec4 color10 = envMapTexelToLinear(texture2D(envMap, uv_10));\\\\n\\\\tvec2 uv_20 = getCubeUV(reflectedDirection, r2, level0);\\\\n\\\\tvec4 color20 = envMapTexelToLinear(texture2D(envMap, uv_20));\\\\n\\\\tvec4 result = mix(color10, color20, t);\\\\n\\\\treturn vec4(result.rgb, 1.0);\\\\n}\\\\n#endif\\\\n\\\";\\n\\n\\tvar defaultnormal_vertex = \\\"vec3 transformedNormal = normalMatrix * objectNormal;\\\\n#ifdef FLIP_SIDED\\\\n\\\\ttransformedNormal = - transformedNormal;\\\\n#endif\\\\n\\\";\\n\\n\\tvar displacementmap_pars_vertex = \\\"#ifdef USE_DISPLACEMENTMAP\\\\n\\\\tuniform sampler2D displacementMap;\\\\n\\\\tuniform float displacementScale;\\\\n\\\\tuniform float displacementBias;\\\\n#endif\\\\n\\\";\\n\\n\\tvar displacementmap_vertex = \\\"#ifdef USE_DISPLACEMENTMAP\\\\n\\\\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, uv ).x * displacementScale + displacementBias );\\\\n#endif\\\\n\\\";\\n\\n\\tvar emissivemap_fragment = \\\"#ifdef USE_EMISSIVEMAP\\\\n\\\\tvec4 emissiveColor = texture2D( emissiveMap, vUv );\\\\n\\\\temissiveColor.rgb = emissiveMapTexelToLinear( emissiveColor ).rgb;\\\\n\\\\ttotalEmissiveRadiance *= emissiveColor.rgb;\\\\n#endif\\\\n\\\";\\n\\n\\tvar emissivemap_pars_fragment = \\\"#ifdef USE_EMISSIVEMAP\\\\n\\\\tuniform sampler2D emissiveMap;\\\\n#endif\\\\n\\\";\\n\\n\\tvar encodings_fragment = \\\" gl_FragColor = linearToOutputTexel( gl_FragColor );\\\\n\\\";\\n\\n\\tvar encodings_pars_fragment = \\\"\\\\nvec4 LinearToLinear( in vec4 value ) {\\\\n\\\\treturn value;\\\\n}\\\\nvec4 GammaToLinear( in vec4 value, in float gammaFactor ) {\\\\n\\\\treturn vec4( pow( value.xyz, vec3( gammaFactor ) ), value.w );\\\\n}\\\\nvec4 LinearToGamma( in vec4 value, in float gammaFactor ) {\\\\n\\\\treturn vec4( pow( value.xyz, vec3( 1.0 / gammaFactor ) ), value.w );\\\\n}\\\\nvec4 sRGBToLinear( in vec4 value ) {\\\\n\\\\treturn vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.w );\\\\n}\\\\nvec4 LinearTosRGB( in vec4 value ) {\\\\n\\\\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.w );\\\\n}\\\\nvec4 RGBEToLinear( in vec4 value ) {\\\\n\\\\treturn vec4( value.rgb * exp2( value.a * 255.0 - 128.0 ), 1.0 );\\\\n}\\\\nvec4 LinearToRGBE( in vec4 value ) {\\\\n\\\\tfloat maxComponent = max( max( value.r, value.g ), value.b );\\\\n\\\\tfloat fExp = clamp( ceil( log2( maxComponent ) ), -128.0, 127.0 );\\\\n\\\\treturn vec4( value.rgb / exp2( fExp ), ( fExp + 128.0 ) / 255.0 );\\\\n}\\\\nvec4 RGBMToLinear( in vec4 value, in float maxRange ) {\\\\n\\\\treturn vec4( value.xyz * value.w * maxRange, 1.0 );\\\\n}\\\\nvec4 LinearToRGBM( in vec4 value, in float maxRange ) {\\\\n\\\\tfloat maxRGB = max( value.x, max( value.g, value.b ) );\\\\n\\\\tfloat M = clamp( maxRGB / maxRange, 0.0, 1.0 );\\\\n\\\\tM = ceil( M * 255.0 ) / 255.0;\\\\n\\\\treturn vec4( value.rgb / ( M * maxRange ), M );\\\\n}\\\\nvec4 RGBDToLinear( in vec4 value, in float maxRange ) {\\\\n\\\\treturn vec4( value.rgb * ( ( maxRange / 255.0 ) / value.a ), 1.0 );\\\\n}\\\\nvec4 LinearToRGBD( in vec4 value, in float maxRange ) {\\\\n\\\\tfloat maxRGB = max( value.x, max( value.g, value.b ) );\\\\n\\\\tfloat D = max( maxRange / maxRGB, 1.0 );\\\\n\\\\tD = min( floor( D ) / 255.0, 1.0 );\\\\n\\\\treturn vec4( value.rgb * ( D * ( 255.0 / maxRange ) ), D );\\\\n}\\\\nconst mat3 cLogLuvM = mat3( 0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969 );\\\\nvec4 LinearToLogLuv( in vec4 value ) {\\\\n\\\\tvec3 Xp_Y_XYZp = value.rgb * cLogLuvM;\\\\n\\\\tXp_Y_XYZp = max(Xp_Y_XYZp, vec3(1e-6, 1e-6, 1e-6));\\\\n\\\\tvec4 vResult;\\\\n\\\\tvResult.xy = Xp_Y_XYZp.xy / Xp_Y_XYZp.z;\\\\n\\\\tfloat Le = 2.0 * log2(Xp_Y_XYZp.y) + 127.0;\\\\n\\\\tvResult.w = fract(Le);\\\\n\\\\tvResult.z = (Le - (floor(vResult.w*255.0))/255.0)/255.0;\\\\n\\\\treturn vResult;\\\\n}\\\\nconst mat3 cLogLuvInverseM = mat3( 6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268 );\\\\nvec4 LogLuvToLinear( in vec4 value ) {\\\\n\\\\tfloat Le = value.z * 255.0 + value.w;\\\\n\\\\tvec3 Xp_Y_XYZp;\\\\n\\\\tXp_Y_XYZp.y = exp2((Le - 127.0) / 2.0);\\\\n\\\\tXp_Y_XYZp.z = Xp_Y_XYZp.y / value.y;\\\\n\\\\tXp_Y_XYZp.x = value.x * Xp_Y_XYZp.z;\\\\n\\\\tvec3 vRGB = Xp_Y_XYZp.rgb * cLogLuvInverseM;\\\\n\\\\treturn vec4( max(vRGB, 0.0), 1.0 );\\\\n}\\\\n\\\";\\n\\n\\tvar envmap_fragment = \\\"#ifdef USE_ENVMAP\\\\n\\\\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\\\\n\\\\t\\\\tvec3 cameraToVertex = normalize( vWorldPosition - cameraPosition );\\\\n\\\\t\\\\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\\\\n\\\\t\\\\t#ifdef ENVMAP_MODE_REFLECTION\\\\n\\\\t\\\\t\\\\tvec3 reflectVec = reflect( cameraToVertex, worldNormal );\\\\n\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\tvec3 reflectVec = refract( cameraToVertex, worldNormal, refractionRatio );\\\\n\\\\t\\\\t#endif\\\\n\\\\t#else\\\\n\\\\t\\\\tvec3 reflectVec = vReflect;\\\\n\\\\t#endif\\\\n\\\\t#ifdef ENVMAP_TYPE_CUBE\\\\n\\\\t\\\\tvec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\\\\n\\\\t#elif defined( ENVMAP_TYPE_EQUIREC )\\\\n\\\\t\\\\tvec2 sampleUV;\\\\n\\\\t\\\\treflectVec = normalize( reflectVec );\\\\n\\\\t\\\\tsampleUV.y = asin( clamp( reflectVec.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\\\\n\\\\t\\\\tsampleUV.x = atan( reflectVec.z, reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\\\\n\\\\t\\\\tvec4 envColor = texture2D( envMap, sampleUV );\\\\n\\\\t#elif defined( ENVMAP_TYPE_SPHERE )\\\\n\\\\t\\\\treflectVec = normalize( reflectVec );\\\\n\\\\t\\\\tvec3 reflectView = normalize( ( viewMatrix * vec4( reflectVec, 0.0 ) ).xyz + vec3( 0.0, 0.0, 1.0 ) );\\\\n\\\\t\\\\tvec4 envColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5 );\\\\n\\\\t#else\\\\n\\\\t\\\\tvec4 envColor = vec4( 0.0 );\\\\n\\\\t#endif\\\\n\\\\tenvColor = envMapTexelToLinear( envColor );\\\\n\\\\t#ifdef ENVMAP_BLENDING_MULTIPLY\\\\n\\\\t\\\\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\\\\n\\\\t#elif defined( ENVMAP_BLENDING_MIX )\\\\n\\\\t\\\\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\\\\n\\\\t#elif defined( ENVMAP_BLENDING_ADD )\\\\n\\\\t\\\\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar envmap_pars_fragment = \\\"#if defined( USE_ENVMAP ) || defined( PHYSICAL )\\\\n\\\\tuniform float reflectivity;\\\\n\\\\tuniform float envMapIntensity;\\\\n#endif\\\\n#ifdef USE_ENVMAP\\\\n\\\\t#if ! defined( PHYSICAL ) && ( defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) )\\\\n\\\\t\\\\tvarying vec3 vWorldPosition;\\\\n\\\\t#endif\\\\n\\\\t#ifdef ENVMAP_TYPE_CUBE\\\\n\\\\t\\\\tuniform samplerCube envMap;\\\\n\\\\t#else\\\\n\\\\t\\\\tuniform sampler2D envMap;\\\\n\\\\t#endif\\\\n\\\\tuniform float flipEnvMap;\\\\n\\\\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( PHYSICAL )\\\\n\\\\t\\\\tuniform float refractionRatio;\\\\n\\\\t#else\\\\n\\\\t\\\\tvarying vec3 vReflect;\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar envmap_pars_vertex = \\\"#ifdef USE_ENVMAP\\\\n\\\\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\\\\n\\\\t\\\\tvarying vec3 vWorldPosition;\\\\n\\\\t#else\\\\n\\\\t\\\\tvarying vec3 vReflect;\\\\n\\\\t\\\\tuniform float refractionRatio;\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar envmap_vertex = \\\"#ifdef USE_ENVMAP\\\\n\\\\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\\\\n\\\\t\\\\tvWorldPosition = worldPosition.xyz;\\\\n\\\\t#else\\\\n\\\\t\\\\tvec3 cameraToVertex = normalize( worldPosition.xyz - cameraPosition );\\\\n\\\\t\\\\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\\\\n\\\\t\\\\t#ifdef ENVMAP_MODE_REFLECTION\\\\n\\\\t\\\\t\\\\tvReflect = reflect( cameraToVertex, worldNormal );\\\\n\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\\\\n\\\\t\\\\t#endif\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar fog_vertex = \\\"\\\\n#ifdef USE_FOG\\\\nfogDepth = -mvPosition.z;\\\\n#endif\\\";\\n\\n\\tvar fog_pars_vertex = \\\"#ifdef USE_FOG\\\\n varying float fogDepth;\\\\n#endif\\\\n\\\";\\n\\n\\tvar fog_fragment = \\\"#ifdef USE_FOG\\\\n\\\\t#ifdef FOG_EXP2\\\\n\\\\t\\\\tfloat fogFactor = whiteCompliment( exp2( - fogDensity * fogDensity * fogDepth * fogDepth * LOG2 ) );\\\\n\\\\t#else\\\\n\\\\t\\\\tfloat fogFactor = smoothstep( fogNear, fogFar, fogDepth );\\\\n\\\\t#endif\\\\n\\\\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\\\\n#endif\\\\n\\\";\\n\\n\\tvar fog_pars_fragment = \\\"#ifdef USE_FOG\\\\n\\\\tuniform vec3 fogColor;\\\\n\\\\tvarying float fogDepth;\\\\n\\\\t#ifdef FOG_EXP2\\\\n\\\\t\\\\tuniform float fogDensity;\\\\n\\\\t#else\\\\n\\\\t\\\\tuniform float fogNear;\\\\n\\\\t\\\\tuniform float fogFar;\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar gradientmap_pars_fragment = \\\"#ifdef TOON\\\\n\\\\tuniform sampler2D gradientMap;\\\\n\\\\tvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\\\\n\\\\t\\\\tfloat dotNL = dot( normal, lightDirection );\\\\n\\\\t\\\\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\\\\n\\\\t\\\\t#ifdef USE_GRADIENTMAP\\\\n\\\\t\\\\t\\\\treturn texture2D( gradientMap, coord ).rgb;\\\\n\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\treturn ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );\\\\n\\\\t\\\\t#endif\\\\n\\\\t}\\\\n#endif\\\\n\\\";\\n\\n\\tvar lightmap_fragment = \\\"#ifdef USE_LIGHTMAP\\\\n\\\\treflectedLight.indirectDiffuse += PI * texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\\\\n#endif\\\\n\\\";\\n\\n\\tvar lightmap_pars_fragment = \\\"#ifdef USE_LIGHTMAP\\\\n\\\\tuniform sampler2D lightMap;\\\\n\\\\tuniform float lightMapIntensity;\\\\n#endif\\\";\\n\\n\\tvar lights_lambert_vertex = \\\"vec3 diffuse = vec3( 1.0 );\\\\nGeometricContext geometry;\\\\ngeometry.position = mvPosition.xyz;\\\\ngeometry.normal = normalize( transformedNormal );\\\\ngeometry.viewDir = normalize( -mvPosition.xyz );\\\\nGeometricContext backGeometry;\\\\nbackGeometry.position = geometry.position;\\\\nbackGeometry.normal = -geometry.normal;\\\\nbackGeometry.viewDir = geometry.viewDir;\\\\nvLightFront = vec3( 0.0 );\\\\n#ifdef DOUBLE_SIDED\\\\n\\\\tvLightBack = vec3( 0.0 );\\\\n#endif\\\\nIncidentLight directLight;\\\\nfloat dotNL;\\\\nvec3 directLightColor_Diffuse;\\\\n#if NUM_POINT_LIGHTS > 0\\\\n\\\\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tgetPointDirectLightIrradiance( pointLights[ i ], geometry, directLight );\\\\n\\\\t\\\\tdotNL = dot( geometry.normal, directLight.direction );\\\\n\\\\t\\\\tdirectLightColor_Diffuse = PI * directLight.color;\\\\n\\\\t\\\\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\\\\n\\\\t\\\\t#ifdef DOUBLE_SIDED\\\\n\\\\t\\\\t\\\\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\\\\n\\\\t\\\\t#endif\\\\n\\\\t}\\\\n#endif\\\\n#if NUM_SPOT_LIGHTS > 0\\\\n\\\\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tgetSpotDirectLightIrradiance( spotLights[ i ], geometry, directLight );\\\\n\\\\t\\\\tdotNL = dot( geometry.normal, directLight.direction );\\\\n\\\\t\\\\tdirectLightColor_Diffuse = PI * directLight.color;\\\\n\\\\t\\\\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\\\\n\\\\t\\\\t#ifdef DOUBLE_SIDED\\\\n\\\\t\\\\t\\\\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\\\\n\\\\t\\\\t#endif\\\\n\\\\t}\\\\n#endif\\\\n#if NUM_DIR_LIGHTS > 0\\\\n\\\\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tgetDirectionalDirectLightIrradiance( directionalLights[ i ], geometry, directLight );\\\\n\\\\t\\\\tdotNL = dot( geometry.normal, directLight.direction );\\\\n\\\\t\\\\tdirectLightColor_Diffuse = PI * directLight.color;\\\\n\\\\t\\\\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\\\\n\\\\t\\\\t#ifdef DOUBLE_SIDED\\\\n\\\\t\\\\t\\\\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\\\\n\\\\t\\\\t#endif\\\\n\\\\t}\\\\n#endif\\\\n#if NUM_HEMI_LIGHTS > 0\\\\n\\\\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tvLightFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\\\\n\\\\t\\\\t#ifdef DOUBLE_SIDED\\\\n\\\\t\\\\t\\\\tvLightBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry );\\\\n\\\\t\\\\t#endif\\\\n\\\\t}\\\\n#endif\\\\n\\\";\\n\\n\\tvar lights_pars = \\\"uniform vec3 ambientLightColor;\\\\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\\\\n\\\\tvec3 irradiance = ambientLightColor;\\\\n\\\\t#ifndef PHYSICALLY_CORRECT_LIGHTS\\\\n\\\\t\\\\tirradiance *= PI;\\\\n\\\\t#endif\\\\n\\\\treturn irradiance;\\\\n}\\\\n#if NUM_DIR_LIGHTS > 0\\\\n\\\\tstruct DirectionalLight {\\\\n\\\\t\\\\tvec3 direction;\\\\n\\\\t\\\\tvec3 color;\\\\n\\\\t\\\\tint shadow;\\\\n\\\\t\\\\tfloat shadowBias;\\\\n\\\\t\\\\tfloat shadowRadius;\\\\n\\\\t\\\\tvec2 shadowMapSize;\\\\n\\\\t};\\\\n\\\\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\\\\n\\\\tvoid getDirectionalDirectLightIrradiance( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight directLight ) {\\\\n\\\\t\\\\tdirectLight.color = directionalLight.color;\\\\n\\\\t\\\\tdirectLight.direction = directionalLight.direction;\\\\n\\\\t\\\\tdirectLight.visible = true;\\\\n\\\\t}\\\\n#endif\\\\n#if NUM_POINT_LIGHTS > 0\\\\n\\\\tstruct PointLight {\\\\n\\\\t\\\\tvec3 position;\\\\n\\\\t\\\\tvec3 color;\\\\n\\\\t\\\\tfloat distance;\\\\n\\\\t\\\\tfloat decay;\\\\n\\\\t\\\\tint shadow;\\\\n\\\\t\\\\tfloat shadowBias;\\\\n\\\\t\\\\tfloat shadowRadius;\\\\n\\\\t\\\\tvec2 shadowMapSize;\\\\n\\\\t\\\\tfloat shadowCameraNear;\\\\n\\\\t\\\\tfloat shadowCameraFar;\\\\n\\\\t};\\\\n\\\\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\\\\n\\\\tvoid getPointDirectLightIrradiance( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight directLight ) {\\\\n\\\\t\\\\tvec3 lVector = pointLight.position - geometry.position;\\\\n\\\\t\\\\tdirectLight.direction = normalize( lVector );\\\\n\\\\t\\\\tfloat lightDistance = length( lVector );\\\\n\\\\t\\\\tdirectLight.color = pointLight.color;\\\\n\\\\t\\\\tdirectLight.color *= punctualLightIntensityToIrradianceFactor( lightDistance, pointLight.distance, pointLight.decay );\\\\n\\\\t\\\\tdirectLight.visible = ( directLight.color != vec3( 0.0 ) );\\\\n\\\\t}\\\\n#endif\\\\n#if NUM_SPOT_LIGHTS > 0\\\\n\\\\tstruct SpotLight {\\\\n\\\\t\\\\tvec3 position;\\\\n\\\\t\\\\tvec3 direction;\\\\n\\\\t\\\\tvec3 color;\\\\n\\\\t\\\\tfloat distance;\\\\n\\\\t\\\\tfloat decay;\\\\n\\\\t\\\\tfloat coneCos;\\\\n\\\\t\\\\tfloat penumbraCos;\\\\n\\\\t\\\\tint shadow;\\\\n\\\\t\\\\tfloat shadowBias;\\\\n\\\\t\\\\tfloat shadowRadius;\\\\n\\\\t\\\\tvec2 shadowMapSize;\\\\n\\\\t};\\\\n\\\\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\\\\n\\\\tvoid getSpotDirectLightIrradiance( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight directLight ) {\\\\n\\\\t\\\\tvec3 lVector = spotLight.position - geometry.position;\\\\n\\\\t\\\\tdirectLight.direction = normalize( lVector );\\\\n\\\\t\\\\tfloat lightDistance = length( lVector );\\\\n\\\\t\\\\tfloat angleCos = dot( directLight.direction, spotLight.direction );\\\\n\\\\t\\\\tif ( angleCos > spotLight.coneCos ) {\\\\n\\\\t\\\\t\\\\tfloat spotEffect = smoothstep( spotLight.coneCos, spotLight.penumbraCos, angleCos );\\\\n\\\\t\\\\t\\\\tdirectLight.color = spotLight.color;\\\\n\\\\t\\\\t\\\\tdirectLight.color *= spotEffect * punctualLightIntensityToIrradianceFactor( lightDistance, spotLight.distance, spotLight.decay );\\\\n\\\\t\\\\t\\\\tdirectLight.visible = true;\\\\n\\\\t\\\\t} else {\\\\n\\\\t\\\\t\\\\tdirectLight.color = vec3( 0.0 );\\\\n\\\\t\\\\t\\\\tdirectLight.visible = false;\\\\n\\\\t\\\\t}\\\\n\\\\t}\\\\n#endif\\\\n#if NUM_RECT_AREA_LIGHTS > 0\\\\n\\\\tstruct RectAreaLight {\\\\n\\\\t\\\\tvec3 color;\\\\n\\\\t\\\\tvec3 position;\\\\n\\\\t\\\\tvec3 halfWidth;\\\\n\\\\t\\\\tvec3 halfHeight;\\\\n\\\\t};\\\\n\\\\tuniform sampler2D ltcMat;\\\\tuniform sampler2D ltcMag;\\\\n\\\\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\\\\n#endif\\\\n#if NUM_HEMI_LIGHTS > 0\\\\n\\\\tstruct HemisphereLight {\\\\n\\\\t\\\\tvec3 direction;\\\\n\\\\t\\\\tvec3 skyColor;\\\\n\\\\t\\\\tvec3 groundColor;\\\\n\\\\t};\\\\n\\\\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\\\\n\\\\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in GeometricContext geometry ) {\\\\n\\\\t\\\\tfloat dotNL = dot( geometry.normal, hemiLight.direction );\\\\n\\\\t\\\\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\\\\n\\\\t\\\\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\\\\n\\\\t\\\\t#ifndef PHYSICALLY_CORRECT_LIGHTS\\\\n\\\\t\\\\t\\\\tirradiance *= PI;\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\treturn irradiance;\\\\n\\\\t}\\\\n#endif\\\\n#if defined( USE_ENVMAP ) && defined( PHYSICAL )\\\\n\\\\tvec3 getLightProbeIndirectIrradiance( const in GeometricContext geometry, const in int maxMIPLevel ) {\\\\n\\\\t\\\\tvec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );\\\\n\\\\t\\\\t#ifdef ENVMAP_TYPE_CUBE\\\\n\\\\t\\\\t\\\\tvec3 queryVec = vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\\\\n\\\\t\\\\t\\\\t#ifdef TEXTURE_LOD_EXT\\\\n\\\\t\\\\t\\\\t\\\\tvec4 envMapColor = textureCubeLodEXT( envMap, queryVec, float( maxMIPLevel ) );\\\\n\\\\t\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\t\\\\tvec4 envMapColor = textureCube( envMap, queryVec, float( maxMIPLevel ) );\\\\n\\\\t\\\\t\\\\t#endif\\\\n\\\\t\\\\t\\\\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\\\\n\\\\t\\\\t#elif defined( ENVMAP_TYPE_CUBE_UV )\\\\n\\\\t\\\\t\\\\tvec3 queryVec = vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\\\\n\\\\t\\\\t\\\\tvec4 envMapColor = textureCubeUV( queryVec, 1.0 );\\\\n\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\tvec4 envMapColor = vec4( 0.0 );\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\treturn PI * envMapColor.rgb * envMapIntensity;\\\\n\\\\t}\\\\n\\\\tfloat getSpecularMIPLevel( const in float blinnShininessExponent, const in int maxMIPLevel ) {\\\\n\\\\t\\\\tfloat maxMIPLevelScalar = float( maxMIPLevel );\\\\n\\\\t\\\\tfloat desiredMIPLevel = maxMIPLevelScalar + 0.79248 - 0.5 * log2( pow2( blinnShininessExponent ) + 1.0 );\\\\n\\\\t\\\\treturn clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );\\\\n\\\\t}\\\\n\\\\tvec3 getLightProbeIndirectRadiance( const in GeometricContext geometry, const in float blinnShininessExponent, const in int maxMIPLevel ) {\\\\n\\\\t\\\\t#ifdef ENVMAP_MODE_REFLECTION\\\\n\\\\t\\\\t\\\\tvec3 reflectVec = reflect( -geometry.viewDir, geometry.normal );\\\\n\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\tvec3 reflectVec = refract( -geometry.viewDir, geometry.normal, refractionRatio );\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\\\\n\\\\t\\\\tfloat specularMIPLevel = getSpecularMIPLevel( blinnShininessExponent, maxMIPLevel );\\\\n\\\\t\\\\t#ifdef ENVMAP_TYPE_CUBE\\\\n\\\\t\\\\t\\\\tvec3 queryReflectVec = vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\\\\n\\\\t\\\\t\\\\t#ifdef TEXTURE_LOD_EXT\\\\n\\\\t\\\\t\\\\t\\\\tvec4 envMapColor = textureCubeLodEXT( envMap, queryReflectVec, specularMIPLevel );\\\\n\\\\t\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\t\\\\tvec4 envMapColor = textureCube( envMap, queryReflectVec, specularMIPLevel );\\\\n\\\\t\\\\t\\\\t#endif\\\\n\\\\t\\\\t\\\\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\\\\n\\\\t\\\\t#elif defined( ENVMAP_TYPE_CUBE_UV )\\\\n\\\\t\\\\t\\\\tvec3 queryReflectVec = vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\\\\n\\\\t\\\\t\\\\tvec4 envMapColor = textureCubeUV(queryReflectVec, BlinnExponentToGGXRoughness(blinnShininessExponent));\\\\n\\\\t\\\\t#elif defined( ENVMAP_TYPE_EQUIREC )\\\\n\\\\t\\\\t\\\\tvec2 sampleUV;\\\\n\\\\t\\\\t\\\\tsampleUV.y = asin( clamp( reflectVec.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\\\\n\\\\t\\\\t\\\\tsampleUV.x = atan( reflectVec.z, reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\\\\n\\\\t\\\\t\\\\t#ifdef TEXTURE_LOD_EXT\\\\n\\\\t\\\\t\\\\t\\\\tvec4 envMapColor = texture2DLodEXT( envMap, sampleUV, specularMIPLevel );\\\\n\\\\t\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\t\\\\tvec4 envMapColor = texture2D( envMap, sampleUV, specularMIPLevel );\\\\n\\\\t\\\\t\\\\t#endif\\\\n\\\\t\\\\t\\\\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\\\\n\\\\t\\\\t#elif defined( ENVMAP_TYPE_SPHERE )\\\\n\\\\t\\\\t\\\\tvec3 reflectView = normalize( ( viewMatrix * vec4( reflectVec, 0.0 ) ).xyz + vec3( 0.0,0.0,1.0 ) );\\\\n\\\\t\\\\t\\\\t#ifdef TEXTURE_LOD_EXT\\\\n\\\\t\\\\t\\\\t\\\\tvec4 envMapColor = texture2DLodEXT( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\\\\n\\\\t\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\t\\\\tvec4 envMapColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\\\\n\\\\t\\\\t\\\\t#endif\\\\n\\\\t\\\\t\\\\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\treturn envMapColor.rgb * envMapIntensity;\\\\n\\\\t}\\\\n#endif\\\\n\\\";\\n\\n\\tvar lights_phong_fragment = \\\"BlinnPhongMaterial material;\\\\nmaterial.diffuseColor = diffuseColor.rgb;\\\\nmaterial.specularColor = specular;\\\\nmaterial.specularShininess = shininess;\\\\nmaterial.specularStrength = specularStrength;\\\\n\\\";\\n\\n\\tvar lights_phong_pars_fragment = \\\"varying vec3 vViewPosition;\\\\n#ifndef FLAT_SHADED\\\\n\\\\tvarying vec3 vNormal;\\\\n#endif\\\\nstruct BlinnPhongMaterial {\\\\n\\\\tvec3\\\\tdiffuseColor;\\\\n\\\\tvec3\\\\tspecularColor;\\\\n\\\\tfloat\\\\tspecularShininess;\\\\n\\\\tfloat\\\\tspecularStrength;\\\\n};\\\\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\\\\n\\\\t#ifdef TOON\\\\n\\\\t\\\\tvec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;\\\\n\\\\t#else\\\\n\\\\t\\\\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\\\\n\\\\t\\\\tvec3 irradiance = dotNL * directLight.color;\\\\n\\\\t#endif\\\\n\\\\t#ifndef PHYSICALLY_CORRECT_LIGHTS\\\\n\\\\t\\\\tirradiance *= PI;\\\\n\\\\t#endif\\\\n\\\\treflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\\\\n\\\\treflectedLight.directSpecular += irradiance * BRDF_Specular_BlinnPhong( directLight, geometry, material.specularColor, material.specularShininess ) * material.specularStrength;\\\\n}\\\\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\\\\n\\\\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\\\\n}\\\\n#define RE_Direct\\\\t\\\\t\\\\t\\\\tRE_Direct_BlinnPhong\\\\n#define RE_IndirectDiffuse\\\\t\\\\tRE_IndirectDiffuse_BlinnPhong\\\\n#define Material_LightProbeLOD( material )\\\\t(0)\\\\n\\\";\\n\\n\\tvar lights_physical_fragment = \\\"PhysicalMaterial material;\\\\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\\\\nmaterial.specularRoughness = clamp( roughnessFactor, 0.04, 1.0 );\\\\n#ifdef STANDARD\\\\n\\\\tmaterial.specularColor = mix( vec3( DEFAULT_SPECULAR_COEFFICIENT ), diffuseColor.rgb, metalnessFactor );\\\\n#else\\\\n\\\\tmaterial.specularColor = mix( vec3( MAXIMUM_SPECULAR_COEFFICIENT * pow2( reflectivity ) ), diffuseColor.rgb, metalnessFactor );\\\\n\\\\tmaterial.clearCoat = saturate( clearCoat );\\\\tmaterial.clearCoatRoughness = clamp( clearCoatRoughness, 0.04, 1.0 );\\\\n#endif\\\\n\\\";\\n\\n\\tvar lights_physical_pars_fragment = \\\"struct PhysicalMaterial {\\\\n\\\\tvec3\\\\tdiffuseColor;\\\\n\\\\tfloat\\\\tspecularRoughness;\\\\n\\\\tvec3\\\\tspecularColor;\\\\n\\\\t#ifndef STANDARD\\\\n\\\\t\\\\tfloat clearCoat;\\\\n\\\\t\\\\tfloat clearCoatRoughness;\\\\n\\\\t#endif\\\\n};\\\\n#define MAXIMUM_SPECULAR_COEFFICIENT 0.16\\\\n#define DEFAULT_SPECULAR_COEFFICIENT 0.04\\\\nfloat clearCoatDHRApprox( const in float roughness, const in float dotNL ) {\\\\n\\\\treturn DEFAULT_SPECULAR_COEFFICIENT + ( 1.0 - DEFAULT_SPECULAR_COEFFICIENT ) * ( pow( 1.0 - dotNL, 5.0 ) * pow( 1.0 - roughness, 2.0 ) );\\\\n}\\\\n#if NUM_RECT_AREA_LIGHTS > 0\\\\n\\\\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\\\\n\\\\t\\\\tvec3 normal = geometry.normal;\\\\n\\\\t\\\\tvec3 viewDir = geometry.viewDir;\\\\n\\\\t\\\\tvec3 position = geometry.position;\\\\n\\\\t\\\\tvec3 lightPos = rectAreaLight.position;\\\\n\\\\t\\\\tvec3 halfWidth = rectAreaLight.halfWidth;\\\\n\\\\t\\\\tvec3 halfHeight = rectAreaLight.halfHeight;\\\\n\\\\t\\\\tvec3 lightColor = rectAreaLight.color;\\\\n\\\\t\\\\tfloat roughness = material.specularRoughness;\\\\n\\\\t\\\\tvec3 rectCoords[ 4 ];\\\\n\\\\t\\\\trectCoords[ 0 ] = lightPos - halfWidth - halfHeight;\\\\t\\\\trectCoords[ 1 ] = lightPos + halfWidth - halfHeight;\\\\n\\\\t\\\\trectCoords[ 2 ] = lightPos + halfWidth + halfHeight;\\\\n\\\\t\\\\trectCoords[ 3 ] = lightPos - halfWidth + halfHeight;\\\\n\\\\t\\\\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\\\\n\\\\t\\\\tfloat norm = texture2D( ltcMag, uv ).a;\\\\n\\\\t\\\\tvec4 t = texture2D( ltcMat, uv );\\\\n\\\\t\\\\tmat3 mInv = mat3(\\\\n\\\\t\\\\t\\\\tvec3( 1, 0, t.y ),\\\\n\\\\t\\\\t\\\\tvec3( 0, t.z, 0 ),\\\\n\\\\t\\\\t\\\\tvec3( t.w, 0, t.x )\\\\n\\\\t\\\\t);\\\\n\\\\t\\\\treflectedLight.directSpecular += lightColor * material.specularColor * norm * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\\\\n\\\\t\\\\treflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1 ), rectCoords );\\\\n\\\\t}\\\\n#endif\\\\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\\\\n\\\\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\\\\n\\\\tvec3 irradiance = dotNL * directLight.color;\\\\n\\\\t#ifndef PHYSICALLY_CORRECT_LIGHTS\\\\n\\\\t\\\\tirradiance *= PI;\\\\n\\\\t#endif\\\\n\\\\t#ifndef STANDARD\\\\n\\\\t\\\\tfloat clearCoatDHR = material.clearCoat * clearCoatDHRApprox( material.clearCoatRoughness, dotNL );\\\\n\\\\t#else\\\\n\\\\t\\\\tfloat clearCoatDHR = 0.0;\\\\n\\\\t#endif\\\\n\\\\treflectedLight.directSpecular += ( 1.0 - clearCoatDHR ) * irradiance * BRDF_Specular_GGX( directLight, geometry, material.specularColor, material.specularRoughness );\\\\n\\\\treflectedLight.directDiffuse += ( 1.0 - clearCoatDHR ) * irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\\\\n\\\\t#ifndef STANDARD\\\\n\\\\t\\\\treflectedLight.directSpecular += irradiance * material.clearCoat * BRDF_Specular_GGX( directLight, geometry, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearCoatRoughness );\\\\n\\\\t#endif\\\\n}\\\\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\\\\n\\\\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\\\\n}\\\\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 clearCoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\\\\n\\\\t#ifndef STANDARD\\\\n\\\\t\\\\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\\\\n\\\\t\\\\tfloat dotNL = dotNV;\\\\n\\\\t\\\\tfloat clearCoatDHR = material.clearCoat * clearCoatDHRApprox( material.clearCoatRoughness, dotNL );\\\\n\\\\t#else\\\\n\\\\t\\\\tfloat clearCoatDHR = 0.0;\\\\n\\\\t#endif\\\\n\\\\treflectedLight.indirectSpecular += ( 1.0 - clearCoatDHR ) * radiance * BRDF_Specular_GGX_Environment( geometry, material.specularColor, material.specularRoughness );\\\\n\\\\t#ifndef STANDARD\\\\n\\\\t\\\\treflectedLight.indirectSpecular += clearCoatRadiance * material.clearCoat * BRDF_Specular_GGX_Environment( geometry, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearCoatRoughness );\\\\n\\\\t#endif\\\\n}\\\\n#define RE_Direct\\\\t\\\\t\\\\t\\\\tRE_Direct_Physical\\\\n#define RE_Direct_RectArea\\\\t\\\\tRE_Direct_RectArea_Physical\\\\n#define RE_IndirectDiffuse\\\\t\\\\tRE_IndirectDiffuse_Physical\\\\n#define RE_IndirectSpecular\\\\t\\\\tRE_IndirectSpecular_Physical\\\\n#define Material_BlinnShininessExponent( material ) GGXRoughnessToBlinnExponent( material.specularRoughness )\\\\n#define Material_ClearCoat_BlinnShininessExponent( material ) GGXRoughnessToBlinnExponent( material.clearCoatRoughness )\\\\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\\\\n\\\\treturn saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\\\\n}\\\\n\\\";\\n\\n\\tvar lights_template = \\\"\\\\nGeometricContext geometry;\\\\ngeometry.position = - vViewPosition;\\\\ngeometry.normal = normal;\\\\ngeometry.viewDir = normalize( vViewPosition );\\\\nIncidentLight directLight;\\\\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\\\\n\\\\tPointLight pointLight;\\\\n\\\\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tpointLight = pointLights[ i ];\\\\n\\\\t\\\\tgetPointDirectLightIrradiance( pointLight, geometry, directLight );\\\\n\\\\t\\\\t#ifdef USE_SHADOWMAP\\\\n\\\\t\\\\tdirectLight.color *= all( bvec2( pointLight.shadow, directLight.visible ) ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\tRE_Direct( directLight, geometry, material, reflectedLight );\\\\n\\\\t}\\\\n#endif\\\\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\\\\n\\\\tSpotLight spotLight;\\\\n\\\\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tspotLight = spotLights[ i ];\\\\n\\\\t\\\\tgetSpotDirectLightIrradiance( spotLight, geometry, directLight );\\\\n\\\\t\\\\t#ifdef USE_SHADOWMAP\\\\n\\\\t\\\\tdirectLight.color *= all( bvec2( spotLight.shadow, directLight.visible ) ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\tRE_Direct( directLight, geometry, material, reflectedLight );\\\\n\\\\t}\\\\n#endif\\\\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\\\\n\\\\tDirectionalLight directionalLight;\\\\n\\\\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tdirectionalLight = directionalLights[ i ];\\\\n\\\\t\\\\tgetDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\\\\n\\\\t\\\\t#ifdef USE_SHADOWMAP\\\\n\\\\t\\\\tdirectLight.color *= all( bvec2( directionalLight.shadow, directLight.visible ) ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\tRE_Direct( directLight, geometry, material, reflectedLight );\\\\n\\\\t}\\\\n#endif\\\\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\\\\n\\\\tRectAreaLight rectAreaLight;\\\\n\\\\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\\\\n\\\\t\\\\trectAreaLight = rectAreaLights[ i ];\\\\n\\\\t\\\\tRE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );\\\\n\\\\t}\\\\n#endif\\\\n#if defined( RE_IndirectDiffuse )\\\\n\\\\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\\\\n\\\\t#ifdef USE_LIGHTMAP\\\\n\\\\t\\\\tvec3 lightMapIrradiance = texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\\\\n\\\\t\\\\t#ifndef PHYSICALLY_CORRECT_LIGHTS\\\\n\\\\t\\\\t\\\\tlightMapIrradiance *= PI;\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\tirradiance += lightMapIrradiance;\\\\n\\\\t#endif\\\\n\\\\t#if ( NUM_HEMI_LIGHTS > 0 )\\\\n\\\\t\\\\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\\\\n\\\\t\\\\t\\\\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\\\\n\\\\t\\\\t}\\\\n\\\\t#endif\\\\n\\\\t#if defined( USE_ENVMAP ) && defined( PHYSICAL ) && defined( ENVMAP_TYPE_CUBE_UV )\\\\n\\\\t\\\\tirradiance += getLightProbeIndirectIrradiance( geometry, 8 );\\\\n\\\\t#endif\\\\n\\\\tRE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );\\\\n#endif\\\\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\\\\n\\\\tvec3 radiance = getLightProbeIndirectRadiance( geometry, Material_BlinnShininessExponent( material ), 8 );\\\\n\\\\t#ifndef STANDARD\\\\n\\\\t\\\\tvec3 clearCoatRadiance = getLightProbeIndirectRadiance( geometry, Material_ClearCoat_BlinnShininessExponent( material ), 8 );\\\\n\\\\t#else\\\\n\\\\t\\\\tvec3 clearCoatRadiance = vec3( 0.0 );\\\\n\\\\t#endif\\\\n\\\\tRE_IndirectSpecular( radiance, clearCoatRadiance, geometry, material, reflectedLight );\\\\n#endif\\\\n\\\";\\n\\n\\tvar logdepthbuf_fragment = \\\"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\\\\n\\\\tgl_FragDepthEXT = log2( vFragDepth ) * logDepthBufFC * 0.5;\\\\n#endif\\\";\\n\\n\\tvar logdepthbuf_pars_fragment = \\\"#ifdef USE_LOGDEPTHBUF\\\\n\\\\tuniform float logDepthBufFC;\\\\n\\\\t#ifdef USE_LOGDEPTHBUF_EXT\\\\n\\\\t\\\\tvarying float vFragDepth;\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar logdepthbuf_pars_vertex = \\\"#ifdef USE_LOGDEPTHBUF\\\\n\\\\t#ifdef USE_LOGDEPTHBUF_EXT\\\\n\\\\t\\\\tvarying float vFragDepth;\\\\n\\\\t#endif\\\\n\\\\tuniform float logDepthBufFC;\\\\n#endif\\\";\\n\\n\\tvar logdepthbuf_vertex = \\\"#ifdef USE_LOGDEPTHBUF\\\\n\\\\t#ifdef USE_LOGDEPTHBUF_EXT\\\\n\\\\t\\\\tvFragDepth = 1.0 + gl_Position.w;\\\\n\\\\t#else\\\\n\\\\t\\\\tgl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;\\\\n\\\\t\\\\tgl_Position.z *= gl_Position.w;\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar map_fragment = \\\"#ifdef USE_MAP\\\\n\\\\tvec4 texelColor = texture2D( map, vUv );\\\\n\\\\ttexelColor = mapTexelToLinear( texelColor );\\\\n\\\\tdiffuseColor *= texelColor;\\\\n#endif\\\\n\\\";\\n\\n\\tvar map_pars_fragment = \\\"#ifdef USE_MAP\\\\n\\\\tuniform sampler2D map;\\\\n#endif\\\\n\\\";\\n\\n\\tvar map_particle_fragment = \\\"#ifdef USE_MAP\\\\n\\\\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\\\\n\\\\tvec4 mapTexel = texture2D( map, uv );\\\\n\\\\tdiffuseColor *= mapTexelToLinear( mapTexel );\\\\n#endif\\\\n\\\";\\n\\n\\tvar map_particle_pars_fragment = \\\"#ifdef USE_MAP\\\\n\\\\tuniform mat3 uvTransform;\\\\n\\\\tuniform sampler2D map;\\\\n#endif\\\\n\\\";\\n\\n\\tvar metalnessmap_fragment = \\\"float metalnessFactor = metalness;\\\\n#ifdef USE_METALNESSMAP\\\\n\\\\tvec4 texelMetalness = texture2D( metalnessMap, vUv );\\\\n\\\\tmetalnessFactor *= texelMetalness.b;\\\\n#endif\\\\n\\\";\\n\\n\\tvar metalnessmap_pars_fragment = \\\"#ifdef USE_METALNESSMAP\\\\n\\\\tuniform sampler2D metalnessMap;\\\\n#endif\\\";\\n\\n\\tvar morphnormal_vertex = \\\"#ifdef USE_MORPHNORMALS\\\\n\\\\tobjectNormal += ( morphNormal0 - normal ) * morphTargetInfluences[ 0 ];\\\\n\\\\tobjectNormal += ( morphNormal1 - normal ) * morphTargetInfluences[ 1 ];\\\\n\\\\tobjectNormal += ( morphNormal2 - normal ) * morphTargetInfluences[ 2 ];\\\\n\\\\tobjectNormal += ( morphNormal3 - normal ) * morphTargetInfluences[ 3 ];\\\\n#endif\\\\n\\\";\\n\\n\\tvar morphtarget_pars_vertex = \\\"#ifdef USE_MORPHTARGETS\\\\n\\\\t#ifndef USE_MORPHNORMALS\\\\n\\\\tuniform float morphTargetInfluences[ 8 ];\\\\n\\\\t#else\\\\n\\\\tuniform float morphTargetInfluences[ 4 ];\\\\n\\\\t#endif\\\\n#endif\\\";\\n\\n\\tvar morphtarget_vertex = \\\"#ifdef USE_MORPHTARGETS\\\\n\\\\ttransformed += ( morphTarget0 - position ) * morphTargetInfluences[ 0 ];\\\\n\\\\ttransformed += ( morphTarget1 - position ) * morphTargetInfluences[ 1 ];\\\\n\\\\ttransformed += ( morphTarget2 - position ) * morphTargetInfluences[ 2 ];\\\\n\\\\ttransformed += ( morphTarget3 - position ) * morphTargetInfluences[ 3 ];\\\\n\\\\t#ifndef USE_MORPHNORMALS\\\\n\\\\ttransformed += ( morphTarget4 - position ) * morphTargetInfluences[ 4 ];\\\\n\\\\ttransformed += ( morphTarget5 - position ) * morphTargetInfluences[ 5 ];\\\\n\\\\ttransformed += ( morphTarget6 - position ) * morphTargetInfluences[ 6 ];\\\\n\\\\ttransformed += ( morphTarget7 - position ) * morphTargetInfluences[ 7 ];\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar normal_fragment = \\\"#ifdef FLAT_SHADED\\\\n\\\\tvec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );\\\\n\\\\tvec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );\\\\n\\\\tvec3 normal = normalize( cross( fdx, fdy ) );\\\\n#else\\\\n\\\\tvec3 normal = normalize( vNormal );\\\\n\\\\t#ifdef DOUBLE_SIDED\\\\n\\\\t\\\\tnormal = normal * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\\\\n\\\\t#endif\\\\n#endif\\\\n#ifdef USE_NORMALMAP\\\\n\\\\tnormal = perturbNormal2Arb( -vViewPosition, normal );\\\\n#elif defined( USE_BUMPMAP )\\\\n\\\\tnormal = perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );\\\\n#endif\\\\n\\\";\\n\\n\\tvar normalmap_pars_fragment = \\\"#ifdef USE_NORMALMAP\\\\n\\\\tuniform sampler2D normalMap;\\\\n\\\\tuniform vec2 normalScale;\\\\n\\\\tvec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm ) {\\\\n\\\\t\\\\tvec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\\\\n\\\\t\\\\tvec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\\\\n\\\\t\\\\tvec2 st0 = dFdx( vUv.st );\\\\n\\\\t\\\\tvec2 st1 = dFdy( vUv.st );\\\\n\\\\t\\\\tvec3 S = normalize( q0 * st1.t - q1 * st0.t );\\\\n\\\\t\\\\tvec3 T = normalize( -q0 * st1.s + q1 * st0.s );\\\\n\\\\t\\\\tvec3 N = normalize( surf_norm );\\\\n\\\\t\\\\tvec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\\\\n\\\\t\\\\tmapN.xy = normalScale * mapN.xy;\\\\n\\\\t\\\\tmat3 tsn = mat3( S, T, N );\\\\n\\\\t\\\\treturn normalize( tsn * mapN );\\\\n\\\\t}\\\\n#endif\\\\n\\\";\\n\\n\\tvar packing = \\\"vec3 packNormalToRGB( const in vec3 normal ) {\\\\n\\\\treturn normalize( normal ) * 0.5 + 0.5;\\\\n}\\\\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\\\\n\\\\treturn 2.0 * rgb.xyz - 1.0;\\\\n}\\\\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;\\\\nconst vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256., 256. );\\\\nconst vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );\\\\nconst float ShiftRight8 = 1. / 256.;\\\\nvec4 packDepthToRGBA( const in float v ) {\\\\n\\\\tvec4 r = vec4( fract( v * PackFactors ), v );\\\\n\\\\tr.yzw -= r.xyz * ShiftRight8;\\\\treturn r * PackUpscale;\\\\n}\\\\nfloat unpackRGBAToDepth( const in vec4 v ) {\\\\n\\\\treturn dot( v, UnpackFactors );\\\\n}\\\\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\\\\n\\\\treturn ( viewZ + near ) / ( near - far );\\\\n}\\\\nfloat orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {\\\\n\\\\treturn linearClipZ * ( near - far ) - near;\\\\n}\\\\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\\\\n\\\\treturn (( near + viewZ ) * far ) / (( far - near ) * viewZ );\\\\n}\\\\nfloat perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {\\\\n\\\\treturn ( near * far ) / ( ( far - near ) * invClipZ - far );\\\\n}\\\\n\\\";\\n\\n\\tvar premultiplied_alpha_fragment = \\\"#ifdef PREMULTIPLIED_ALPHA\\\\n\\\\tgl_FragColor.rgb *= gl_FragColor.a;\\\\n#endif\\\\n\\\";\\n\\n\\tvar project_vertex = \\\"vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );\\\\ngl_Position = projectionMatrix * mvPosition;\\\\n\\\";\\n\\n\\tvar dithering_fragment = \\\"#if defined( DITHERING )\\\\n gl_FragColor.rgb = dithering( gl_FragColor.rgb );\\\\n#endif\\\\n\\\";\\n\\n\\tvar dithering_pars_fragment = \\\"#if defined( DITHERING )\\\\n\\\\tvec3 dithering( vec3 color ) {\\\\n\\\\t\\\\tfloat grid_position = rand( gl_FragCoord.xy );\\\\n\\\\t\\\\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\\\\n\\\\t\\\\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\\\\n\\\\t\\\\treturn color + dither_shift_RGB;\\\\n\\\\t}\\\\n#endif\\\\n\\\";\\n\\n\\tvar roughnessmap_fragment = \\\"float roughnessFactor = roughness;\\\\n#ifdef USE_ROUGHNESSMAP\\\\n\\\\tvec4 texelRoughness = texture2D( roughnessMap, vUv );\\\\n\\\\troughnessFactor *= texelRoughness.g;\\\\n#endif\\\\n\\\";\\n\\n\\tvar roughnessmap_pars_fragment = \\\"#ifdef USE_ROUGHNESSMAP\\\\n\\\\tuniform sampler2D roughnessMap;\\\\n#endif\\\";\\n\\n\\tvar shadowmap_pars_fragment = \\\"#ifdef USE_SHADOWMAP\\\\n\\\\t#if NUM_DIR_LIGHTS > 0\\\\n\\\\t\\\\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHTS ];\\\\n\\\\t\\\\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHTS ];\\\\n\\\\t#endif\\\\n\\\\t#if NUM_SPOT_LIGHTS > 0\\\\n\\\\t\\\\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHTS ];\\\\n\\\\t\\\\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHTS ];\\\\n\\\\t#endif\\\\n\\\\t#if NUM_POINT_LIGHTS > 0\\\\n\\\\t\\\\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHTS ];\\\\n\\\\t\\\\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHTS ];\\\\n\\\\t#endif\\\\n\\\\tfloat texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\\\\n\\\\t\\\\treturn step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\\\\n\\\\t}\\\\n\\\\tfloat texture2DShadowLerp( sampler2D depths, vec2 size, vec2 uv, float compare ) {\\\\n\\\\t\\\\tconst vec2 offset = vec2( 0.0, 1.0 );\\\\n\\\\t\\\\tvec2 texelSize = vec2( 1.0 ) / size;\\\\n\\\\t\\\\tvec2 centroidUV = floor( uv * size + 0.5 ) / size;\\\\n\\\\t\\\\tfloat lb = texture2DCompare( depths, centroidUV + texelSize * offset.xx, compare );\\\\n\\\\t\\\\tfloat lt = texture2DCompare( depths, centroidUV + texelSize * offset.xy, compare );\\\\n\\\\t\\\\tfloat rb = texture2DCompare( depths, centroidUV + texelSize * offset.yx, compare );\\\\n\\\\t\\\\tfloat rt = texture2DCompare( depths, centroidUV + texelSize * offset.yy, compare );\\\\n\\\\t\\\\tvec2 f = fract( uv * size + 0.5 );\\\\n\\\\t\\\\tfloat a = mix( lb, lt, f.y );\\\\n\\\\t\\\\tfloat b = mix( rb, rt, f.y );\\\\n\\\\t\\\\tfloat c = mix( a, b, f.x );\\\\n\\\\t\\\\treturn c;\\\\n\\\\t}\\\\n\\\\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\\\\n\\\\t\\\\tfloat shadow = 1.0;\\\\n\\\\t\\\\tshadowCoord.xyz /= shadowCoord.w;\\\\n\\\\t\\\\tshadowCoord.z += shadowBias;\\\\n\\\\t\\\\tbvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );\\\\n\\\\t\\\\tbool inFrustum = all( inFrustumVec );\\\\n\\\\t\\\\tbvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );\\\\n\\\\t\\\\tbool frustumTest = all( frustumTestVec );\\\\n\\\\t\\\\tif ( frustumTest ) {\\\\n\\\\t\\\\t#if defined( SHADOWMAP_TYPE_PCF )\\\\n\\\\t\\\\t\\\\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\\\\n\\\\t\\\\t\\\\tfloat dx0 = - texelSize.x * shadowRadius;\\\\n\\\\t\\\\t\\\\tfloat dy0 = - texelSize.y * shadowRadius;\\\\n\\\\t\\\\t\\\\tfloat dx1 = + texelSize.x * shadowRadius;\\\\n\\\\t\\\\t\\\\tfloat dy1 = + texelSize.y * shadowRadius;\\\\n\\\\t\\\\t\\\\tshadow = (\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\\\\n\\\\t\\\\t\\\\t) * ( 1.0 / 9.0 );\\\\n\\\\t\\\\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\\\\n\\\\t\\\\t\\\\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\\\\n\\\\t\\\\t\\\\tfloat dx0 = - texelSize.x * shadowRadius;\\\\n\\\\t\\\\t\\\\tfloat dy0 = - texelSize.y * shadowRadius;\\\\n\\\\t\\\\t\\\\tfloat dx1 = + texelSize.x * shadowRadius;\\\\n\\\\t\\\\t\\\\tfloat dy1 = + texelSize.y * shadowRadius;\\\\n\\\\t\\\\t\\\\tshadow = (\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy, shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\\\\n\\\\t\\\\t\\\\t) * ( 1.0 / 9.0 );\\\\n\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\tshadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\t}\\\\n\\\\t\\\\treturn shadow;\\\\n\\\\t}\\\\n\\\\tvec2 cubeToUV( vec3 v, float texelSizeY ) {\\\\n\\\\t\\\\tvec3 absV = abs( v );\\\\n\\\\t\\\\tfloat scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\\\\n\\\\t\\\\tabsV *= scaleToCube;\\\\n\\\\t\\\\tv *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\\\\n\\\\t\\\\tvec2 planar = v.xy;\\\\n\\\\t\\\\tfloat almostATexel = 1.5 * texelSizeY;\\\\n\\\\t\\\\tfloat almostOne = 1.0 - almostATexel;\\\\n\\\\t\\\\tif ( absV.z >= almostOne ) {\\\\n\\\\t\\\\t\\\\tif ( v.z > 0.0 )\\\\n\\\\t\\\\t\\\\t\\\\tplanar.x = 4.0 - v.x;\\\\n\\\\t\\\\t} else if ( absV.x >= almostOne ) {\\\\n\\\\t\\\\t\\\\tfloat signX = sign( v.x );\\\\n\\\\t\\\\t\\\\tplanar.x = v.z * signX + 2.0 * signX;\\\\n\\\\t\\\\t} else if ( absV.y >= almostOne ) {\\\\n\\\\t\\\\t\\\\tfloat signY = sign( v.y );\\\\n\\\\t\\\\t\\\\tplanar.x = v.x + 2.0 * signY + 2.0;\\\\n\\\\t\\\\t\\\\tplanar.y = v.z * signY - 2.0;\\\\n\\\\t\\\\t}\\\\n\\\\t\\\\treturn vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\\\\n\\\\t}\\\\n\\\\tfloat getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\\\\n\\\\t\\\\tvec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\\\\n\\\\t\\\\tvec3 lightToPosition = shadowCoord.xyz;\\\\n\\\\t\\\\tfloat dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\\\\t\\\\tdp += shadowBias;\\\\n\\\\t\\\\tvec3 bd3D = normalize( lightToPosition );\\\\n\\\\t\\\\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT )\\\\n\\\\t\\\\t\\\\tvec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\\\\n\\\\t\\\\t\\\\treturn (\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\\\\n\\\\t\\\\t\\\\t) * ( 1.0 / 9.0 );\\\\n\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\treturn texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\\\\n\\\\t\\\\t#endif\\\\n\\\\t}\\\\n#endif\\\\n\\\";\\n\\n\\tvar shadowmap_pars_vertex = \\\"#ifdef USE_SHADOWMAP\\\\n\\\\t#if NUM_DIR_LIGHTS > 0\\\\n\\\\t\\\\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHTS ];\\\\n\\\\t\\\\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHTS ];\\\\n\\\\t#endif\\\\n\\\\t#if NUM_SPOT_LIGHTS > 0\\\\n\\\\t\\\\tuniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHTS ];\\\\n\\\\t\\\\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHTS ];\\\\n\\\\t#endif\\\\n\\\\t#if NUM_POINT_LIGHTS > 0\\\\n\\\\t\\\\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHTS ];\\\\n\\\\t\\\\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHTS ];\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar shadowmap_vertex = \\\"#ifdef USE_SHADOWMAP\\\\n\\\\t#if NUM_DIR_LIGHTS > 0\\\\n\\\\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * worldPosition;\\\\n\\\\t}\\\\n\\\\t#endif\\\\n\\\\t#if NUM_SPOT_LIGHTS > 0\\\\n\\\\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tvSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * worldPosition;\\\\n\\\\t}\\\\n\\\\t#endif\\\\n\\\\t#if NUM_POINT_LIGHTS > 0\\\\n\\\\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * worldPosition;\\\\n\\\\t}\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar shadowmask_pars_fragment = \\\"float getShadowMask() {\\\\n\\\\tfloat shadow = 1.0;\\\\n\\\\t#ifdef USE_SHADOWMAP\\\\n\\\\t#if NUM_DIR_LIGHTS > 0\\\\n\\\\tDirectionalLight directionalLight;\\\\n\\\\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tdirectionalLight = directionalLights[ i ];\\\\n\\\\t\\\\tshadow *= bool( directionalLight.shadow ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\\\\n\\\\t}\\\\n\\\\t#endif\\\\n\\\\t#if NUM_SPOT_LIGHTS > 0\\\\n\\\\tSpotLight spotLight;\\\\n\\\\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tspotLight = spotLights[ i ];\\\\n\\\\t\\\\tshadow *= bool( spotLight.shadow ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\\\\n\\\\t}\\\\n\\\\t#endif\\\\n\\\\t#if NUM_POINT_LIGHTS > 0\\\\n\\\\tPointLight pointLight;\\\\n\\\\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tpointLight = pointLights[ i ];\\\\n\\\\t\\\\tshadow *= bool( pointLight.shadow ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\\\\n\\\\t}\\\\n\\\\t#endif\\\\n\\\\t#endif\\\\n\\\\treturn shadow;\\\\n}\\\\n\\\";\\n\\n\\tvar skinbase_vertex = \\\"#ifdef USE_SKINNING\\\\n\\\\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\\\\n\\\\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\\\\n\\\\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\\\\n\\\\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\\\\n#endif\\\";\\n\\n\\tvar skinning_pars_vertex = \\\"#ifdef USE_SKINNING\\\\n\\\\tuniform mat4 bindMatrix;\\\\n\\\\tuniform mat4 bindMatrixInverse;\\\\n\\\\t#ifdef BONE_TEXTURE\\\\n\\\\t\\\\tuniform sampler2D boneTexture;\\\\n\\\\t\\\\tuniform int boneTextureSize;\\\\n\\\\t\\\\tmat4 getBoneMatrix( const in float i ) {\\\\n\\\\t\\\\t\\\\tfloat j = i * 4.0;\\\\n\\\\t\\\\t\\\\tfloat x = mod( j, float( boneTextureSize ) );\\\\n\\\\t\\\\t\\\\tfloat y = floor( j / float( boneTextureSize ) );\\\\n\\\\t\\\\t\\\\tfloat dx = 1.0 / float( boneTextureSize );\\\\n\\\\t\\\\t\\\\tfloat dy = 1.0 / float( boneTextureSize );\\\\n\\\\t\\\\t\\\\ty = dy * ( y + 0.5 );\\\\n\\\\t\\\\t\\\\tvec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\\\\n\\\\t\\\\t\\\\tvec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\\\\n\\\\t\\\\t\\\\tvec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\\\\n\\\\t\\\\t\\\\tvec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\\\\n\\\\t\\\\t\\\\tmat4 bone = mat4( v1, v2, v3, v4 );\\\\n\\\\t\\\\t\\\\treturn bone;\\\\n\\\\t\\\\t}\\\\n\\\\t#else\\\\n\\\\t\\\\tuniform mat4 boneMatrices[ MAX_BONES ];\\\\n\\\\t\\\\tmat4 getBoneMatrix( const in float i ) {\\\\n\\\\t\\\\t\\\\tmat4 bone = boneMatrices[ int(i) ];\\\\n\\\\t\\\\t\\\\treturn bone;\\\\n\\\\t\\\\t}\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar skinning_vertex = \\\"#ifdef USE_SKINNING\\\\n\\\\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\\\\n\\\\tvec4 skinned = vec4( 0.0 );\\\\n\\\\tskinned += boneMatX * skinVertex * skinWeight.x;\\\\n\\\\tskinned += boneMatY * skinVertex * skinWeight.y;\\\\n\\\\tskinned += boneMatZ * skinVertex * skinWeight.z;\\\\n\\\\tskinned += boneMatW * skinVertex * skinWeight.w;\\\\n\\\\ttransformed = ( bindMatrixInverse * skinned ).xyz;\\\\n#endif\\\\n\\\";\\n\\n\\tvar skinnormal_vertex = \\\"#ifdef USE_SKINNING\\\\n\\\\tmat4 skinMatrix = mat4( 0.0 );\\\\n\\\\tskinMatrix += skinWeight.x * boneMatX;\\\\n\\\\tskinMatrix += skinWeight.y * boneMatY;\\\\n\\\\tskinMatrix += skinWeight.z * boneMatZ;\\\\n\\\\tskinMatrix += skinWeight.w * boneMatW;\\\\n\\\\tskinMatrix = bindMatrixInverse * skinMatrix * bindMatrix;\\\\n\\\\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\\\\n#endif\\\\n\\\";\\n\\n\\tvar specularmap_fragment = \\\"float specularStrength;\\\\n#ifdef USE_SPECULARMAP\\\\n\\\\tvec4 texelSpecular = texture2D( specularMap, vUv );\\\\n\\\\tspecularStrength = texelSpecular.r;\\\\n#else\\\\n\\\\tspecularStrength = 1.0;\\\\n#endif\\\";\\n\\n\\tvar specularmap_pars_fragment = \\\"#ifdef USE_SPECULARMAP\\\\n\\\\tuniform sampler2D specularMap;\\\\n#endif\\\";\\n\\n\\tvar tonemapping_fragment = \\\"#if defined( TONE_MAPPING )\\\\n gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\\\\n#endif\\\\n\\\";\\n\\n\\tvar tonemapping_pars_fragment = \\\"#ifndef saturate\\\\n\\\\t#define saturate(a) clamp( a, 0.0, 1.0 )\\\\n#endif\\\\nuniform float toneMappingExposure;\\\\nuniform float toneMappingWhitePoint;\\\\nvec3 LinearToneMapping( vec3 color ) {\\\\n\\\\treturn toneMappingExposure * color;\\\\n}\\\\nvec3 ReinhardToneMapping( vec3 color ) {\\\\n\\\\tcolor *= toneMappingExposure;\\\\n\\\\treturn saturate( color / ( vec3( 1.0 ) + color ) );\\\\n}\\\\n#define Uncharted2Helper( x ) max( ( ( x * ( 0.15 * x + 0.10 * 0.50 ) + 0.20 * 0.02 ) / ( x * ( 0.15 * x + 0.50 ) + 0.20 * 0.30 ) ) - 0.02 / 0.30, vec3( 0.0 ) )\\\\nvec3 Uncharted2ToneMapping( vec3 color ) {\\\\n\\\\tcolor *= toneMappingExposure;\\\\n\\\\treturn saturate( Uncharted2Helper( color ) / Uncharted2Helper( vec3( toneMappingWhitePoint ) ) );\\\\n}\\\\nvec3 OptimizedCineonToneMapping( vec3 color ) {\\\\n\\\\tcolor *= toneMappingExposure;\\\\n\\\\tcolor = max( vec3( 0.0 ), color - 0.004 );\\\\n\\\\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\\\\n}\\\\n\\\";\\n\\n\\tvar uv_pars_fragment = \\\"#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\\\\n\\\\tvarying vec2 vUv;\\\\n#endif\\\";\\n\\n\\tvar uv_pars_vertex = \\\"#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\\\\n\\\\tvarying vec2 vUv;\\\\n\\\\tuniform mat3 uvTransform;\\\\n#endif\\\\n\\\";\\n\\n\\tvar uv_vertex = \\\"#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\\\\n\\\\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\\\\n#endif\\\";\\n\\n\\tvar uv2_pars_fragment = \\\"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\\\\n\\\\tvarying vec2 vUv2;\\\\n#endif\\\";\\n\\n\\tvar uv2_pars_vertex = \\\"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\\\\n\\\\tattribute vec2 uv2;\\\\n\\\\tvarying vec2 vUv2;\\\\n#endif\\\";\\n\\n\\tvar uv2_vertex = \\\"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\\\\n\\\\tvUv2 = uv2;\\\\n#endif\\\";\\n\\n\\tvar worldpos_vertex = \\\"#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP )\\\\n\\\\tvec4 worldPosition = modelMatrix * vec4( transformed, 1.0 );\\\\n#endif\\\\n\\\";\\n\\n\\tvar cube_frag = \\\"uniform samplerCube tCube;\\\\nuniform float tFlip;\\\\nuniform float opacity;\\\\nvarying vec3 vWorldPosition;\\\\nvoid main() {\\\\n\\\\tgl_FragColor = textureCube( tCube, vec3( tFlip * vWorldPosition.x, vWorldPosition.yz ) );\\\\n\\\\tgl_FragColor.a *= opacity;\\\\n}\\\\n\\\";\\n\\n\\tvar cube_vert = \\\"varying vec3 vWorldPosition;\\\\n#include \\\\nvoid main() {\\\\n\\\\tvWorldPosition = transformDirection( position, modelMatrix );\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\tgl_Position.z = gl_Position.w;\\\\n}\\\\n\\\";\\n\\n\\tvar depth_frag = \\\"#if DEPTH_PACKING == 3200\\\\n\\\\tuniform float opacity;\\\\n#endif\\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\tvec4 diffuseColor = vec4( 1.0 );\\\\n\\\\t#if DEPTH_PACKING == 3200\\\\n\\\\t\\\\tdiffuseColor.a = opacity;\\\\n\\\\t#endif\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#if DEPTH_PACKING == 3200\\\\n\\\\t\\\\tgl_FragColor = vec4( vec3( gl_FragCoord.z ), opacity );\\\\n\\\\t#elif DEPTH_PACKING == 3201\\\\n\\\\t\\\\tgl_FragColor = packDepthToRGBA( gl_FragCoord.z );\\\\n\\\\t#endif\\\\n}\\\\n\\\";\\n\\n\\tvar depth_vert = \\\"#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#ifdef USE_DISPLACEMENTMAP\\\\n\\\\t\\\\t#include \\\\n\\\\t\\\\t#include \\\\n\\\\t\\\\t#include \\\\n\\\\t#endif\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n}\\\\n\\\";\\n\\n\\tvar distanceRGBA_frag = \\\"#define DISTANCE\\\\nuniform vec3 referencePosition;\\\\nuniform float nearDistance;\\\\nuniform float farDistance;\\\\nvarying vec3 vWorldPosition;\\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main () {\\\\n\\\\t#include \\\\n\\\\tvec4 diffuseColor = vec4( 1.0 );\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\tfloat dist = length( vWorldPosition - referencePosition );\\\\n\\\\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\\\\n\\\\tdist = saturate( dist );\\\\n\\\\tgl_FragColor = packDepthToRGBA( dist );\\\\n}\\\\n\\\";\\n\\n\\tvar distanceRGBA_vert = \\\"#define DISTANCE\\\\nvarying vec3 vWorldPosition;\\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#ifdef USE_DISPLACEMENTMAP\\\\n\\\\t\\\\t#include \\\\n\\\\t\\\\t#include \\\\n\\\\t\\\\t#include \\\\n\\\\t#endif\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\tvWorldPosition = worldPosition.xyz;\\\\n}\\\\n\\\";\\n\\n\\tvar equirect_frag = \\\"uniform sampler2D tEquirect;\\\\nvarying vec3 vWorldPosition;\\\\n#include \\\\nvoid main() {\\\\n\\\\tvec3 direction = normalize( vWorldPosition );\\\\n\\\\tvec2 sampleUV;\\\\n\\\\tsampleUV.y = asin( clamp( direction.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\\\\n\\\\tsampleUV.x = atan( direction.z, direction.x ) * RECIPROCAL_PI2 + 0.5;\\\\n\\\\tgl_FragColor = texture2D( tEquirect, sampleUV );\\\\n}\\\\n\\\";\\n\\n\\tvar equirect_vert = \\\"varying vec3 vWorldPosition;\\\\n#include \\\\nvoid main() {\\\\n\\\\tvWorldPosition = transformDirection( position, modelMatrix );\\\\n\\\\t#include \\\\n\\\\t#include \\\\n}\\\\n\\\";\\n\\n\\tvar linedashed_frag = \\\"uniform vec3 diffuse;\\\\nuniform float opacity;\\\\nuniform float dashSize;\\\\nuniform float totalSize;\\\\nvarying float vLineDistance;\\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\\\\n\\\\t\\\\tdiscard;\\\\n\\\\t}\\\\n\\\\tvec3 outgoingLight = vec3( 0.0 );\\\\n\\\\tvec4 diffuseColor = vec4( diffuse, opacity );\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\toutgoingLight = diffuseColor.rgb;\\\\n\\\\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n}\\\\n\\\";\\n\\n\\tvar linedashed_vert = \\\"uniform float scale;\\\\nattribute float lineDistance;\\\\nvarying float vLineDistance;\\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\tvLineDistance = scale * lineDistance;\\\\n\\\\tvec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\\\\n\\\\tgl_Position = projectionMatrix * mvPosition;\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n}\\\\n\\\";\\n\\n\\tvar meshbasic_frag = \\\"uniform vec3 diffuse;\\\\nuniform float opacity;\\\\n#ifndef FLAT_SHADED\\\\n\\\\tvarying vec3 vNormal;\\\\n#endif\\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\tvec4 diffuseColor = vec4( diffuse, opacity );\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\\\\n\\\\t#ifdef USE_LIGHTMAP\\\\n\\\\t\\\\treflectedLight.indirectDiffuse += texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\\\\n\\\\t#else\\\\n\\\\t\\\\treflectedLight.indirectDiffuse += vec3( 1.0 );\\\\n\\\\t#endif\\\\n\\\\t#include \\\\n\\\\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\\\\n\\\\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\\\\n\\\\t#include \\\\n\\\\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n}\\\\n\\\";\\n\\n\\tvar meshbasic_vert = \\\"#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#ifdef USE_ENVMAP\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#endif\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n}\\\\n\\\";\\n\\n\\tvar meshlambert_frag = \\\"uniform vec3 diffuse;\\\\nuniform vec3 emissive;\\\\nuniform float opacity;\\\\nvarying vec3 vLightFront;\\\\n#ifdef DOUBLE_SIDED\\\\n\\\\tvarying vec3 vLightBack;\\\\n#endif\\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\tvec4 diffuseColor = vec4( diffuse, opacity );\\\\n\\\\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\\\\n\\\\tvec3 totalEmissiveRadiance = emissive;\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\treflectedLight.indirectDiffuse = getAmbientLightIrradiance( ambientLightColor );\\\\n\\\\t#include \\\\n\\\\treflectedLight.indirectDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb );\\\\n\\\\t#ifdef DOUBLE_SIDED\\\\n\\\\t\\\\treflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;\\\\n\\\\t#else\\\\n\\\\t\\\\treflectedLight.directDiffuse = vLightFront;\\\\n\\\\t#endif\\\\n\\\\treflectedLight.directDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask();\\\\n\\\\t#include \\\\n\\\\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\\\\n\\\\t#include \\\\n\\\\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n}\\\\n\\\";\\n\\n\\tvar meshlambert_vert = \\\"#define LAMBERT\\\\nvarying vec3 vLightFront;\\\\n#ifdef DOUBLE_SIDED\\\\n\\\\tvarying vec3 vLightBack;\\\\n#endif\\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n}\\\\n\\\";\\n\\n\\tvar meshphong_frag = \\\"#define PHONG\\\\nuniform vec3 diffuse;\\\\nuniform vec3 emissive;\\\\nuniform vec3 specular;\\\\nuniform float shininess;\\\\nuniform float opacity;\\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\tvec4 diffuseColor = vec4( diffuse, opacity );\\\\n\\\\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\\\\n\\\\tvec3 totalEmissiveRadiance = emissive;\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\\\\n\\\\t#include \\\\n\\\\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n}\\\\n\\\";\\n\\n\\tvar meshphong_vert = \\\"#define PHONG\\\\nvarying vec3 vViewPosition;\\\\n#ifndef FLAT_SHADED\\\\n\\\\tvarying vec3 vNormal;\\\\n#endif\\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n#ifndef FLAT_SHADED\\\\n\\\\tvNormal = normalize( transformedNormal );\\\\n#endif\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\tvViewPosition = - mvPosition.xyz;\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n}\\\\n\\\";\\n\\n\\tvar meshphysical_frag = \\\"#define PHYSICAL\\\\nuniform vec3 diffuse;\\\\nuniform vec3 emissive;\\\\nuniform float roughness;\\\\nuniform float metalness;\\\\nuniform float opacity;\\\\n#ifndef STANDARD\\\\n\\\\tuniform float clearCoat;\\\\n\\\\tuniform float clearCoatRoughness;\\\\n#endif\\\\nvarying vec3 vViewPosition;\\\\n#ifndef FLAT_SHADED\\\\n\\\\tvarying vec3 vNormal;\\\\n#endif\\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\tvec4 diffuseColor = vec4( diffuse, opacity );\\\\n\\\\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\\\\n\\\\tvec3 totalEmissiveRadiance = emissive;\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\\\\n\\\\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n}\\\\n\\\";\\n\\n\\tvar meshphysical_vert = \\\"#define PHYSICAL\\\\nvarying vec3 vViewPosition;\\\\n#ifndef FLAT_SHADED\\\\n\\\\tvarying vec3 vNormal;\\\\n#endif\\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n#ifndef FLAT_SHADED\\\\n\\\\tvNormal = normalize( transformedNormal );\\\\n#endif\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\tvViewPosition = - mvPosition.xyz;\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n}\\\\n\\\";\\n\\n\\tvar normal_frag = \\\"#define NORMAL\\\\nuniform float opacity;\\\\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP )\\\\n\\\\tvarying vec3 vViewPosition;\\\\n#endif\\\\n#ifndef FLAT_SHADED\\\\n\\\\tvarying vec3 vNormal;\\\\n#endif\\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\tgl_FragColor = vec4( packNormalToRGB( normal ), opacity );\\\\n}\\\\n\\\";\\n\\n\\tvar normal_vert = \\\"#define NORMAL\\\\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP )\\\\n\\\\tvarying vec3 vViewPosition;\\\\n#endif\\\\n#ifndef FLAT_SHADED\\\\n\\\\tvarying vec3 vNormal;\\\\n#endif\\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n#ifndef FLAT_SHADED\\\\n\\\\tvNormal = normalize( transformedNormal );\\\\n#endif\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP )\\\\n\\\\tvViewPosition = - mvPosition.xyz;\\\\n#endif\\\\n}\\\\n\\\";\\n\\n\\tvar points_frag = \\\"uniform vec3 diffuse;\\\\nuniform float opacity;\\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\tvec3 outgoingLight = vec3( 0.0 );\\\\n\\\\tvec4 diffuseColor = vec4( diffuse, opacity );\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\toutgoingLight = diffuseColor.rgb;\\\\n\\\\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n}\\\\n\\\";\\n\\n\\tvar points_vert = \\\"uniform float size;\\\\nuniform float scale;\\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#ifdef USE_SIZEATTENUATION\\\\n\\\\t\\\\tgl_PointSize = size * ( scale / - mvPosition.z );\\\\n\\\\t#else\\\\n\\\\t\\\\tgl_PointSize = size;\\\\n\\\\t#endif\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n}\\\\n\\\";\\n\\n\\tvar shadow_frag = \\\"uniform vec3 color;\\\\nuniform float opacity;\\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\n#include \\\\nvoid main() {\\\\n\\\\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\\\\n\\\\t#include \\\\n}\\\\n\\\";\\n\\n\\tvar shadow_vert = \\\"#include \\\\n#include \\\\nvoid main() {\\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n\\\\t#include \\\\n}\\\\n\\\";\\n\\n\\tvar ShaderChunk = {\\n\\t\\talphamap_fragment: alphamap_fragment,\\n\\t\\talphamap_pars_fragment: alphamap_pars_fragment,\\n\\t\\talphatest_fragment: alphatest_fragment,\\n\\t\\taomap_fragment: aomap_fragment,\\n\\t\\taomap_pars_fragment: aomap_pars_fragment,\\n\\t\\tbegin_vertex: begin_vertex,\\n\\t\\tbeginnormal_vertex: beginnormal_vertex,\\n\\t\\tbsdfs: bsdfs,\\n\\t\\tbumpmap_pars_fragment: bumpmap_pars_fragment,\\n\\t\\tclipping_planes_fragment: clipping_planes_fragment,\\n\\t\\tclipping_planes_pars_fragment: clipping_planes_pars_fragment,\\n\\t\\tclipping_planes_pars_vertex: clipping_planes_pars_vertex,\\n\\t\\tclipping_planes_vertex: clipping_planes_vertex,\\n\\t\\tcolor_fragment: color_fragment,\\n\\t\\tcolor_pars_fragment: color_pars_fragment,\\n\\t\\tcolor_pars_vertex: color_pars_vertex,\\n\\t\\tcolor_vertex: color_vertex,\\n\\t\\tcommon: common,\\n\\t\\tcube_uv_reflection_fragment: cube_uv_reflection_fragment,\\n\\t\\tdefaultnormal_vertex: defaultnormal_vertex,\\n\\t\\tdisplacementmap_pars_vertex: displacementmap_pars_vertex,\\n\\t\\tdisplacementmap_vertex: displacementmap_vertex,\\n\\t\\temissivemap_fragment: emissivemap_fragment,\\n\\t\\temissivemap_pars_fragment: emissivemap_pars_fragment,\\n\\t\\tencodings_fragment: encodings_fragment,\\n\\t\\tencodings_pars_fragment: encodings_pars_fragment,\\n\\t\\tenvmap_fragment: envmap_fragment,\\n\\t\\tenvmap_pars_fragment: envmap_pars_fragment,\\n\\t\\tenvmap_pars_vertex: envmap_pars_vertex,\\n\\t\\tenvmap_vertex: envmap_vertex,\\n\\t\\tfog_vertex: fog_vertex,\\n\\t\\tfog_pars_vertex: fog_pars_vertex,\\n\\t\\tfog_fragment: fog_fragment,\\n\\t\\tfog_pars_fragment: fog_pars_fragment,\\n\\t\\tgradientmap_pars_fragment: gradientmap_pars_fragment,\\n\\t\\tlightmap_fragment: lightmap_fragment,\\n\\t\\tlightmap_pars_fragment: lightmap_pars_fragment,\\n\\t\\tlights_lambert_vertex: lights_lambert_vertex,\\n\\t\\tlights_pars: lights_pars,\\n\\t\\tlights_phong_fragment: lights_phong_fragment,\\n\\t\\tlights_phong_pars_fragment: lights_phong_pars_fragment,\\n\\t\\tlights_physical_fragment: lights_physical_fragment,\\n\\t\\tlights_physical_pars_fragment: lights_physical_pars_fragment,\\n\\t\\tlights_template: lights_template,\\n\\t\\tlogdepthbuf_fragment: logdepthbuf_fragment,\\n\\t\\tlogdepthbuf_pars_fragment: logdepthbuf_pars_fragment,\\n\\t\\tlogdepthbuf_pars_vertex: logdepthbuf_pars_vertex,\\n\\t\\tlogdepthbuf_vertex: logdepthbuf_vertex,\\n\\t\\tmap_fragment: map_fragment,\\n\\t\\tmap_pars_fragment: map_pars_fragment,\\n\\t\\tmap_particle_fragment: map_particle_fragment,\\n\\t\\tmap_particle_pars_fragment: map_particle_pars_fragment,\\n\\t\\tmetalnessmap_fragment: metalnessmap_fragment,\\n\\t\\tmetalnessmap_pars_fragment: metalnessmap_pars_fragment,\\n\\t\\tmorphnormal_vertex: morphnormal_vertex,\\n\\t\\tmorphtarget_pars_vertex: morphtarget_pars_vertex,\\n\\t\\tmorphtarget_vertex: morphtarget_vertex,\\n\\t\\tnormal_fragment: normal_fragment,\\n\\t\\tnormalmap_pars_fragment: normalmap_pars_fragment,\\n\\t\\tpacking: packing,\\n\\t\\tpremultiplied_alpha_fragment: premultiplied_alpha_fragment,\\n\\t\\tproject_vertex: project_vertex,\\n\\t\\tdithering_fragment: dithering_fragment,\\n\\t\\tdithering_pars_fragment: dithering_pars_fragment,\\n\\t\\troughnessmap_fragment: roughnessmap_fragment,\\n\\t\\troughnessmap_pars_fragment: roughnessmap_pars_fragment,\\n\\t\\tshadowmap_pars_fragment: shadowmap_pars_fragment,\\n\\t\\tshadowmap_pars_vertex: shadowmap_pars_vertex,\\n\\t\\tshadowmap_vertex: shadowmap_vertex,\\n\\t\\tshadowmask_pars_fragment: shadowmask_pars_fragment,\\n\\t\\tskinbase_vertex: skinbase_vertex,\\n\\t\\tskinning_pars_vertex: skinning_pars_vertex,\\n\\t\\tskinning_vertex: skinning_vertex,\\n\\t\\tskinnormal_vertex: skinnormal_vertex,\\n\\t\\tspecularmap_fragment: specularmap_fragment,\\n\\t\\tspecularmap_pars_fragment: specularmap_pars_fragment,\\n\\t\\ttonemapping_fragment: tonemapping_fragment,\\n\\t\\ttonemapping_pars_fragment: tonemapping_pars_fragment,\\n\\t\\tuv_pars_fragment: uv_pars_fragment,\\n\\t\\tuv_pars_vertex: uv_pars_vertex,\\n\\t\\tuv_vertex: uv_vertex,\\n\\t\\tuv2_pars_fragment: uv2_pars_fragment,\\n\\t\\tuv2_pars_vertex: uv2_pars_vertex,\\n\\t\\tuv2_vertex: uv2_vertex,\\n\\t\\tworldpos_vertex: worldpos_vertex,\\n\\n\\t\\tcube_frag: cube_frag,\\n\\t\\tcube_vert: cube_vert,\\n\\t\\tdepth_frag: depth_frag,\\n\\t\\tdepth_vert: depth_vert,\\n\\t\\tdistanceRGBA_frag: distanceRGBA_frag,\\n\\t\\tdistanceRGBA_vert: distanceRGBA_vert,\\n\\t\\tequirect_frag: equirect_frag,\\n\\t\\tequirect_vert: equirect_vert,\\n\\t\\tlinedashed_frag: linedashed_frag,\\n\\t\\tlinedashed_vert: linedashed_vert,\\n\\t\\tmeshbasic_frag: meshbasic_frag,\\n\\t\\tmeshbasic_vert: meshbasic_vert,\\n\\t\\tmeshlambert_frag: meshlambert_frag,\\n\\t\\tmeshlambert_vert: meshlambert_vert,\\n\\t\\tmeshphong_frag: meshphong_frag,\\n\\t\\tmeshphong_vert: meshphong_vert,\\n\\t\\tmeshphysical_frag: meshphysical_frag,\\n\\t\\tmeshphysical_vert: meshphysical_vert,\\n\\t\\tnormal_frag: normal_frag,\\n\\t\\tnormal_vert: normal_vert,\\n\\t\\tpoints_frag: points_frag,\\n\\t\\tpoints_vert: points_vert,\\n\\t\\tshadow_frag: shadow_frag,\\n\\t\\tshadow_vert: shadow_vert\\n\\t};\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t */\\n\\n\\tvar ShaderLib = {\\n\\n\\t\\tbasic: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.common,\\n\\t\\t\\t\\tUniformsLib.specularmap,\\n\\t\\t\\t\\tUniformsLib.envmap,\\n\\t\\t\\t\\tUniformsLib.aomap,\\n\\t\\t\\t\\tUniformsLib.lightmap,\\n\\t\\t\\t\\tUniformsLib.fog\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.meshbasic_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.meshbasic_frag\\n\\n\\t\\t},\\n\\n\\t\\tlambert: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.common,\\n\\t\\t\\t\\tUniformsLib.specularmap,\\n\\t\\t\\t\\tUniformsLib.envmap,\\n\\t\\t\\t\\tUniformsLib.aomap,\\n\\t\\t\\t\\tUniformsLib.lightmap,\\n\\t\\t\\t\\tUniformsLib.emissivemap,\\n\\t\\t\\t\\tUniformsLib.fog,\\n\\t\\t\\t\\tUniformsLib.lights,\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\temissive: { value: new Color( 0x000000 ) }\\n\\t\\t\\t\\t}\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.meshlambert_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.meshlambert_frag\\n\\n\\t\\t},\\n\\n\\t\\tphong: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.common,\\n\\t\\t\\t\\tUniformsLib.specularmap,\\n\\t\\t\\t\\tUniformsLib.envmap,\\n\\t\\t\\t\\tUniformsLib.aomap,\\n\\t\\t\\t\\tUniformsLib.lightmap,\\n\\t\\t\\t\\tUniformsLib.emissivemap,\\n\\t\\t\\t\\tUniformsLib.bumpmap,\\n\\t\\t\\t\\tUniformsLib.normalmap,\\n\\t\\t\\t\\tUniformsLib.displacementmap,\\n\\t\\t\\t\\tUniformsLib.gradientmap,\\n\\t\\t\\t\\tUniformsLib.fog,\\n\\t\\t\\t\\tUniformsLib.lights,\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\temissive: { value: new Color( 0x000000 ) },\\n\\t\\t\\t\\t\\tspecular: { value: new Color( 0x111111 ) },\\n\\t\\t\\t\\t\\tshininess: { value: 30 }\\n\\t\\t\\t\\t}\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.meshphong_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.meshphong_frag\\n\\n\\t\\t},\\n\\n\\t\\tstandard: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.common,\\n\\t\\t\\t\\tUniformsLib.envmap,\\n\\t\\t\\t\\tUniformsLib.aomap,\\n\\t\\t\\t\\tUniformsLib.lightmap,\\n\\t\\t\\t\\tUniformsLib.emissivemap,\\n\\t\\t\\t\\tUniformsLib.bumpmap,\\n\\t\\t\\t\\tUniformsLib.normalmap,\\n\\t\\t\\t\\tUniformsLib.displacementmap,\\n\\t\\t\\t\\tUniformsLib.roughnessmap,\\n\\t\\t\\t\\tUniformsLib.metalnessmap,\\n\\t\\t\\t\\tUniformsLib.fog,\\n\\t\\t\\t\\tUniformsLib.lights,\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\temissive: { value: new Color( 0x000000 ) },\\n\\t\\t\\t\\t\\troughness: { value: 0.5 },\\n\\t\\t\\t\\t\\tmetalness: { value: 0.5 },\\n\\t\\t\\t\\t\\tenvMapIntensity: { value: 1 } // temporary\\n\\t\\t\\t\\t}\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.meshphysical_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.meshphysical_frag\\n\\n\\t\\t},\\n\\n\\t\\tpoints: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.points,\\n\\t\\t\\t\\tUniformsLib.fog\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.points_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.points_frag\\n\\n\\t\\t},\\n\\n\\t\\tdashed: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.common,\\n\\t\\t\\t\\tUniformsLib.fog,\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tscale: { value: 1 },\\n\\t\\t\\t\\t\\tdashSize: { value: 1 },\\n\\t\\t\\t\\t\\ttotalSize: { value: 2 }\\n\\t\\t\\t\\t}\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.linedashed_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.linedashed_frag\\n\\n\\t\\t},\\n\\n\\t\\tdepth: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.common,\\n\\t\\t\\t\\tUniformsLib.displacementmap\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.depth_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.depth_frag\\n\\n\\t\\t},\\n\\n\\t\\tnormal: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.common,\\n\\t\\t\\t\\tUniformsLib.bumpmap,\\n\\t\\t\\t\\tUniformsLib.normalmap,\\n\\t\\t\\t\\tUniformsLib.displacementmap,\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\topacity: { value: 1.0 }\\n\\t\\t\\t\\t}\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.normal_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.normal_frag\\n\\n\\t\\t},\\n\\n\\t\\t/* -------------------------------------------------------------------------\\n\\t\\t//\\tCube map shader\\n\\t\\t ------------------------------------------------------------------------- */\\n\\n\\t\\tcube: {\\n\\n\\t\\t\\tuniforms: {\\n\\t\\t\\t\\ttCube: { value: null },\\n\\t\\t\\t\\ttFlip: { value: - 1 },\\n\\t\\t\\t\\topacity: { value: 1.0 }\\n\\t\\t\\t},\\n\\n\\t\\t\\tvertexShader: ShaderChunk.cube_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.cube_frag\\n\\n\\t\\t},\\n\\n\\t\\tequirect: {\\n\\n\\t\\t\\tuniforms: {\\n\\t\\t\\t\\ttEquirect: { value: null },\\n\\t\\t\\t},\\n\\n\\t\\t\\tvertexShader: ShaderChunk.equirect_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.equirect_frag\\n\\n\\t\\t},\\n\\n\\t\\tdistanceRGBA: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.common,\\n\\t\\t\\t\\tUniformsLib.displacementmap,\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\treferencePosition: { value: new Vector3() },\\n\\t\\t\\t\\t\\tnearDistance: { value: 1 },\\n\\t\\t\\t\\t\\tfarDistance: { value: 1000 }\\n\\t\\t\\t\\t}\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.distanceRGBA_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.distanceRGBA_frag\\n\\n\\t\\t},\\n\\n\\t\\tshadow: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.lights,\\n\\t\\t\\t\\tUniformsLib.fog,\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tcolor: { value: new Color( 0x00000 ) },\\n\\t\\t\\t\\t\\topacity: { value: 1.0 }\\n\\t\\t\\t\\t},\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.shadow_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.shadow_frag\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\tShaderLib.physical = {\\n\\n\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\tShaderLib.standard.uniforms,\\n\\t\\t\\t{\\n\\t\\t\\t\\tclearCoat: { value: 0 },\\n\\t\\t\\t\\tclearCoatRoughness: { value: 0 }\\n\\t\\t\\t}\\n\\t\\t] ),\\n\\n\\t\\tvertexShader: ShaderChunk.meshphysical_vert,\\n\\t\\tfragmentShader: ShaderChunk.meshphysical_frag\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author bhouston / http://clara.io\\n\\t */\\n\\n\\tfunction Box2( min, max ) {\\n\\n\\t\\tthis.min = ( min !== undefined ) ? min : new Vector2( + Infinity, + Infinity );\\n\\t\\tthis.max = ( max !== undefined ) ? max : new Vector2( - Infinity, - Infinity );\\n\\n\\t}\\n\\n\\tObject.assign( Box2.prototype, {\\n\\n\\t\\tset: function ( min, max ) {\\n\\n\\t\\t\\tthis.min.copy( min );\\n\\t\\t\\tthis.max.copy( max );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromPoints: function ( points ) {\\n\\n\\t\\t\\tthis.makeEmpty();\\n\\n\\t\\t\\tfor ( var i = 0, il = points.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.expandByPoint( points[ i ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromCenterAndSize: function () {\\n\\n\\t\\t\\tvar v1 = new Vector2();\\n\\n\\t\\t\\treturn function setFromCenterAndSize( center, size ) {\\n\\n\\t\\t\\t\\tvar halfSize = v1.copy( size ).multiplyScalar( 0.5 );\\n\\t\\t\\t\\tthis.min.copy( center ).sub( halfSize );\\n\\t\\t\\t\\tthis.max.copy( center ).add( halfSize );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( box ) {\\n\\n\\t\\t\\tthis.min.copy( box.min );\\n\\t\\t\\tthis.max.copy( box.max );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeEmpty: function () {\\n\\n\\t\\t\\tthis.min.x = this.min.y = + Infinity;\\n\\t\\t\\tthis.max.x = this.max.y = - Infinity;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tisEmpty: function () {\\n\\n\\t\\t\\t// this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes\\n\\n\\t\\t\\treturn ( this.max.x < this.min.x ) || ( this.max.y < this.min.y );\\n\\n\\t\\t},\\n\\n\\t\\tgetCenter: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector2();\\n\\t\\t\\treturn this.isEmpty() ? result.set( 0, 0 ) : result.addVectors( this.min, this.max ).multiplyScalar( 0.5 );\\n\\n\\t\\t},\\n\\n\\t\\tgetSize: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector2();\\n\\t\\t\\treturn this.isEmpty() ? result.set( 0, 0 ) : result.subVectors( this.max, this.min );\\n\\n\\t\\t},\\n\\n\\t\\texpandByPoint: function ( point ) {\\n\\n\\t\\t\\tthis.min.min( point );\\n\\t\\t\\tthis.max.max( point );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\texpandByVector: function ( vector ) {\\n\\n\\t\\t\\tthis.min.sub( vector );\\n\\t\\t\\tthis.max.add( vector );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\texpandByScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.min.addScalar( - scalar );\\n\\t\\t\\tthis.max.addScalar( scalar );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcontainsPoint: function ( point ) {\\n\\n\\t\\t\\treturn point.x < this.min.x || point.x > this.max.x ||\\n\\t\\t\\t\\tpoint.y < this.min.y || point.y > this.max.y ? false : true;\\n\\n\\t\\t},\\n\\n\\t\\tcontainsBox: function ( box ) {\\n\\n\\t\\t\\treturn this.min.x <= box.min.x && box.max.x <= this.max.x &&\\n\\t\\t\\t\\tthis.min.y <= box.min.y && box.max.y <= this.max.y;\\n\\n\\t\\t},\\n\\n\\t\\tgetParameter: function ( point, optionalTarget ) {\\n\\n\\t\\t\\t// This can potentially have a divide by zero if the box\\n\\t\\t\\t// has a size dimension of 0.\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector2();\\n\\n\\t\\t\\treturn result.set(\\n\\t\\t\\t\\t( point.x - this.min.x ) / ( this.max.x - this.min.x ),\\n\\t\\t\\t\\t( point.y - this.min.y ) / ( this.max.y - this.min.y )\\n\\t\\t\\t);\\n\\n\\t\\t},\\n\\n\\t\\tintersectsBox: function ( box ) {\\n\\n\\t\\t\\t// using 4 splitting planes to rule out intersections\\n\\n\\t\\t\\treturn box.max.x < this.min.x || box.min.x > this.max.x ||\\n\\t\\t\\t\\tbox.max.y < this.min.y || box.min.y > this.max.y ? false : true;\\n\\n\\t\\t},\\n\\n\\t\\tclampPoint: function ( point, optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector2();\\n\\t\\t\\treturn result.copy( point ).clamp( this.min, this.max );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToPoint: function () {\\n\\n\\t\\t\\tvar v1 = new Vector2();\\n\\n\\t\\t\\treturn function distanceToPoint( point ) {\\n\\n\\t\\t\\t\\tvar clampedPoint = v1.copy( point ).clamp( this.min, this.max );\\n\\t\\t\\t\\treturn clampedPoint.sub( point ).length();\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tintersect: function ( box ) {\\n\\n\\t\\t\\tthis.min.max( box.min );\\n\\t\\t\\tthis.max.min( box.max );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tunion: function ( box ) {\\n\\n\\t\\t\\tthis.min.min( box.min );\\n\\t\\t\\tthis.max.max( box.max );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttranslate: function ( offset ) {\\n\\n\\t\\t\\tthis.min.add( offset );\\n\\t\\t\\tthis.max.add( offset );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( box ) {\\n\\n\\t\\t\\treturn box.min.equals( this.min ) && box.max.equals( this.max );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction WebGLFlareRenderer( renderer, gl, state, textures, capabilities ) {\\n\\n\\t\\tvar vertexBuffer, elementBuffer;\\n\\t\\tvar shader, program, attributes, uniforms;\\n\\n\\t\\tvar tempTexture, occlusionTexture;\\n\\n\\t\\tfunction init() {\\n\\n\\t\\t\\tvar vertices = new Float32Array( [\\n\\t\\t\\t\\t- 1, - 1, 0, 0,\\n\\t\\t\\t\\t 1, - 1, 1, 0,\\n\\t\\t\\t\\t 1, 1, 1, 1,\\n\\t\\t\\t\\t- 1, 1, 0, 1\\n\\t\\t\\t] );\\n\\n\\t\\t\\tvar faces = new Uint16Array( [\\n\\t\\t\\t\\t0, 1, 2,\\n\\t\\t\\t\\t0, 2, 3\\n\\t\\t\\t] );\\n\\n\\t\\t\\t// buffers\\n\\n\\t\\t\\tvertexBuffer = gl.createBuffer();\\n\\t\\t\\telementBuffer = gl.createBuffer();\\n\\n\\t\\t\\tgl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer );\\n\\t\\t\\tgl.bufferData( gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW );\\n\\n\\t\\t\\tgl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer );\\n\\t\\t\\tgl.bufferData( gl.ELEMENT_ARRAY_BUFFER, faces, gl.STATIC_DRAW );\\n\\n\\t\\t\\t// textures\\n\\n\\t\\t\\ttempTexture = gl.createTexture();\\n\\t\\t\\tocclusionTexture = gl.createTexture();\\n\\n\\t\\t\\tstate.bindTexture( gl.TEXTURE_2D, tempTexture );\\n\\t\\t\\tgl.texImage2D( gl.TEXTURE_2D, 0, gl.RGB, 16, 16, 0, gl.RGB, gl.UNSIGNED_BYTE, null );\\n\\t\\t\\tgl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE );\\n\\t\\t\\tgl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE );\\n\\t\\t\\tgl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST );\\n\\t\\t\\tgl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST );\\n\\n\\t\\t\\tstate.bindTexture( gl.TEXTURE_2D, occlusionTexture );\\n\\t\\t\\tgl.texImage2D( gl.TEXTURE_2D, 0, gl.RGBA, 16, 16, 0, gl.RGBA, gl.UNSIGNED_BYTE, null );\\n\\t\\t\\tgl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE );\\n\\t\\t\\tgl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE );\\n\\t\\t\\tgl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST );\\n\\t\\t\\tgl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST );\\n\\n\\t\\t\\tshader = {\\n\\n\\t\\t\\t\\tvertexShader: [\\n\\n\\t\\t\\t\\t\\t'uniform lowp int renderType;',\\n\\n\\t\\t\\t\\t\\t'uniform vec3 screenPosition;',\\n\\t\\t\\t\\t\\t'uniform vec2 scale;',\\n\\t\\t\\t\\t\\t'uniform float rotation;',\\n\\n\\t\\t\\t\\t\\t'uniform sampler2D occlusionMap;',\\n\\n\\t\\t\\t\\t\\t'attribute vec2 position;',\\n\\t\\t\\t\\t\\t'attribute vec2 uv;',\\n\\n\\t\\t\\t\\t\\t'varying vec2 vUV;',\\n\\t\\t\\t\\t\\t'varying float vVisibility;',\\n\\n\\t\\t\\t\\t\\t'void main() {',\\n\\n\\t\\t\\t\\t\\t'\\tvUV = uv;',\\n\\n\\t\\t\\t\\t\\t'\\tvec2 pos = position;',\\n\\n\\t\\t\\t\\t\\t'\\tif ( renderType == 2 ) {',\\n\\n\\t\\t\\t\\t\\t'\\t\\tvec4 visibility = texture2D( occlusionMap, vec2( 0.1, 0.1 ) );',\\n\\t\\t\\t\\t\\t'\\t\\tvisibility += texture2D( occlusionMap, vec2( 0.5, 0.1 ) );',\\n\\t\\t\\t\\t\\t'\\t\\tvisibility += texture2D( occlusionMap, vec2( 0.9, 0.1 ) );',\\n\\t\\t\\t\\t\\t'\\t\\tvisibility += texture2D( occlusionMap, vec2( 0.9, 0.5 ) );',\\n\\t\\t\\t\\t\\t'\\t\\tvisibility += texture2D( occlusionMap, vec2( 0.9, 0.9 ) );',\\n\\t\\t\\t\\t\\t'\\t\\tvisibility += texture2D( occlusionMap, vec2( 0.5, 0.9 ) );',\\n\\t\\t\\t\\t\\t'\\t\\tvisibility += texture2D( occlusionMap, vec2( 0.1, 0.9 ) );',\\n\\t\\t\\t\\t\\t'\\t\\tvisibility += texture2D( occlusionMap, vec2( 0.1, 0.5 ) );',\\n\\t\\t\\t\\t\\t'\\t\\tvisibility += texture2D( occlusionMap, vec2( 0.5, 0.5 ) );',\\n\\n\\t\\t\\t\\t\\t'\\t\\tvVisibility = visibility.r / 9.0;',\\n\\t\\t\\t\\t\\t'\\t\\tvVisibility *= 1.0 - visibility.g / 9.0;',\\n\\t\\t\\t\\t\\t'\\t\\tvVisibility *= visibility.b / 9.0;',\\n\\t\\t\\t\\t\\t'\\t\\tvVisibility *= 1.0 - visibility.a / 9.0;',\\n\\n\\t\\t\\t\\t\\t'\\t\\tpos.x = cos( rotation ) * position.x - sin( rotation ) * position.y;',\\n\\t\\t\\t\\t\\t'\\t\\tpos.y = sin( rotation ) * position.x + cos( rotation ) * position.y;',\\n\\n\\t\\t\\t\\t\\t'\\t}',\\n\\n\\t\\t\\t\\t\\t'\\tgl_Position = vec4( ( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );',\\n\\n\\t\\t\\t\\t\\t'}'\\n\\n\\t\\t\\t\\t].join( '\\\\n' ),\\n\\n\\t\\t\\t\\tfragmentShader: [\\n\\n\\t\\t\\t\\t\\t'uniform lowp int renderType;',\\n\\n\\t\\t\\t\\t\\t'uniform sampler2D map;',\\n\\t\\t\\t\\t\\t'uniform float opacity;',\\n\\t\\t\\t\\t\\t'uniform vec3 color;',\\n\\n\\t\\t\\t\\t\\t'varying vec2 vUV;',\\n\\t\\t\\t\\t\\t'varying float vVisibility;',\\n\\n\\t\\t\\t\\t\\t'void main() {',\\n\\n\\t\\t\\t\\t\\t// pink square\\n\\n\\t\\t\\t\\t\\t'\\tif ( renderType == 0 ) {',\\n\\n\\t\\t\\t\\t\\t'\\t\\tgl_FragColor = vec4( 1.0, 0.0, 1.0, 0.0 );',\\n\\n\\t\\t\\t\\t\\t// restore\\n\\n\\t\\t\\t\\t\\t'\\t} else if ( renderType == 1 ) {',\\n\\n\\t\\t\\t\\t\\t'\\t\\tgl_FragColor = texture2D( map, vUV );',\\n\\n\\t\\t\\t\\t\\t// flare\\n\\n\\t\\t\\t\\t\\t'\\t} else {',\\n\\n\\t\\t\\t\\t\\t'\\t\\tvec4 texture = texture2D( map, vUV );',\\n\\t\\t\\t\\t\\t'\\t\\ttexture.a *= opacity * vVisibility;',\\n\\t\\t\\t\\t\\t'\\t\\tgl_FragColor = texture;',\\n\\t\\t\\t\\t\\t'\\t\\tgl_FragColor.rgb *= color;',\\n\\n\\t\\t\\t\\t\\t'\\t}',\\n\\n\\t\\t\\t\\t\\t'}'\\n\\n\\t\\t\\t\\t].join( '\\\\n' )\\n\\n\\t\\t\\t};\\n\\n\\t\\t\\tprogram = createProgram( shader );\\n\\n\\t\\t\\tattributes = {\\n\\t\\t\\t\\tvertex: gl.getAttribLocation( program, 'position' ),\\n\\t\\t\\t\\tuv: gl.getAttribLocation( program, 'uv' )\\n\\t\\t\\t};\\n\\n\\t\\t\\tuniforms = {\\n\\t\\t\\t\\trenderType: gl.getUniformLocation( program, 'renderType' ),\\n\\t\\t\\t\\tmap: gl.getUniformLocation( program, 'map' ),\\n\\t\\t\\t\\tocclusionMap: gl.getUniformLocation( program, 'occlusionMap' ),\\n\\t\\t\\t\\topacity: gl.getUniformLocation( program, 'opacity' ),\\n\\t\\t\\t\\tcolor: gl.getUniformLocation( program, 'color' ),\\n\\t\\t\\t\\tscale: gl.getUniformLocation( program, 'scale' ),\\n\\t\\t\\t\\trotation: gl.getUniformLocation( program, 'rotation' ),\\n\\t\\t\\t\\tscreenPosition: gl.getUniformLocation( program, 'screenPosition' )\\n\\t\\t\\t};\\n\\n\\t\\t}\\n\\n\\t\\t/*\\n\\t\\t * Render lens flares\\n\\t\\t * Method: renders 16x16 0xff00ff-colored points scattered over the light source area,\\n\\t\\t * reads these back and calculates occlusion.\\n\\t\\t */\\n\\n\\t\\tthis.render = function ( flares, scene, camera, viewport ) {\\n\\n\\t\\t\\tif ( flares.length === 0 ) return;\\n\\n\\t\\t\\tvar tempPosition = new Vector3();\\n\\n\\t\\t\\tvar invAspect = viewport.w / viewport.z,\\n\\t\\t\\t\\thalfViewportWidth = viewport.z * 0.5,\\n\\t\\t\\t\\thalfViewportHeight = viewport.w * 0.5;\\n\\n\\t\\t\\tvar size = 16 / viewport.w,\\n\\t\\t\\t\\tscale = new Vector2( size * invAspect, size );\\n\\n\\t\\t\\tvar screenPosition = new Vector3( 1, 1, 0 ),\\n\\t\\t\\t\\tscreenPositionPixels = new Vector2( 1, 1 );\\n\\n\\t\\t\\tvar validArea = new Box2();\\n\\n\\t\\t\\tvalidArea.min.set( viewport.x, viewport.y );\\n\\t\\t\\tvalidArea.max.set( viewport.x + ( viewport.z - 16 ), viewport.y + ( viewport.w - 16 ) );\\n\\n\\t\\t\\tif ( program === undefined ) {\\n\\n\\t\\t\\t\\tinit();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tstate.useProgram( program );\\n\\n\\t\\t\\tstate.initAttributes();\\n\\t\\t\\tstate.enableAttribute( attributes.vertex );\\n\\t\\t\\tstate.enableAttribute( attributes.uv );\\n\\t\\t\\tstate.disableUnusedAttributes();\\n\\n\\t\\t\\t// loop through all lens flares to update their occlusion and positions\\n\\t\\t\\t// setup gl and common used attribs/uniforms\\n\\n\\t\\t\\tgl.uniform1i( uniforms.occlusionMap, 0 );\\n\\t\\t\\tgl.uniform1i( uniforms.map, 1 );\\n\\n\\t\\t\\tgl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer );\\n\\t\\t\\tgl.vertexAttribPointer( attributes.vertex, 2, gl.FLOAT, false, 2 * 8, 0 );\\n\\t\\t\\tgl.vertexAttribPointer( attributes.uv, 2, gl.FLOAT, false, 2 * 8, 8 );\\n\\n\\t\\t\\tgl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer );\\n\\n\\t\\t\\tstate.disable( gl.CULL_FACE );\\n\\t\\t\\tstate.buffers.depth.setMask( false );\\n\\n\\t\\t\\tfor ( var i = 0, l = flares.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tsize = 16 / viewport.w;\\n\\t\\t\\t\\tscale.set( size * invAspect, size );\\n\\n\\t\\t\\t\\t// calc object screen position\\n\\n\\t\\t\\t\\tvar flare = flares[ i ];\\n\\n\\t\\t\\t\\ttempPosition.set( flare.matrixWorld.elements[ 12 ], flare.matrixWorld.elements[ 13 ], flare.matrixWorld.elements[ 14 ] );\\n\\n\\t\\t\\t\\ttempPosition.applyMatrix4( camera.matrixWorldInverse );\\n\\t\\t\\t\\ttempPosition.applyMatrix4( camera.projectionMatrix );\\n\\n\\t\\t\\t\\t// setup arrays for gl programs\\n\\n\\t\\t\\t\\tscreenPosition.copy( tempPosition );\\n\\n\\t\\t\\t\\t// horizontal and vertical coordinate of the lower left corner of the pixels to copy\\n\\n\\t\\t\\t\\tscreenPositionPixels.x = viewport.x + ( screenPosition.x * halfViewportWidth ) + halfViewportWidth - 8;\\n\\t\\t\\t\\tscreenPositionPixels.y = viewport.y + ( screenPosition.y * halfViewportHeight ) + halfViewportHeight - 8;\\n\\n\\t\\t\\t\\t// screen cull\\n\\n\\t\\t\\t\\tif ( validArea.containsPoint( screenPositionPixels ) === true ) {\\n\\n\\t\\t\\t\\t\\t// save current RGB to temp texture\\n\\n\\t\\t\\t\\t\\tstate.activeTexture( gl.TEXTURE0 );\\n\\t\\t\\t\\t\\tstate.bindTexture( gl.TEXTURE_2D, null );\\n\\t\\t\\t\\t\\tstate.activeTexture( gl.TEXTURE1 );\\n\\t\\t\\t\\t\\tstate.bindTexture( gl.TEXTURE_2D, tempTexture );\\n\\t\\t\\t\\t\\tgl.copyTexImage2D( gl.TEXTURE_2D, 0, gl.RGB, screenPositionPixels.x, screenPositionPixels.y, 16, 16, 0 );\\n\\n\\n\\t\\t\\t\\t\\t// render pink quad\\n\\n\\t\\t\\t\\t\\tgl.uniform1i( uniforms.renderType, 0 );\\n\\t\\t\\t\\t\\tgl.uniform2f( uniforms.scale, scale.x, scale.y );\\n\\t\\t\\t\\t\\tgl.uniform3f( uniforms.screenPosition, screenPosition.x, screenPosition.y, screenPosition.z );\\n\\n\\t\\t\\t\\t\\tstate.disable( gl.BLEND );\\n\\t\\t\\t\\t\\tstate.enable( gl.DEPTH_TEST );\\n\\n\\t\\t\\t\\t\\tgl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );\\n\\n\\n\\t\\t\\t\\t\\t// copy result to occlusionMap\\n\\n\\t\\t\\t\\t\\tstate.activeTexture( gl.TEXTURE0 );\\n\\t\\t\\t\\t\\tstate.bindTexture( gl.TEXTURE_2D, occlusionTexture );\\n\\t\\t\\t\\t\\tgl.copyTexImage2D( gl.TEXTURE_2D, 0, gl.RGBA, screenPositionPixels.x, screenPositionPixels.y, 16, 16, 0 );\\n\\n\\n\\t\\t\\t\\t\\t// restore graphics\\n\\n\\t\\t\\t\\t\\tgl.uniform1i( uniforms.renderType, 1 );\\n\\t\\t\\t\\t\\tstate.disable( gl.DEPTH_TEST );\\n\\n\\t\\t\\t\\t\\tstate.activeTexture( gl.TEXTURE1 );\\n\\t\\t\\t\\t\\tstate.bindTexture( gl.TEXTURE_2D, tempTexture );\\n\\t\\t\\t\\t\\tgl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );\\n\\n\\n\\t\\t\\t\\t\\t// update object positions\\n\\n\\t\\t\\t\\t\\tflare.positionScreen.copy( screenPosition );\\n\\n\\t\\t\\t\\t\\tif ( flare.customUpdateCallback ) {\\n\\n\\t\\t\\t\\t\\t\\tflare.customUpdateCallback( flare );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tflare.updateLensFlares();\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t// render flares\\n\\n\\t\\t\\t\\t\\tgl.uniform1i( uniforms.renderType, 2 );\\n\\t\\t\\t\\t\\tstate.enable( gl.BLEND );\\n\\n\\t\\t\\t\\t\\tfor ( var j = 0, jl = flare.lensFlares.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar sprite = flare.lensFlares[ j ];\\n\\n\\t\\t\\t\\t\\t\\tif ( sprite.opacity > 0.001 && sprite.scale > 0.001 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tscreenPosition.x = sprite.x;\\n\\t\\t\\t\\t\\t\\t\\tscreenPosition.y = sprite.y;\\n\\t\\t\\t\\t\\t\\t\\tscreenPosition.z = sprite.z;\\n\\n\\t\\t\\t\\t\\t\\t\\tsize = sprite.size * sprite.scale / viewport.w;\\n\\n\\t\\t\\t\\t\\t\\t\\tscale.x = size * invAspect;\\n\\t\\t\\t\\t\\t\\t\\tscale.y = size;\\n\\n\\t\\t\\t\\t\\t\\t\\tgl.uniform3f( uniforms.screenPosition, screenPosition.x, screenPosition.y, screenPosition.z );\\n\\t\\t\\t\\t\\t\\t\\tgl.uniform2f( uniforms.scale, scale.x, scale.y );\\n\\t\\t\\t\\t\\t\\t\\tgl.uniform1f( uniforms.rotation, sprite.rotation );\\n\\n\\t\\t\\t\\t\\t\\t\\tgl.uniform1f( uniforms.opacity, sprite.opacity );\\n\\t\\t\\t\\t\\t\\t\\tgl.uniform3f( uniforms.color, sprite.color.r, sprite.color.g, sprite.color.b );\\n\\n\\t\\t\\t\\t\\t\\t\\tstate.setBlending( sprite.blending, sprite.blendEquation, sprite.blendSrc, sprite.blendDst );\\n\\n\\t\\t\\t\\t\\t\\t\\ttextures.setTexture2D( sprite.texture, 1 );\\n\\n\\t\\t\\t\\t\\t\\t\\tgl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// restore gl\\n\\n\\t\\t\\tstate.enable( gl.CULL_FACE );\\n\\t\\t\\tstate.enable( gl.DEPTH_TEST );\\n\\t\\t\\tstate.buffers.depth.setMask( true );\\n\\n\\t\\t\\tstate.reset();\\n\\n\\t\\t};\\n\\n\\t\\tfunction createProgram( shader ) {\\n\\n\\t\\t\\tvar program = gl.createProgram();\\n\\n\\t\\t\\tvar fragmentShader = gl.createShader( gl.FRAGMENT_SHADER );\\n\\t\\t\\tvar vertexShader = gl.createShader( gl.VERTEX_SHADER );\\n\\n\\t\\t\\tvar prefix = 'precision ' + capabilities.precision + ' float;\\\\n';\\n\\n\\t\\t\\tgl.shaderSource( fragmentShader, prefix + shader.fragmentShader );\\n\\t\\t\\tgl.shaderSource( vertexShader, prefix + shader.vertexShader );\\n\\n\\t\\t\\tgl.compileShader( fragmentShader );\\n\\t\\t\\tgl.compileShader( vertexShader );\\n\\n\\t\\t\\tgl.attachShader( program, fragmentShader );\\n\\t\\t\\tgl.attachShader( program, vertexShader );\\n\\n\\t\\t\\tgl.linkProgram( program );\\n\\n\\t\\t\\treturn program;\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction CanvasTexture( canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) {\\n\\n\\t\\tTexture.call( this, canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );\\n\\n\\t\\tthis.needsUpdate = true;\\n\\n\\t}\\n\\n\\tCanvasTexture.prototype = Object.create( Texture.prototype );\\n\\tCanvasTexture.prototype.constructor = CanvasTexture;\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction WebGLSpriteRenderer( renderer, gl, state, textures, capabilities ) {\\n\\n\\t\\tvar vertexBuffer, elementBuffer;\\n\\t\\tvar program, attributes, uniforms;\\n\\n\\t\\tvar texture;\\n\\n\\t\\t// decompose matrixWorld\\n\\n\\t\\tvar spritePosition = new Vector3();\\n\\t\\tvar spriteRotation = new Quaternion();\\n\\t\\tvar spriteScale = new Vector3();\\n\\n\\t\\tfunction init() {\\n\\n\\t\\t\\tvar vertices = new Float32Array( [\\n\\t\\t\\t\\t- 0.5, - 0.5, 0, 0,\\n\\t\\t\\t\\t 0.5, - 0.5, 1, 0,\\n\\t\\t\\t\\t 0.5, 0.5, 1, 1,\\n\\t\\t\\t\\t- 0.5, 0.5, 0, 1\\n\\t\\t\\t] );\\n\\n\\t\\t\\tvar faces = new Uint16Array( [\\n\\t\\t\\t\\t0, 1, 2,\\n\\t\\t\\t\\t0, 2, 3\\n\\t\\t\\t] );\\n\\n\\t\\t\\tvertexBuffer = gl.createBuffer();\\n\\t\\t\\telementBuffer = gl.createBuffer();\\n\\n\\t\\t\\tgl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer );\\n\\t\\t\\tgl.bufferData( gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW );\\n\\n\\t\\t\\tgl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer );\\n\\t\\t\\tgl.bufferData( gl.ELEMENT_ARRAY_BUFFER, faces, gl.STATIC_DRAW );\\n\\n\\t\\t\\tprogram = createProgram();\\n\\n\\t\\t\\tattributes = {\\n\\t\\t\\t\\tposition: gl.getAttribLocation( program, 'position' ),\\n\\t\\t\\t\\tuv: gl.getAttribLocation( program, 'uv' )\\n\\t\\t\\t};\\n\\n\\t\\t\\tuniforms = {\\n\\t\\t\\t\\tuvOffset: gl.getUniformLocation( program, 'uvOffset' ),\\n\\t\\t\\t\\tuvScale: gl.getUniformLocation( program, 'uvScale' ),\\n\\n\\t\\t\\t\\trotation: gl.getUniformLocation( program, 'rotation' ),\\n\\t\\t\\t\\tscale: gl.getUniformLocation( program, 'scale' ),\\n\\n\\t\\t\\t\\tcolor: gl.getUniformLocation( program, 'color' ),\\n\\t\\t\\t\\tmap: gl.getUniformLocation( program, 'map' ),\\n\\t\\t\\t\\topacity: gl.getUniformLocation( program, 'opacity' ),\\n\\n\\t\\t\\t\\tmodelViewMatrix: gl.getUniformLocation( program, 'modelViewMatrix' ),\\n\\t\\t\\t\\tprojectionMatrix: gl.getUniformLocation( program, 'projectionMatrix' ),\\n\\n\\t\\t\\t\\tfogType: gl.getUniformLocation( program, 'fogType' ),\\n\\t\\t\\t\\tfogDensity: gl.getUniformLocation( program, 'fogDensity' ),\\n\\t\\t\\t\\tfogNear: gl.getUniformLocation( program, 'fogNear' ),\\n\\t\\t\\t\\tfogFar: gl.getUniformLocation( program, 'fogFar' ),\\n\\t\\t\\t\\tfogColor: gl.getUniformLocation( program, 'fogColor' ),\\n\\t\\t\\t\\tfogDepth: gl.getUniformLocation( program, 'fogDepth' ),\\n\\n\\t\\t\\t\\talphaTest: gl.getUniformLocation( program, 'alphaTest' )\\n\\t\\t\\t};\\n\\n\\t\\t\\tvar canvas = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' );\\n\\t\\t\\tcanvas.width = 8;\\n\\t\\t\\tcanvas.height = 8;\\n\\n\\t\\t\\tvar context = canvas.getContext( '2d' );\\n\\t\\t\\tcontext.fillStyle = 'white';\\n\\t\\t\\tcontext.fillRect( 0, 0, 8, 8 );\\n\\n\\t\\t\\ttexture = new CanvasTexture( canvas );\\n\\n\\t\\t}\\n\\n\\t\\tthis.render = function ( sprites, scene, camera ) {\\n\\n\\t\\t\\tif ( sprites.length === 0 ) return;\\n\\n\\t\\t\\t// setup gl\\n\\n\\t\\t\\tif ( program === undefined ) {\\n\\n\\t\\t\\t\\tinit();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tstate.useProgram( program );\\n\\n\\t\\t\\tstate.initAttributes();\\n\\t\\t\\tstate.enableAttribute( attributes.position );\\n\\t\\t\\tstate.enableAttribute( attributes.uv );\\n\\t\\t\\tstate.disableUnusedAttributes();\\n\\n\\t\\t\\tstate.disable( gl.CULL_FACE );\\n\\t\\t\\tstate.enable( gl.BLEND );\\n\\n\\t\\t\\tgl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer );\\n\\t\\t\\tgl.vertexAttribPointer( attributes.position, 2, gl.FLOAT, false, 2 * 8, 0 );\\n\\t\\t\\tgl.vertexAttribPointer( attributes.uv, 2, gl.FLOAT, false, 2 * 8, 8 );\\n\\n\\t\\t\\tgl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer );\\n\\n\\t\\t\\tgl.uniformMatrix4fv( uniforms.projectionMatrix, false, camera.projectionMatrix.elements );\\n\\n\\t\\t\\tstate.activeTexture( gl.TEXTURE0 );\\n\\t\\t\\tgl.uniform1i( uniforms.map, 0 );\\n\\n\\t\\t\\tvar oldFogType = 0;\\n\\t\\t\\tvar sceneFogType = 0;\\n\\t\\t\\tvar fog = scene.fog;\\n\\n\\t\\t\\tif ( fog ) {\\n\\n\\t\\t\\t\\tgl.uniform3f( uniforms.fogColor, fog.color.r, fog.color.g, fog.color.b );\\n\\n\\t\\t\\t\\tif ( fog.isFog ) {\\n\\n\\t\\t\\t\\t\\tgl.uniform1f( uniforms.fogNear, fog.near );\\n\\t\\t\\t\\t\\tgl.uniform1f( uniforms.fogFar, fog.far );\\n\\n\\t\\t\\t\\t\\tgl.uniform1i( uniforms.fogType, 1 );\\n\\t\\t\\t\\t\\toldFogType = 1;\\n\\t\\t\\t\\t\\tsceneFogType = 1;\\n\\n\\t\\t\\t\\t} else if ( fog.isFogExp2 ) {\\n\\n\\t\\t\\t\\t\\tgl.uniform1f( uniforms.fogDensity, fog.density );\\n\\n\\t\\t\\t\\t\\tgl.uniform1i( uniforms.fogType, 2 );\\n\\t\\t\\t\\t\\toldFogType = 2;\\n\\t\\t\\t\\t\\tsceneFogType = 2;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tgl.uniform1i( uniforms.fogType, 0 );\\n\\t\\t\\t\\toldFogType = 0;\\n\\t\\t\\t\\tsceneFogType = 0;\\n\\n\\t\\t\\t}\\n\\n\\n\\t\\t\\t// update positions and sort\\n\\n\\t\\t\\tfor ( var i = 0, l = sprites.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar sprite = sprites[ i ];\\n\\n\\t\\t\\t\\tsprite.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, sprite.matrixWorld );\\n\\t\\t\\t\\tsprite.z = - sprite.modelViewMatrix.elements[ 14 ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tsprites.sort( painterSortStable );\\n\\n\\t\\t\\t// render all sprites\\n\\n\\t\\t\\tvar scale = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = sprites.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar sprite = sprites[ i ];\\n\\t\\t\\t\\tvar material = sprite.material;\\n\\n\\t\\t\\t\\tif ( material.visible === false ) continue;\\n\\n\\t\\t\\t\\tsprite.onBeforeRender( renderer, scene, camera, undefined, material, undefined );\\n\\n\\t\\t\\t\\tgl.uniform1f( uniforms.alphaTest, material.alphaTest );\\n\\t\\t\\t\\tgl.uniformMatrix4fv( uniforms.modelViewMatrix, false, sprite.modelViewMatrix.elements );\\n\\n\\t\\t\\t\\tsprite.matrixWorld.decompose( spritePosition, spriteRotation, spriteScale );\\n\\n\\t\\t\\t\\tscale[ 0 ] = spriteScale.x;\\n\\t\\t\\t\\tscale[ 1 ] = spriteScale.y;\\n\\n\\t\\t\\t\\tvar fogType = 0;\\n\\n\\t\\t\\t\\tif ( scene.fog && material.fog ) {\\n\\n\\t\\t\\t\\t\\tfogType = sceneFogType;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( oldFogType !== fogType ) {\\n\\n\\t\\t\\t\\t\\tgl.uniform1i( uniforms.fogType, fogType );\\n\\t\\t\\t\\t\\toldFogType = fogType;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( material.map !== null ) {\\n\\n\\t\\t\\t\\t\\tgl.uniform2f( uniforms.uvOffset, material.map.offset.x, material.map.offset.y );\\n\\t\\t\\t\\t\\tgl.uniform2f( uniforms.uvScale, material.map.repeat.x, material.map.repeat.y );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tgl.uniform2f( uniforms.uvOffset, 0, 0 );\\n\\t\\t\\t\\t\\tgl.uniform2f( uniforms.uvScale, 1, 1 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgl.uniform1f( uniforms.opacity, material.opacity );\\n\\t\\t\\t\\tgl.uniform3f( uniforms.color, material.color.r, material.color.g, material.color.b );\\n\\n\\t\\t\\t\\tgl.uniform1f( uniforms.rotation, material.rotation );\\n\\t\\t\\t\\tgl.uniform2fv( uniforms.scale, scale );\\n\\n\\t\\t\\t\\tstate.setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha, material.premultipliedAlpha );\\n\\t\\t\\t\\tstate.buffers.depth.setTest( material.depthTest );\\n\\t\\t\\t\\tstate.buffers.depth.setMask( material.depthWrite );\\n\\t\\t\\t\\tstate.buffers.color.setMask( material.colorWrite );\\n\\n\\t\\t\\t\\ttextures.setTexture2D( material.map || texture, 0 );\\n\\n\\t\\t\\t\\tgl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );\\n\\n\\t\\t\\t\\tsprite.onAfterRender( renderer, scene, camera, undefined, material, undefined );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// restore gl\\n\\n\\t\\t\\tstate.enable( gl.CULL_FACE );\\n\\n\\t\\t\\tstate.reset();\\n\\n\\t\\t};\\n\\n\\t\\tfunction createProgram() {\\n\\n\\t\\t\\tvar program = gl.createProgram();\\n\\n\\t\\t\\tvar vertexShader = gl.createShader( gl.VERTEX_SHADER );\\n\\t\\t\\tvar fragmentShader = gl.createShader( gl.FRAGMENT_SHADER );\\n\\n\\t\\t\\tgl.shaderSource( vertexShader, [\\n\\n\\t\\t\\t\\t'precision ' + capabilities.precision + ' float;',\\n\\n\\t\\t\\t\\t'#define SHADER_NAME ' + 'SpriteMaterial',\\n\\n\\t\\t\\t\\t'uniform mat4 modelViewMatrix;',\\n\\t\\t\\t\\t'uniform mat4 projectionMatrix;',\\n\\t\\t\\t\\t'uniform float rotation;',\\n\\t\\t\\t\\t'uniform vec2 scale;',\\n\\t\\t\\t\\t'uniform vec2 uvOffset;',\\n\\t\\t\\t\\t'uniform vec2 uvScale;',\\n\\n\\t\\t\\t\\t'attribute vec2 position;',\\n\\t\\t\\t\\t'attribute vec2 uv;',\\n\\n\\t\\t\\t\\t'varying vec2 vUV;',\\n\\t\\t\\t\\t'varying float fogDepth;',\\n\\n\\t\\t\\t\\t'void main() {',\\n\\n\\t\\t\\t\\t'\\tvUV = uvOffset + uv * uvScale;',\\n\\n\\t\\t\\t\\t'\\tvec2 alignedPosition = position * scale;',\\n\\n\\t\\t\\t\\t'\\tvec2 rotatedPosition;',\\n\\t\\t\\t\\t'\\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;',\\n\\t\\t\\t\\t'\\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;',\\n\\n\\t\\t\\t\\t'\\tvec4 mvPosition;',\\n\\n\\t\\t\\t\\t'\\tmvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );',\\n\\t\\t\\t\\t'\\tmvPosition.xy += rotatedPosition;',\\n\\n\\t\\t\\t\\t'\\tgl_Position = projectionMatrix * mvPosition;',\\n\\n\\t\\t\\t\\t'\\tfogDepth = - mvPosition.z;',\\n\\n\\t\\t\\t\\t'}'\\n\\n\\t\\t\\t].join( '\\\\n' ) );\\n\\n\\t\\t\\tgl.shaderSource( fragmentShader, [\\n\\n\\t\\t\\t\\t'precision ' + capabilities.precision + ' float;',\\n\\n\\t\\t\\t\\t'#define SHADER_NAME ' + 'SpriteMaterial',\\n\\n\\t\\t\\t\\t'uniform vec3 color;',\\n\\t\\t\\t\\t'uniform sampler2D map;',\\n\\t\\t\\t\\t'uniform float opacity;',\\n\\n\\t\\t\\t\\t'uniform int fogType;',\\n\\t\\t\\t\\t'uniform vec3 fogColor;',\\n\\t\\t\\t\\t'uniform float fogDensity;',\\n\\t\\t\\t\\t'uniform float fogNear;',\\n\\t\\t\\t\\t'uniform float fogFar;',\\n\\t\\t\\t\\t'uniform float alphaTest;',\\n\\n\\t\\t\\t\\t'varying vec2 vUV;',\\n\\t\\t\\t\\t'varying float fogDepth;',\\n\\n\\t\\t\\t\\t'void main() {',\\n\\n\\t\\t\\t\\t'\\tvec4 texture = texture2D( map, vUV );',\\n\\n\\t\\t\\t\\t'\\tgl_FragColor = vec4( color * texture.xyz, texture.a * opacity );',\\n\\n\\t\\t\\t\\t'\\tif ( gl_FragColor.a < alphaTest ) discard;',\\n\\n\\t\\t\\t\\t'\\tif ( fogType > 0 ) {',\\n\\n\\t\\t\\t\\t'\\t\\tfloat fogFactor = 0.0;',\\n\\n\\t\\t\\t\\t'\\t\\tif ( fogType == 1 ) {',\\n\\n\\t\\t\\t\\t'\\t\\t\\tfogFactor = smoothstep( fogNear, fogFar, fogDepth );',\\n\\n\\t\\t\\t\\t'\\t\\t} else {',\\n\\n\\t\\t\\t\\t'\\t\\t\\tconst float LOG2 = 1.442695;',\\n\\t\\t\\t\\t'\\t\\t\\tfogFactor = exp2( - fogDensity * fogDensity * fogDepth * fogDepth * LOG2 );',\\n\\t\\t\\t\\t'\\t\\t\\tfogFactor = 1.0 - clamp( fogFactor, 0.0, 1.0 );',\\n\\n\\t\\t\\t\\t'\\t\\t}',\\n\\n\\t\\t\\t\\t'\\t\\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );',\\n\\n\\t\\t\\t\\t'\\t}',\\n\\n\\t\\t\\t\\t'}'\\n\\n\\t\\t\\t].join( '\\\\n' ) );\\n\\n\\t\\t\\tgl.compileShader( vertexShader );\\n\\t\\t\\tgl.compileShader( fragmentShader );\\n\\n\\t\\t\\tgl.attachShader( program, vertexShader );\\n\\t\\t\\tgl.attachShader( program, fragmentShader );\\n\\n\\t\\t\\tgl.linkProgram( program );\\n\\n\\t\\t\\treturn program;\\n\\n\\t\\t}\\n\\n\\t\\tfunction painterSortStable( a, b ) {\\n\\n\\t\\t\\tif ( a.renderOrder !== b.renderOrder ) {\\n\\n\\t\\t\\t\\treturn a.renderOrder - b.renderOrder;\\n\\n\\t\\t\\t} else if ( a.z !== b.z ) {\\n\\n\\t\\t\\t\\treturn b.z - a.z;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\treturn b.id - a.id;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tvar materialId = 0;\\n\\n\\tfunction Material() {\\n\\n\\t\\tObject.defineProperty( this, 'id', { value: materialId ++ } );\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.name = '';\\n\\t\\tthis.type = 'Material';\\n\\n\\t\\tthis.fog = true;\\n\\t\\tthis.lights = true;\\n\\n\\t\\tthis.blending = NormalBlending;\\n\\t\\tthis.side = FrontSide;\\n\\t\\tthis.flatShading = false;\\n\\t\\tthis.vertexColors = NoColors; // THREE.NoColors, THREE.VertexColors, THREE.FaceColors\\n\\n\\t\\tthis.opacity = 1;\\n\\t\\tthis.transparent = false;\\n\\n\\t\\tthis.blendSrc = SrcAlphaFactor;\\n\\t\\tthis.blendDst = OneMinusSrcAlphaFactor;\\n\\t\\tthis.blendEquation = AddEquation;\\n\\t\\tthis.blendSrcAlpha = null;\\n\\t\\tthis.blendDstAlpha = null;\\n\\t\\tthis.blendEquationAlpha = null;\\n\\n\\t\\tthis.depthFunc = LessEqualDepth;\\n\\t\\tthis.depthTest = true;\\n\\t\\tthis.depthWrite = true;\\n\\n\\t\\tthis.clippingPlanes = null;\\n\\t\\tthis.clipIntersection = false;\\n\\t\\tthis.clipShadows = false;\\n\\n\\t\\tthis.colorWrite = true;\\n\\n\\t\\tthis.precision = null; // override the renderer's default precision for this material\\n\\n\\t\\tthis.polygonOffset = false;\\n\\t\\tthis.polygonOffsetFactor = 0;\\n\\t\\tthis.polygonOffsetUnits = 0;\\n\\n\\t\\tthis.dithering = false;\\n\\n\\t\\tthis.alphaTest = 0;\\n\\t\\tthis.premultipliedAlpha = false;\\n\\n\\t\\tthis.overdraw = 0; // Overdrawn pixels (typically between 0 and 1) for fixing antialiasing gaps in CanvasRenderer\\n\\n\\t\\tthis.visible = true;\\n\\n\\t\\tthis.userData = {};\\n\\n\\t\\tthis.needsUpdate = true;\\n\\n\\t}\\n\\n\\tMaterial.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {\\n\\n\\t\\tconstructor: Material,\\n\\n\\t\\tisMaterial: true,\\n\\n\\t\\tonBeforeCompile: function () {},\\n\\n\\t\\tsetValues: function ( values ) {\\n\\n\\t\\t\\tif ( values === undefined ) return;\\n\\n\\t\\t\\tfor ( var key in values ) {\\n\\n\\t\\t\\t\\tvar newValue = values[ key ];\\n\\n\\t\\t\\t\\tif ( newValue === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( \\\"THREE.Material: '\\\" + key + \\\"' parameter is undefined.\\\" );\\n\\t\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// for backward compatability if shading is set in the constructor\\n\\t\\t\\t\\tif ( key === 'shading' ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.' + this.type + ': .shading has been removed. Use the boolean .flatShading instead.' );\\n\\t\\t\\t\\t\\tthis.flatShading = ( newValue === FlatShading ) ? true : false;\\n\\t\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar currentValue = this[ key ];\\n\\n\\t\\t\\t\\tif ( currentValue === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( \\\"THREE.\\\" + this.type + \\\": '\\\" + key + \\\"' is not a property of this material.\\\" );\\n\\t\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( currentValue && currentValue.isColor ) {\\n\\n\\t\\t\\t\\t\\tcurrentValue.set( newValue );\\n\\n\\t\\t\\t\\t} else if ( ( currentValue && currentValue.isVector3 ) && ( newValue && newValue.isVector3 ) ) {\\n\\n\\t\\t\\t\\t\\tcurrentValue.copy( newValue );\\n\\n\\t\\t\\t\\t} else if ( key === 'overdraw' ) {\\n\\n\\t\\t\\t\\t\\t// ensure overdraw is backwards-compatible with legacy boolean type\\n\\t\\t\\t\\t\\tthis[ key ] = Number( newValue );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthis[ key ] = newValue;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\tvar isRoot = ( meta === undefined || typeof meta === 'string' );\\n\\n\\t\\t\\tif ( isRoot ) {\\n\\n\\t\\t\\t\\tmeta = {\\n\\t\\t\\t\\t\\ttextures: {},\\n\\t\\t\\t\\t\\timages: {}\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar data = {\\n\\t\\t\\t\\tmetadata: {\\n\\t\\t\\t\\t\\tversion: 4.5,\\n\\t\\t\\t\\t\\ttype: 'Material',\\n\\t\\t\\t\\t\\tgenerator: 'Material.toJSON'\\n\\t\\t\\t\\t}\\n\\t\\t\\t};\\n\\n\\t\\t\\t// standard Material serialization\\n\\t\\t\\tdata.uuid = this.uuid;\\n\\t\\t\\tdata.type = this.type;\\n\\n\\t\\t\\tif ( this.name !== '' ) data.name = this.name;\\n\\n\\t\\t\\tif ( this.color && this.color.isColor ) data.color = this.color.getHex();\\n\\n\\t\\t\\tif ( this.roughness !== undefined ) data.roughness = this.roughness;\\n\\t\\t\\tif ( this.metalness !== undefined ) data.metalness = this.metalness;\\n\\n\\t\\t\\tif ( this.emissive && this.emissive.isColor ) data.emissive = this.emissive.getHex();\\n\\t\\t\\tif ( this.emissiveIntensity !== 1 ) data.emissiveIntensity = this.emissiveIntensity;\\n\\n\\t\\t\\tif ( this.specular && this.specular.isColor ) data.specular = this.specular.getHex();\\n\\t\\t\\tif ( this.shininess !== undefined ) data.shininess = this.shininess;\\n\\t\\t\\tif ( this.clearCoat !== undefined ) data.clearCoat = this.clearCoat;\\n\\t\\t\\tif ( this.clearCoatRoughness !== undefined ) data.clearCoatRoughness = this.clearCoatRoughness;\\n\\n\\t\\t\\tif ( this.map && this.map.isTexture ) data.map = this.map.toJSON( meta ).uuid;\\n\\t\\t\\tif ( this.alphaMap && this.alphaMap.isTexture ) data.alphaMap = this.alphaMap.toJSON( meta ).uuid;\\n\\t\\t\\tif ( this.lightMap && this.lightMap.isTexture ) data.lightMap = this.lightMap.toJSON( meta ).uuid;\\n\\t\\t\\tif ( this.bumpMap && this.bumpMap.isTexture ) {\\n\\n\\t\\t\\t\\tdata.bumpMap = this.bumpMap.toJSON( meta ).uuid;\\n\\t\\t\\t\\tdata.bumpScale = this.bumpScale;\\n\\n\\t\\t\\t}\\n\\t\\t\\tif ( this.normalMap && this.normalMap.isTexture ) {\\n\\n\\t\\t\\t\\tdata.normalMap = this.normalMap.toJSON( meta ).uuid;\\n\\t\\t\\t\\tdata.normalScale = this.normalScale.toArray();\\n\\n\\t\\t\\t}\\n\\t\\t\\tif ( this.displacementMap && this.displacementMap.isTexture ) {\\n\\n\\t\\t\\t\\tdata.displacementMap = this.displacementMap.toJSON( meta ).uuid;\\n\\t\\t\\t\\tdata.displacementScale = this.displacementScale;\\n\\t\\t\\t\\tdata.displacementBias = this.displacementBias;\\n\\n\\t\\t\\t}\\n\\t\\t\\tif ( this.roughnessMap && this.roughnessMap.isTexture ) data.roughnessMap = this.roughnessMap.toJSON( meta ).uuid;\\n\\t\\t\\tif ( this.metalnessMap && this.metalnessMap.isTexture ) data.metalnessMap = this.metalnessMap.toJSON( meta ).uuid;\\n\\n\\t\\t\\tif ( this.emissiveMap && this.emissiveMap.isTexture ) data.emissiveMap = this.emissiveMap.toJSON( meta ).uuid;\\n\\t\\t\\tif ( this.specularMap && this.specularMap.isTexture ) data.specularMap = this.specularMap.toJSON( meta ).uuid;\\n\\n\\t\\t\\tif ( this.envMap && this.envMap.isTexture ) {\\n\\n\\t\\t\\t\\tdata.envMap = this.envMap.toJSON( meta ).uuid;\\n\\t\\t\\t\\tdata.reflectivity = this.reflectivity; // Scale behind envMap\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.gradientMap && this.gradientMap.isTexture ) {\\n\\n\\t\\t\\t\\tdata.gradientMap = this.gradientMap.toJSON( meta ).uuid;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.size !== undefined ) data.size = this.size;\\n\\t\\t\\tif ( this.sizeAttenuation !== undefined ) data.sizeAttenuation = this.sizeAttenuation;\\n\\n\\t\\t\\tif ( this.blending !== NormalBlending ) data.blending = this.blending;\\n\\t\\t\\tif ( this.flatShading === true ) data.flatShading = this.flatShading;\\n\\t\\t\\tif ( this.side !== FrontSide ) data.side = this.side;\\n\\t\\t\\tif ( this.vertexColors !== NoColors ) data.vertexColors = this.vertexColors;\\n\\n\\t\\t\\tif ( this.opacity < 1 ) data.opacity = this.opacity;\\n\\t\\t\\tif ( this.transparent === true ) data.transparent = this.transparent;\\n\\n\\t\\t\\tdata.depthFunc = this.depthFunc;\\n\\t\\t\\tdata.depthTest = this.depthTest;\\n\\t\\t\\tdata.depthWrite = this.depthWrite;\\n\\n\\t\\t\\t// rotation (SpriteMaterial)\\n\\t\\t\\tif ( this.rotation !== 0 ) data.rotation = this.rotation;\\n\\n\\t\\t\\tif ( this.linewidth !== 1 ) data.linewidth = this.linewidth;\\n\\t\\t\\tif ( this.dashSize !== undefined ) data.dashSize = this.dashSize;\\n\\t\\t\\tif ( this.gapSize !== undefined ) data.gapSize = this.gapSize;\\n\\t\\t\\tif ( this.scale !== undefined ) data.scale = this.scale;\\n\\n\\t\\t\\tif ( this.dithering === true ) data.dithering = true;\\n\\n\\t\\t\\tif ( this.alphaTest > 0 ) data.alphaTest = this.alphaTest;\\n\\t\\t\\tif ( this.premultipliedAlpha === true ) data.premultipliedAlpha = this.premultipliedAlpha;\\n\\n\\t\\t\\tif ( this.wireframe === true ) data.wireframe = this.wireframe;\\n\\t\\t\\tif ( this.wireframeLinewidth > 1 ) data.wireframeLinewidth = this.wireframeLinewidth;\\n\\t\\t\\tif ( this.wireframeLinecap !== 'round' ) data.wireframeLinecap = this.wireframeLinecap;\\n\\t\\t\\tif ( this.wireframeLinejoin !== 'round' ) data.wireframeLinejoin = this.wireframeLinejoin;\\n\\n\\t\\t\\tif ( this.morphTargets === true ) data.morphTargets = true;\\n\\t\\t\\tif ( this.skinning === true ) data.skinning = true;\\n\\n\\t\\t\\tif ( this.visible === false ) data.visible = false;\\n\\t\\t\\tif ( JSON.stringify( this.userData ) !== '{}' ) data.userData = this.userData;\\n\\n\\t\\t\\t// TODO: Copied from Object3D.toJSON\\n\\n\\t\\t\\tfunction extractFromCache( cache ) {\\n\\n\\t\\t\\t\\tvar values = [];\\n\\n\\t\\t\\t\\tfor ( var key in cache ) {\\n\\n\\t\\t\\t\\t\\tvar data = cache[ key ];\\n\\t\\t\\t\\t\\tdelete data.metadata;\\n\\t\\t\\t\\t\\tvalues.push( data );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn values;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( isRoot ) {\\n\\n\\t\\t\\t\\tvar textures = extractFromCache( meta.textures );\\n\\t\\t\\t\\tvar images = extractFromCache( meta.images );\\n\\n\\t\\t\\t\\tif ( textures.length > 0 ) data.textures = textures;\\n\\t\\t\\t\\tif ( images.length > 0 ) data.images = images;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tthis.name = source.name;\\n\\n\\t\\t\\tthis.fog = source.fog;\\n\\t\\t\\tthis.lights = source.lights;\\n\\n\\t\\t\\tthis.blending = source.blending;\\n\\t\\t\\tthis.side = source.side;\\n\\t\\t\\tthis.flatShading = source.flatShading;\\n\\t\\t\\tthis.vertexColors = source.vertexColors;\\n\\n\\t\\t\\tthis.opacity = source.opacity;\\n\\t\\t\\tthis.transparent = source.transparent;\\n\\n\\t\\t\\tthis.blendSrc = source.blendSrc;\\n\\t\\t\\tthis.blendDst = source.blendDst;\\n\\t\\t\\tthis.blendEquation = source.blendEquation;\\n\\t\\t\\tthis.blendSrcAlpha = source.blendSrcAlpha;\\n\\t\\t\\tthis.blendDstAlpha = source.blendDstAlpha;\\n\\t\\t\\tthis.blendEquationAlpha = source.blendEquationAlpha;\\n\\n\\t\\t\\tthis.depthFunc = source.depthFunc;\\n\\t\\t\\tthis.depthTest = source.depthTest;\\n\\t\\t\\tthis.depthWrite = source.depthWrite;\\n\\n\\t\\t\\tthis.colorWrite = source.colorWrite;\\n\\n\\t\\t\\tthis.precision = source.precision;\\n\\n\\t\\t\\tthis.polygonOffset = source.polygonOffset;\\n\\t\\t\\tthis.polygonOffsetFactor = source.polygonOffsetFactor;\\n\\t\\t\\tthis.polygonOffsetUnits = source.polygonOffsetUnits;\\n\\n\\t\\t\\tthis.dithering = source.dithering;\\n\\n\\t\\t\\tthis.alphaTest = source.alphaTest;\\n\\t\\t\\tthis.premultipliedAlpha = source.premultipliedAlpha;\\n\\n\\t\\t\\tthis.overdraw = source.overdraw;\\n\\n\\t\\t\\tthis.visible = source.visible;\\n\\t\\t\\tthis.userData = JSON.parse( JSON.stringify( source.userData ) );\\n\\n\\t\\t\\tthis.clipShadows = source.clipShadows;\\n\\t\\t\\tthis.clipIntersection = source.clipIntersection;\\n\\n\\t\\t\\tvar srcPlanes = source.clippingPlanes,\\n\\t\\t\\t\\tdstPlanes = null;\\n\\n\\t\\t\\tif ( srcPlanes !== null ) {\\n\\n\\t\\t\\t\\tvar n = srcPlanes.length;\\n\\t\\t\\t\\tdstPlanes = new Array( n );\\n\\n\\t\\t\\t\\tfor ( var i = 0; i !== n; ++ i )\\n\\t\\t\\t\\t\\tdstPlanes[ i ] = srcPlanes[ i ].clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.clippingPlanes = dstPlanes;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdispose: function () {\\n\\n\\t\\t\\tthis.dispatchEvent( { type: 'dispose' } );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author bhouston / https://clara.io\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t *\\n\\t * parameters = {\\n\\t *\\n\\t * opacity: ,\\n\\t *\\n\\t * map: new THREE.Texture( ),\\n\\t *\\n\\t * alphaMap: new THREE.Texture( ),\\n\\t *\\n\\t * displacementMap: new THREE.Texture( ),\\n\\t * displacementScale: ,\\n\\t * displacementBias: ,\\n\\t *\\n\\t * wireframe: ,\\n\\t * wireframeLinewidth: \\n\\t * }\\n\\t */\\n\\n\\tfunction MeshDepthMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'MeshDepthMaterial';\\n\\n\\t\\tthis.depthPacking = BasicDepthPacking;\\n\\n\\t\\tthis.skinning = false;\\n\\t\\tthis.morphTargets = false;\\n\\n\\t\\tthis.map = null;\\n\\n\\t\\tthis.alphaMap = null;\\n\\n\\t\\tthis.displacementMap = null;\\n\\t\\tthis.displacementScale = 1;\\n\\t\\tthis.displacementBias = 0;\\n\\n\\t\\tthis.wireframe = false;\\n\\t\\tthis.wireframeLinewidth = 1;\\n\\n\\t\\tthis.fog = false;\\n\\t\\tthis.lights = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshDepthMaterial.prototype = Object.create( Material.prototype );\\n\\tMeshDepthMaterial.prototype.constructor = MeshDepthMaterial;\\n\\n\\tMeshDepthMaterial.prototype.isMeshDepthMaterial = true;\\n\\n\\tMeshDepthMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.depthPacking = source.depthPacking;\\n\\n\\t\\tthis.skinning = source.skinning;\\n\\t\\tthis.morphTargets = source.morphTargets;\\n\\n\\t\\tthis.map = source.map;\\n\\n\\t\\tthis.alphaMap = source.alphaMap;\\n\\n\\t\\tthis.displacementMap = source.displacementMap;\\n\\t\\tthis.displacementScale = source.displacementScale;\\n\\t\\tthis.displacementBias = source.displacementBias;\\n\\n\\t\\tthis.wireframe = source.wireframe;\\n\\t\\tthis.wireframeLinewidth = source.wireframeLinewidth;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t *\\n\\t * parameters = {\\n\\t *\\n\\t * referencePosition: ,\\n\\t * nearDistance: ,\\n\\t * farDistance: ,\\n\\t *\\n\\t * skinning: ,\\n\\t * morphTargets: ,\\n\\t *\\n\\t * map: new THREE.Texture( ),\\n\\t *\\n\\t * alphaMap: new THREE.Texture( ),\\n\\t *\\n\\t * displacementMap: new THREE.Texture( ),\\n\\t * displacementScale: ,\\n\\t * displacementBias: \\n\\t *\\n\\t * }\\n\\t */\\n\\n\\tfunction MeshDistanceMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'MeshDistanceMaterial';\\n\\n\\t\\tthis.referencePosition = new Vector3();\\n\\t\\tthis.nearDistance = 1;\\n\\t\\tthis.farDistance = 1000;\\n\\n\\t\\tthis.skinning = false;\\n\\t\\tthis.morphTargets = false;\\n\\n\\t\\tthis.map = null;\\n\\n\\t\\tthis.alphaMap = null;\\n\\n\\t\\tthis.displacementMap = null;\\n\\t\\tthis.displacementScale = 1;\\n\\t\\tthis.displacementBias = 0;\\n\\n\\t\\tthis.fog = false;\\n\\t\\tthis.lights = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshDistanceMaterial.prototype = Object.create( Material.prototype );\\n\\tMeshDistanceMaterial.prototype.constructor = MeshDistanceMaterial;\\n\\n\\tMeshDistanceMaterial.prototype.isMeshDistanceMaterial = true;\\n\\n\\tMeshDistanceMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.referencePosition.copy( source.referencePosition );\\n\\t\\tthis.nearDistance = source.nearDistance;\\n\\t\\tthis.farDistance = source.farDistance;\\n\\n\\t\\tthis.skinning = source.skinning;\\n\\t\\tthis.morphTargets = source.morphTargets;\\n\\n\\t\\tthis.map = source.map;\\n\\n\\t\\tthis.alphaMap = source.alphaMap;\\n\\n\\t\\tthis.displacementMap = source.displacementMap;\\n\\t\\tthis.displacementScale = source.displacementScale;\\n\\t\\tthis.displacementBias = source.displacementBias;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author bhouston / http://clara.io\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction Box3( min, max ) {\\n\\n\\t\\tthis.min = ( min !== undefined ) ? min : new Vector3( + Infinity, + Infinity, + Infinity );\\n\\t\\tthis.max = ( max !== undefined ) ? max : new Vector3( - Infinity, - Infinity, - Infinity );\\n\\n\\t}\\n\\n\\tObject.assign( Box3.prototype, {\\n\\n\\t\\tisBox3: true,\\n\\n\\t\\tset: function ( min, max ) {\\n\\n\\t\\t\\tthis.min.copy( min );\\n\\t\\t\\tthis.max.copy( max );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromArray: function ( array ) {\\n\\n\\t\\t\\tvar minX = + Infinity;\\n\\t\\t\\tvar minY = + Infinity;\\n\\t\\t\\tvar minZ = + Infinity;\\n\\n\\t\\t\\tvar maxX = - Infinity;\\n\\t\\t\\tvar maxY = - Infinity;\\n\\t\\t\\tvar maxZ = - Infinity;\\n\\n\\t\\t\\tfor ( var i = 0, l = array.length; i < l; i += 3 ) {\\n\\n\\t\\t\\t\\tvar x = array[ i ];\\n\\t\\t\\t\\tvar y = array[ i + 1 ];\\n\\t\\t\\t\\tvar z = array[ i + 2 ];\\n\\n\\t\\t\\t\\tif ( x < minX ) minX = x;\\n\\t\\t\\t\\tif ( y < minY ) minY = y;\\n\\t\\t\\t\\tif ( z < minZ ) minZ = z;\\n\\n\\t\\t\\t\\tif ( x > maxX ) maxX = x;\\n\\t\\t\\t\\tif ( y > maxY ) maxY = y;\\n\\t\\t\\t\\tif ( z > maxZ ) maxZ = z;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.min.set( minX, minY, minZ );\\n\\t\\t\\tthis.max.set( maxX, maxY, maxZ );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromBufferAttribute: function ( attribute ) {\\n\\n\\t\\t\\tvar minX = + Infinity;\\n\\t\\t\\tvar minY = + Infinity;\\n\\t\\t\\tvar minZ = + Infinity;\\n\\n\\t\\t\\tvar maxX = - Infinity;\\n\\t\\t\\tvar maxY = - Infinity;\\n\\t\\t\\tvar maxZ = - Infinity;\\n\\n\\t\\t\\tfor ( var i = 0, l = attribute.count; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar x = attribute.getX( i );\\n\\t\\t\\t\\tvar y = attribute.getY( i );\\n\\t\\t\\t\\tvar z = attribute.getZ( i );\\n\\n\\t\\t\\t\\tif ( x < minX ) minX = x;\\n\\t\\t\\t\\tif ( y < minY ) minY = y;\\n\\t\\t\\t\\tif ( z < minZ ) minZ = z;\\n\\n\\t\\t\\t\\tif ( x > maxX ) maxX = x;\\n\\t\\t\\t\\tif ( y > maxY ) maxY = y;\\n\\t\\t\\t\\tif ( z > maxZ ) maxZ = z;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.min.set( minX, minY, minZ );\\n\\t\\t\\tthis.max.set( maxX, maxY, maxZ );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromPoints: function ( points ) {\\n\\n\\t\\t\\tthis.makeEmpty();\\n\\n\\t\\t\\tfor ( var i = 0, il = points.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.expandByPoint( points[ i ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromCenterAndSize: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function setFromCenterAndSize( center, size ) {\\n\\n\\t\\t\\t\\tvar halfSize = v1.copy( size ).multiplyScalar( 0.5 );\\n\\n\\t\\t\\t\\tthis.min.copy( center ).sub( halfSize );\\n\\t\\t\\t\\tthis.max.copy( center ).add( halfSize );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tsetFromObject: function ( object ) {\\n\\n\\t\\t\\tthis.makeEmpty();\\n\\n\\t\\t\\treturn this.expandByObject( object );\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( box ) {\\n\\n\\t\\t\\tthis.min.copy( box.min );\\n\\t\\t\\tthis.max.copy( box.max );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeEmpty: function () {\\n\\n\\t\\t\\tthis.min.x = this.min.y = this.min.z = + Infinity;\\n\\t\\t\\tthis.max.x = this.max.y = this.max.z = - Infinity;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tisEmpty: function () {\\n\\n\\t\\t\\t// this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes\\n\\n\\t\\t\\treturn ( this.max.x < this.min.x ) || ( this.max.y < this.min.y ) || ( this.max.z < this.min.z );\\n\\n\\t\\t},\\n\\n\\t\\tgetCenter: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\t\\t\\treturn this.isEmpty() ? result.set( 0, 0, 0 ) : result.addVectors( this.min, this.max ).multiplyScalar( 0.5 );\\n\\n\\t\\t},\\n\\n\\t\\tgetSize: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\t\\t\\treturn this.isEmpty() ? result.set( 0, 0, 0 ) : result.subVectors( this.max, this.min );\\n\\n\\t\\t},\\n\\n\\t\\texpandByPoint: function ( point ) {\\n\\n\\t\\t\\tthis.min.min( point );\\n\\t\\t\\tthis.max.max( point );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\texpandByVector: function ( vector ) {\\n\\n\\t\\t\\tthis.min.sub( vector );\\n\\t\\t\\tthis.max.add( vector );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\texpandByScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.min.addScalar( - scalar );\\n\\t\\t\\tthis.max.addScalar( scalar );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\texpandByObject: function () {\\n\\n\\t\\t\\t// Computes the world-axis-aligned bounding box of an object (including its children),\\n\\t\\t\\t// accounting for both the object's, and children's, world transforms\\n\\n\\t\\t\\tvar scope, i, l;\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\tfunction traverse( node ) {\\n\\n\\t\\t\\t\\tvar geometry = node.geometry;\\n\\n\\t\\t\\t\\tif ( geometry !== undefined ) {\\n\\n\\t\\t\\t\\t\\tif ( geometry.isGeometry ) {\\n\\n\\t\\t\\t\\t\\t\\tvar vertices = geometry.vertices;\\n\\n\\t\\t\\t\\t\\t\\tfor ( i = 0, l = vertices.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tv1.copy( vertices[ i ] );\\n\\t\\t\\t\\t\\t\\t\\tv1.applyMatrix4( node.matrixWorld );\\n\\n\\t\\t\\t\\t\\t\\t\\tscope.expandByPoint( v1 );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else if ( geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\t\\t\\tvar attribute = geometry.attributes.position;\\n\\n\\t\\t\\t\\t\\t\\tif ( attribute !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( i = 0, l = attribute.count; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tv1.fromBufferAttribute( attribute, i ).applyMatrix4( node.matrixWorld );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tscope.expandByPoint( v1 );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn function expandByObject( object ) {\\n\\n\\t\\t\\t\\tscope = this;\\n\\n\\t\\t\\t\\tobject.updateMatrixWorld( true );\\n\\n\\t\\t\\t\\tobject.traverse( traverse );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tcontainsPoint: function ( point ) {\\n\\n\\t\\t\\treturn point.x < this.min.x || point.x > this.max.x ||\\n\\t\\t\\t\\tpoint.y < this.min.y || point.y > this.max.y ||\\n\\t\\t\\t\\tpoint.z < this.min.z || point.z > this.max.z ? false : true;\\n\\n\\t\\t},\\n\\n\\t\\tcontainsBox: function ( box ) {\\n\\n\\t\\t\\treturn this.min.x <= box.min.x && box.max.x <= this.max.x &&\\n\\t\\t\\t\\tthis.min.y <= box.min.y && box.max.y <= this.max.y &&\\n\\t\\t\\t\\tthis.min.z <= box.min.z && box.max.z <= this.max.z;\\n\\n\\t\\t},\\n\\n\\t\\tgetParameter: function ( point, optionalTarget ) {\\n\\n\\t\\t\\t// This can potentially have a divide by zero if the box\\n\\t\\t\\t// has a size dimension of 0.\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\treturn result.set(\\n\\t\\t\\t\\t( point.x - this.min.x ) / ( this.max.x - this.min.x ),\\n\\t\\t\\t\\t( point.y - this.min.y ) / ( this.max.y - this.min.y ),\\n\\t\\t\\t\\t( point.z - this.min.z ) / ( this.max.z - this.min.z )\\n\\t\\t\\t);\\n\\n\\t\\t},\\n\\n\\t\\tintersectsBox: function ( box ) {\\n\\n\\t\\t\\t// using 6 splitting planes to rule out intersections.\\n\\t\\t\\treturn box.max.x < this.min.x || box.min.x > this.max.x ||\\n\\t\\t\\t\\tbox.max.y < this.min.y || box.min.y > this.max.y ||\\n\\t\\t\\t\\tbox.max.z < this.min.z || box.min.z > this.max.z ? false : true;\\n\\n\\t\\t},\\n\\n\\t\\tintersectsSphere: ( function () {\\n\\n\\t\\t\\tvar closestPoint = new Vector3();\\n\\n\\t\\t\\treturn function intersectsSphere( sphere ) {\\n\\n\\t\\t\\t\\t// Find the point on the AABB closest to the sphere center.\\n\\t\\t\\t\\tthis.clampPoint( sphere.center, closestPoint );\\n\\n\\t\\t\\t\\t// If that point is inside the sphere, the AABB and sphere intersect.\\n\\t\\t\\t\\treturn closestPoint.distanceToSquared( sphere.center ) <= ( sphere.radius * sphere.radius );\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )(),\\n\\n\\t\\tintersectsPlane: function ( plane ) {\\n\\n\\t\\t\\t// We compute the minimum and maximum dot product values. If those values\\n\\t\\t\\t// are on the same side (back or front) of the plane, then there is no intersection.\\n\\n\\t\\t\\tvar min, max;\\n\\n\\t\\t\\tif ( plane.normal.x > 0 ) {\\n\\n\\t\\t\\t\\tmin = plane.normal.x * this.min.x;\\n\\t\\t\\t\\tmax = plane.normal.x * this.max.x;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tmin = plane.normal.x * this.max.x;\\n\\t\\t\\t\\tmax = plane.normal.x * this.min.x;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( plane.normal.y > 0 ) {\\n\\n\\t\\t\\t\\tmin += plane.normal.y * this.min.y;\\n\\t\\t\\t\\tmax += plane.normal.y * this.max.y;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tmin += plane.normal.y * this.max.y;\\n\\t\\t\\t\\tmax += plane.normal.y * this.min.y;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( plane.normal.z > 0 ) {\\n\\n\\t\\t\\t\\tmin += plane.normal.z * this.min.z;\\n\\t\\t\\t\\tmax += plane.normal.z * this.max.z;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tmin += plane.normal.z * this.max.z;\\n\\t\\t\\t\\tmax += plane.normal.z * this.min.z;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn ( min <= plane.constant && max >= plane.constant );\\n\\n\\t\\t},\\n\\n\\t\\tclampPoint: function ( point, optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\t\\t\\treturn result.copy( point ).clamp( this.min, this.max );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToPoint: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function distanceToPoint( point ) {\\n\\n\\t\\t\\t\\tvar clampedPoint = v1.copy( point ).clamp( this.min, this.max );\\n\\t\\t\\t\\treturn clampedPoint.sub( point ).length();\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tgetBoundingSphere: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function getBoundingSphere( optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Sphere();\\n\\n\\t\\t\\t\\tthis.getCenter( result.center );\\n\\n\\t\\t\\t\\tresult.radius = this.getSize( v1 ).length() * 0.5;\\n\\n\\t\\t\\t\\treturn result;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tintersect: function ( box ) {\\n\\n\\t\\t\\tthis.min.max( box.min );\\n\\t\\t\\tthis.max.min( box.max );\\n\\n\\t\\t\\t// ensure that if there is no overlap, the result is fully empty, not slightly empty with non-inf/+inf values that will cause subsequence intersects to erroneously return valid values.\\n\\t\\t\\tif ( this.isEmpty() ) this.makeEmpty();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tunion: function ( box ) {\\n\\n\\t\\t\\tthis.min.min( box.min );\\n\\t\\t\\tthis.max.max( box.max );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tapplyMatrix4: function () {\\n\\n\\t\\t\\tvar points = [\\n\\t\\t\\t\\tnew Vector3(),\\n\\t\\t\\t\\tnew Vector3(),\\n\\t\\t\\t\\tnew Vector3(),\\n\\t\\t\\t\\tnew Vector3(),\\n\\t\\t\\t\\tnew Vector3(),\\n\\t\\t\\t\\tnew Vector3(),\\n\\t\\t\\t\\tnew Vector3(),\\n\\t\\t\\t\\tnew Vector3()\\n\\t\\t\\t];\\n\\n\\t\\t\\treturn function applyMatrix4( matrix ) {\\n\\n\\t\\t\\t\\t// transform of empty box is an empty box.\\n\\t\\t\\t\\tif ( this.isEmpty() ) return this;\\n\\n\\t\\t\\t\\t// NOTE: I am using a binary pattern to specify all 2^3 combinations below\\n\\t\\t\\t\\tpoints[ 0 ].set( this.min.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 000\\n\\t\\t\\t\\tpoints[ 1 ].set( this.min.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 001\\n\\t\\t\\t\\tpoints[ 2 ].set( this.min.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 010\\n\\t\\t\\t\\tpoints[ 3 ].set( this.min.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 011\\n\\t\\t\\t\\tpoints[ 4 ].set( this.max.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 100\\n\\t\\t\\t\\tpoints[ 5 ].set( this.max.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 101\\n\\t\\t\\t\\tpoints[ 6 ].set( this.max.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 110\\n\\t\\t\\t\\tpoints[ 7 ].set( this.max.x, this.max.y, this.max.z ).applyMatrix4( matrix );\\t// 111\\n\\n\\t\\t\\t\\tthis.setFromPoints( points );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttranslate: function ( offset ) {\\n\\n\\t\\t\\tthis.min.add( offset );\\n\\t\\t\\tthis.max.add( offset );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( box ) {\\n\\n\\t\\t\\treturn box.min.equals( this.min ) && box.max.equals( this.max );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author bhouston / http://clara.io\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Sphere( center, radius ) {\\n\\n\\t\\tthis.center = ( center !== undefined ) ? center : new Vector3();\\n\\t\\tthis.radius = ( radius !== undefined ) ? radius : 0;\\n\\n\\t}\\n\\n\\tObject.assign( Sphere.prototype, {\\n\\n\\t\\tset: function ( center, radius ) {\\n\\n\\t\\t\\tthis.center.copy( center );\\n\\t\\t\\tthis.radius = radius;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromPoints: function () {\\n\\n\\t\\t\\tvar box = new Box3();\\n\\n\\t\\t\\treturn function setFromPoints( points, optionalCenter ) {\\n\\n\\t\\t\\t\\tvar center = this.center;\\n\\n\\t\\t\\t\\tif ( optionalCenter !== undefined ) {\\n\\n\\t\\t\\t\\t\\tcenter.copy( optionalCenter );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tbox.setFromPoints( points ).getCenter( center );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar maxRadiusSq = 0;\\n\\n\\t\\t\\t\\tfor ( var i = 0, il = points.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tmaxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( points[ i ] ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.radius = Math.sqrt( maxRadiusSq );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( sphere ) {\\n\\n\\t\\t\\tthis.center.copy( sphere.center );\\n\\t\\t\\tthis.radius = sphere.radius;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tempty: function () {\\n\\n\\t\\t\\treturn ( this.radius <= 0 );\\n\\n\\t\\t},\\n\\n\\t\\tcontainsPoint: function ( point ) {\\n\\n\\t\\t\\treturn ( point.distanceToSquared( this.center ) <= ( this.radius * this.radius ) );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToPoint: function ( point ) {\\n\\n\\t\\t\\treturn ( point.distanceTo( this.center ) - this.radius );\\n\\n\\t\\t},\\n\\n\\t\\tintersectsSphere: function ( sphere ) {\\n\\n\\t\\t\\tvar radiusSum = this.radius + sphere.radius;\\n\\n\\t\\t\\treturn sphere.center.distanceToSquared( this.center ) <= ( radiusSum * radiusSum );\\n\\n\\t\\t},\\n\\n\\t\\tintersectsBox: function ( box ) {\\n\\n\\t\\t\\treturn box.intersectsSphere( this );\\n\\n\\t\\t},\\n\\n\\t\\tintersectsPlane: function ( plane ) {\\n\\n\\t\\t\\treturn Math.abs( plane.distanceToPoint( this.center ) ) <= this.radius;\\n\\n\\t\\t},\\n\\n\\t\\tclampPoint: function ( point, optionalTarget ) {\\n\\n\\t\\t\\tvar deltaLengthSq = this.center.distanceToSquared( point );\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\tresult.copy( point );\\n\\n\\t\\t\\tif ( deltaLengthSq > ( this.radius * this.radius ) ) {\\n\\n\\t\\t\\t\\tresult.sub( this.center ).normalize();\\n\\t\\t\\t\\tresult.multiplyScalar( this.radius ).add( this.center );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn result;\\n\\n\\t\\t},\\n\\n\\t\\tgetBoundingBox: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar box = optionalTarget || new Box3();\\n\\n\\t\\t\\tbox.set( this.center, this.center );\\n\\t\\t\\tbox.expandByScalar( this.radius );\\n\\n\\t\\t\\treturn box;\\n\\n\\t\\t},\\n\\n\\t\\tapplyMatrix4: function ( matrix ) {\\n\\n\\t\\t\\tthis.center.applyMatrix4( matrix );\\n\\t\\t\\tthis.radius = this.radius * matrix.getMaxScaleOnAxis();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttranslate: function ( offset ) {\\n\\n\\t\\t\\tthis.center.add( offset );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( sphere ) {\\n\\n\\t\\t\\treturn sphere.center.equals( this.center ) && ( sphere.radius === this.radius );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author bhouston / http://clara.io\\n\\t */\\n\\n\\tfunction Plane( normal, constant ) {\\n\\n\\t\\t// normal is assumed to be normalized\\n\\n\\t\\tthis.normal = ( normal !== undefined ) ? normal : new Vector3( 1, 0, 0 );\\n\\t\\tthis.constant = ( constant !== undefined ) ? constant : 0;\\n\\n\\t}\\n\\n\\tObject.assign( Plane.prototype, {\\n\\n\\t\\tset: function ( normal, constant ) {\\n\\n\\t\\t\\tthis.normal.copy( normal );\\n\\t\\t\\tthis.constant = constant;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetComponents: function ( x, y, z, w ) {\\n\\n\\t\\t\\tthis.normal.set( x, y, z );\\n\\t\\t\\tthis.constant = w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromNormalAndCoplanarPoint: function ( normal, point ) {\\n\\n\\t\\t\\tthis.normal.copy( normal );\\n\\t\\t\\tthis.constant = - point.dot( this.normal );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromCoplanarPoints: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\t\\t\\tvar v2 = new Vector3();\\n\\n\\t\\t\\treturn function setFromCoplanarPoints( a, b, c ) {\\n\\n\\t\\t\\t\\tvar normal = v1.subVectors( c, b ).cross( v2.subVectors( a, b ) ).normalize();\\n\\n\\t\\t\\t\\t// Q: should an error be thrown if normal is zero (e.g. degenerate plane)?\\n\\n\\t\\t\\t\\tthis.setFromNormalAndCoplanarPoint( normal, a );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( plane ) {\\n\\n\\t\\t\\tthis.normal.copy( plane.normal );\\n\\t\\t\\tthis.constant = plane.constant;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tnormalize: function () {\\n\\n\\t\\t\\t// Note: will lead to a divide by zero if the plane is invalid.\\n\\n\\t\\t\\tvar inverseNormalLength = 1.0 / this.normal.length();\\n\\t\\t\\tthis.normal.multiplyScalar( inverseNormalLength );\\n\\t\\t\\tthis.constant *= inverseNormalLength;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tnegate: function () {\\n\\n\\t\\t\\tthis.constant *= - 1;\\n\\t\\t\\tthis.normal.negate();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToPoint: function ( point ) {\\n\\n\\t\\t\\treturn this.normal.dot( point ) + this.constant;\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToSphere: function ( sphere ) {\\n\\n\\t\\t\\treturn this.distanceToPoint( sphere.center ) - sphere.radius;\\n\\n\\t\\t},\\n\\n\\t\\tprojectPoint: function ( point, optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\treturn result.copy( this.normal ).multiplyScalar( - this.distanceToPoint( point ) ).add( point );\\n\\n\\t\\t},\\n\\n\\t\\tintersectLine: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function intersectLine( line, optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\t\\tvar direction = line.delta( v1 );\\n\\n\\t\\t\\t\\tvar denominator = this.normal.dot( direction );\\n\\n\\t\\t\\t\\tif ( denominator === 0 ) {\\n\\n\\t\\t\\t\\t\\t// line is coplanar, return origin\\n\\t\\t\\t\\t\\tif ( this.distanceToPoint( line.start ) === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\treturn result.copy( line.start );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t// Unsure if this is the correct method to handle this case.\\n\\t\\t\\t\\t\\treturn undefined;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar t = - ( line.start.dot( this.normal ) + this.constant ) / denominator;\\n\\n\\t\\t\\t\\tif ( t < 0 || t > 1 ) {\\n\\n\\t\\t\\t\\t\\treturn undefined;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn result.copy( direction ).multiplyScalar( t ).add( line.start );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tintersectsLine: function ( line ) {\\n\\n\\t\\t\\t// Note: this tests if a line intersects the plane, not whether it (or its end-points) are coplanar with it.\\n\\n\\t\\t\\tvar startSign = this.distanceToPoint( line.start );\\n\\t\\t\\tvar endSign = this.distanceToPoint( line.end );\\n\\n\\t\\t\\treturn ( startSign < 0 && endSign > 0 ) || ( endSign < 0 && startSign > 0 );\\n\\n\\t\\t},\\n\\n\\t\\tintersectsBox: function ( box ) {\\n\\n\\t\\t\\treturn box.intersectsPlane( this );\\n\\n\\t\\t},\\n\\n\\t\\tintersectsSphere: function ( sphere ) {\\n\\n\\t\\t\\treturn sphere.intersectsPlane( this );\\n\\n\\t\\t},\\n\\n\\t\\tcoplanarPoint: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\treturn result.copy( this.normal ).multiplyScalar( - this.constant );\\n\\n\\t\\t},\\n\\n\\t\\tapplyMatrix4: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\t\\t\\tvar m1 = new Matrix3();\\n\\n\\t\\t\\treturn function applyMatrix4( matrix, optionalNormalMatrix ) {\\n\\n\\t\\t\\t\\tvar normalMatrix = optionalNormalMatrix || m1.getNormalMatrix( matrix );\\n\\n\\t\\t\\t\\tvar referencePoint = this.coplanarPoint( v1 ).applyMatrix4( matrix );\\n\\n\\t\\t\\t\\tvar normal = this.normal.applyMatrix3( normalMatrix ).normalize();\\n\\n\\t\\t\\t\\tthis.constant = - referencePoint.dot( normal );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttranslate: function ( offset ) {\\n\\n\\t\\t\\tthis.constant -= offset.dot( this.normal );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( plane ) {\\n\\n\\t\\t\\treturn plane.normal.equals( this.normal ) && ( plane.constant === this.constant );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author bhouston / http://clara.io\\n\\t */\\n\\n\\tfunction Frustum( p0, p1, p2, p3, p4, p5 ) {\\n\\n\\t\\tthis.planes = [\\n\\n\\t\\t\\t( p0 !== undefined ) ? p0 : new Plane(),\\n\\t\\t\\t( p1 !== undefined ) ? p1 : new Plane(),\\n\\t\\t\\t( p2 !== undefined ) ? p2 : new Plane(),\\n\\t\\t\\t( p3 !== undefined ) ? p3 : new Plane(),\\n\\t\\t\\t( p4 !== undefined ) ? p4 : new Plane(),\\n\\t\\t\\t( p5 !== undefined ) ? p5 : new Plane()\\n\\n\\t\\t];\\n\\n\\t}\\n\\n\\tObject.assign( Frustum.prototype, {\\n\\n\\t\\tset: function ( p0, p1, p2, p3, p4, p5 ) {\\n\\n\\t\\t\\tvar planes = this.planes;\\n\\n\\t\\t\\tplanes[ 0 ].copy( p0 );\\n\\t\\t\\tplanes[ 1 ].copy( p1 );\\n\\t\\t\\tplanes[ 2 ].copy( p2 );\\n\\t\\t\\tplanes[ 3 ].copy( p3 );\\n\\t\\t\\tplanes[ 4 ].copy( p4 );\\n\\t\\t\\tplanes[ 5 ].copy( p5 );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( frustum ) {\\n\\n\\t\\t\\tvar planes = this.planes;\\n\\n\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\tplanes[ i ].copy( frustum.planes[ i ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromMatrix: function ( m ) {\\n\\n\\t\\t\\tvar planes = this.planes;\\n\\t\\t\\tvar me = m.elements;\\n\\t\\t\\tvar me0 = me[ 0 ], me1 = me[ 1 ], me2 = me[ 2 ], me3 = me[ 3 ];\\n\\t\\t\\tvar me4 = me[ 4 ], me5 = me[ 5 ], me6 = me[ 6 ], me7 = me[ 7 ];\\n\\t\\t\\tvar me8 = me[ 8 ], me9 = me[ 9 ], me10 = me[ 10 ], me11 = me[ 11 ];\\n\\t\\t\\tvar me12 = me[ 12 ], me13 = me[ 13 ], me14 = me[ 14 ], me15 = me[ 15 ];\\n\\n\\t\\t\\tplanes[ 0 ].setComponents( me3 - me0, me7 - me4, me11 - me8, me15 - me12 ).normalize();\\n\\t\\t\\tplanes[ 1 ].setComponents( me3 + me0, me7 + me4, me11 + me8, me15 + me12 ).normalize();\\n\\t\\t\\tplanes[ 2 ].setComponents( me3 + me1, me7 + me5, me11 + me9, me15 + me13 ).normalize();\\n\\t\\t\\tplanes[ 3 ].setComponents( me3 - me1, me7 - me5, me11 - me9, me15 - me13 ).normalize();\\n\\t\\t\\tplanes[ 4 ].setComponents( me3 - me2, me7 - me6, me11 - me10, me15 - me14 ).normalize();\\n\\t\\t\\tplanes[ 5 ].setComponents( me3 + me2, me7 + me6, me11 + me10, me15 + me14 ).normalize();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tintersectsObject: function () {\\n\\n\\t\\t\\tvar sphere = new Sphere();\\n\\n\\t\\t\\treturn function intersectsObject( object ) {\\n\\n\\t\\t\\t\\tvar geometry = object.geometry;\\n\\n\\t\\t\\t\\tif ( geometry.boundingSphere === null )\\n\\t\\t\\t\\t\\tgeometry.computeBoundingSphere();\\n\\n\\t\\t\\t\\tsphere.copy( geometry.boundingSphere )\\n\\t\\t\\t\\t\\t.applyMatrix4( object.matrixWorld );\\n\\n\\t\\t\\t\\treturn this.intersectsSphere( sphere );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tintersectsSprite: function () {\\n\\n\\t\\t\\tvar sphere = new Sphere();\\n\\n\\t\\t\\treturn function intersectsSprite( sprite ) {\\n\\n\\t\\t\\t\\tsphere.center.set( 0, 0, 0 );\\n\\t\\t\\t\\tsphere.radius = 0.7071067811865476;\\n\\t\\t\\t\\tsphere.applyMatrix4( sprite.matrixWorld );\\n\\n\\t\\t\\t\\treturn this.intersectsSphere( sphere );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tintersectsSphere: function ( sphere ) {\\n\\n\\t\\t\\tvar planes = this.planes;\\n\\t\\t\\tvar center = sphere.center;\\n\\t\\t\\tvar negRadius = - sphere.radius;\\n\\n\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\tvar distance = planes[ i ].distanceToPoint( center );\\n\\n\\t\\t\\t\\tif ( distance < negRadius ) {\\n\\n\\t\\t\\t\\t\\treturn false;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn true;\\n\\n\\t\\t},\\n\\n\\t\\tintersectsBox: function () {\\n\\n\\t\\t\\tvar p1 = new Vector3(),\\n\\t\\t\\t\\tp2 = new Vector3();\\n\\n\\t\\t\\treturn function intersectsBox( box ) {\\n\\n\\t\\t\\t\\tvar planes = this.planes;\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar plane = planes[ i ];\\n\\n\\t\\t\\t\\t\\tp1.x = plane.normal.x > 0 ? box.min.x : box.max.x;\\n\\t\\t\\t\\t\\tp2.x = plane.normal.x > 0 ? box.max.x : box.min.x;\\n\\t\\t\\t\\t\\tp1.y = plane.normal.y > 0 ? box.min.y : box.max.y;\\n\\t\\t\\t\\t\\tp2.y = plane.normal.y > 0 ? box.max.y : box.min.y;\\n\\t\\t\\t\\t\\tp1.z = plane.normal.z > 0 ? box.min.z : box.max.z;\\n\\t\\t\\t\\t\\tp2.z = plane.normal.z > 0 ? box.max.z : box.min.z;\\n\\n\\t\\t\\t\\t\\tvar d1 = plane.distanceToPoint( p1 );\\n\\t\\t\\t\\t\\tvar d2 = plane.distanceToPoint( p2 );\\n\\n\\t\\t\\t\\t\\t// if both outside plane, no intersection\\n\\n\\t\\t\\t\\t\\tif ( d1 < 0 && d2 < 0 ) {\\n\\n\\t\\t\\t\\t\\t\\treturn false;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn true;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tcontainsPoint: function ( point ) {\\n\\n\\t\\t\\tvar planes = this.planes;\\n\\n\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\tif ( planes[ i ].distanceToPoint( point ) < 0 ) {\\n\\n\\t\\t\\t\\t\\treturn false;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn true;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLShadowMap( _renderer, _objects, maxTextureSize ) {\\n\\n\\t\\tvar _frustum = new Frustum(),\\n\\t\\t\\t_projScreenMatrix = new Matrix4(),\\n\\n\\t\\t\\t_shadowMapSize = new Vector2(),\\n\\t\\t\\t_maxShadowMapSize = new Vector2( maxTextureSize, maxTextureSize ),\\n\\n\\t\\t\\t_lookTarget = new Vector3(),\\n\\t\\t\\t_lightPositionWorld = new Vector3(),\\n\\n\\t\\t\\t_MorphingFlag = 1,\\n\\t\\t\\t_SkinningFlag = 2,\\n\\n\\t\\t\\t_NumberOfMaterialVariants = ( _MorphingFlag | _SkinningFlag ) + 1,\\n\\n\\t\\t\\t_depthMaterials = new Array( _NumberOfMaterialVariants ),\\n\\t\\t\\t_distanceMaterials = new Array( _NumberOfMaterialVariants ),\\n\\n\\t\\t\\t_materialCache = {};\\n\\n\\t\\tvar cubeDirections = [\\n\\t\\t\\tnew Vector3( 1, 0, 0 ), new Vector3( - 1, 0, 0 ), new Vector3( 0, 0, 1 ),\\n\\t\\t\\tnew Vector3( 0, 0, - 1 ), new Vector3( 0, 1, 0 ), new Vector3( 0, - 1, 0 )\\n\\t\\t];\\n\\n\\t\\tvar cubeUps = [\\n\\t\\t\\tnew Vector3( 0, 1, 0 ), new Vector3( 0, 1, 0 ), new Vector3( 0, 1, 0 ),\\n\\t\\t\\tnew Vector3( 0, 1, 0 ), new Vector3( 0, 0, 1 ),\\tnew Vector3( 0, 0, - 1 )\\n\\t\\t];\\n\\n\\t\\tvar cube2DViewPorts = [\\n\\t\\t\\tnew Vector4(), new Vector4(), new Vector4(),\\n\\t\\t\\tnew Vector4(), new Vector4(), new Vector4()\\n\\t\\t];\\n\\n\\t\\t// init\\n\\n\\t\\tfor ( var i = 0; i !== _NumberOfMaterialVariants; ++ i ) {\\n\\n\\t\\t\\tvar useMorphing = ( i & _MorphingFlag ) !== 0;\\n\\t\\t\\tvar useSkinning = ( i & _SkinningFlag ) !== 0;\\n\\n\\t\\t\\tvar depthMaterial = new MeshDepthMaterial( {\\n\\n\\t\\t\\t\\tdepthPacking: RGBADepthPacking,\\n\\n\\t\\t\\t\\tmorphTargets: useMorphing,\\n\\t\\t\\t\\tskinning: useSkinning\\n\\n\\t\\t\\t} );\\n\\n\\t\\t\\t_depthMaterials[ i ] = depthMaterial;\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar distanceMaterial = new MeshDistanceMaterial( {\\n\\n\\t\\t\\t\\tmorphTargets: useMorphing,\\n\\t\\t\\t\\tskinning: useSkinning\\n\\n\\t\\t\\t} );\\n\\n\\t\\t\\t_distanceMaterials[ i ] = distanceMaterial;\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tvar scope = this;\\n\\n\\t\\tthis.enabled = false;\\n\\n\\t\\tthis.autoUpdate = true;\\n\\t\\tthis.needsUpdate = false;\\n\\n\\t\\tthis.type = PCFShadowMap;\\n\\n\\t\\tthis.renderReverseSided = true;\\n\\t\\tthis.renderSingleSided = true;\\n\\n\\t\\tthis.render = function ( lights, scene, camera ) {\\n\\n\\t\\t\\tif ( scope.enabled === false ) return;\\n\\t\\t\\tif ( scope.autoUpdate === false && scope.needsUpdate === false ) return;\\n\\n\\t\\t\\tif ( lights.length === 0 ) return;\\n\\n\\t\\t\\t// TODO Clean up (needed in case of contextlost)\\n\\t\\t\\tvar _gl = _renderer.context;\\n\\t\\t\\tvar _state = _renderer.state;\\n\\n\\t\\t\\t// Set GL state for depth map.\\n\\t\\t\\t_state.disable( _gl.BLEND );\\n\\t\\t\\t_state.buffers.color.setClear( 1, 1, 1, 1 );\\n\\t\\t\\t_state.buffers.depth.setTest( true );\\n\\t\\t\\t_state.setScissorTest( false );\\n\\n\\t\\t\\t// render depth map\\n\\n\\t\\t\\tvar faceCount;\\n\\n\\t\\t\\tfor ( var i = 0, il = lights.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar light = lights[ i ];\\n\\t\\t\\t\\tvar shadow = light.shadow;\\n\\t\\t\\t\\tvar isPointLight = light && light.isPointLight;\\n\\n\\t\\t\\t\\tif ( shadow === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLShadowMap:', light, 'has no shadow.' );\\n\\t\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar shadowCamera = shadow.camera;\\n\\n\\t\\t\\t\\t_shadowMapSize.copy( shadow.mapSize );\\n\\t\\t\\t\\t_shadowMapSize.min( _maxShadowMapSize );\\n\\n\\t\\t\\t\\tif ( isPointLight ) {\\n\\n\\t\\t\\t\\t\\tvar vpWidth = _shadowMapSize.x;\\n\\t\\t\\t\\t\\tvar vpHeight = _shadowMapSize.y;\\n\\n\\t\\t\\t\\t\\t// These viewports map a cube-map onto a 2D texture with the\\n\\t\\t\\t\\t\\t// following orientation:\\n\\t\\t\\t\\t\\t//\\n\\t\\t\\t\\t\\t// xzXZ\\n\\t\\t\\t\\t\\t// y Y\\n\\t\\t\\t\\t\\t//\\n\\t\\t\\t\\t\\t// X - Positive x direction\\n\\t\\t\\t\\t\\t// x - Negative x direction\\n\\t\\t\\t\\t\\t// Y - Positive y direction\\n\\t\\t\\t\\t\\t// y - Negative y direction\\n\\t\\t\\t\\t\\t// Z - Positive z direction\\n\\t\\t\\t\\t\\t// z - Negative z direction\\n\\n\\t\\t\\t\\t\\t// positive X\\n\\t\\t\\t\\t\\tcube2DViewPorts[ 0 ].set( vpWidth * 2, vpHeight, vpWidth, vpHeight );\\n\\t\\t\\t\\t\\t// negative X\\n\\t\\t\\t\\t\\tcube2DViewPorts[ 1 ].set( 0, vpHeight, vpWidth, vpHeight );\\n\\t\\t\\t\\t\\t// positive Z\\n\\t\\t\\t\\t\\tcube2DViewPorts[ 2 ].set( vpWidth * 3, vpHeight, vpWidth, vpHeight );\\n\\t\\t\\t\\t\\t// negative Z\\n\\t\\t\\t\\t\\tcube2DViewPorts[ 3 ].set( vpWidth, vpHeight, vpWidth, vpHeight );\\n\\t\\t\\t\\t\\t// positive Y\\n\\t\\t\\t\\t\\tcube2DViewPorts[ 4 ].set( vpWidth * 3, 0, vpWidth, vpHeight );\\n\\t\\t\\t\\t\\t// negative Y\\n\\t\\t\\t\\t\\tcube2DViewPorts[ 5 ].set( vpWidth, 0, vpWidth, vpHeight );\\n\\n\\t\\t\\t\\t\\t_shadowMapSize.x *= 4.0;\\n\\t\\t\\t\\t\\t_shadowMapSize.y *= 2.0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( shadow.map === null ) {\\n\\n\\t\\t\\t\\t\\tvar pars = { minFilter: NearestFilter, magFilter: NearestFilter, format: RGBAFormat };\\n\\n\\t\\t\\t\\t\\tshadow.map = new WebGLRenderTarget( _shadowMapSize.x, _shadowMapSize.y, pars );\\n\\t\\t\\t\\t\\tshadow.map.texture.name = light.name + \\\".shadowMap\\\";\\n\\n\\t\\t\\t\\t\\tshadowCamera.updateProjectionMatrix();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( shadow.isSpotLightShadow ) {\\n\\n\\t\\t\\t\\t\\tshadow.update( light );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar shadowMap = shadow.map;\\n\\t\\t\\t\\tvar shadowMatrix = shadow.matrix;\\n\\n\\t\\t\\t\\t_lightPositionWorld.setFromMatrixPosition( light.matrixWorld );\\n\\t\\t\\t\\tshadowCamera.position.copy( _lightPositionWorld );\\n\\n\\t\\t\\t\\tif ( isPointLight ) {\\n\\n\\t\\t\\t\\t\\tfaceCount = 6;\\n\\n\\t\\t\\t\\t\\t// for point lights we set the shadow matrix to be a translation-only matrix\\n\\t\\t\\t\\t\\t// equal to inverse of the light's position\\n\\n\\t\\t\\t\\t\\tshadowMatrix.makeTranslation( - _lightPositionWorld.x, - _lightPositionWorld.y, - _lightPositionWorld.z );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tfaceCount = 1;\\n\\n\\t\\t\\t\\t\\t_lookTarget.setFromMatrixPosition( light.target.matrixWorld );\\n\\t\\t\\t\\t\\tshadowCamera.lookAt( _lookTarget );\\n\\t\\t\\t\\t\\tshadowCamera.updateMatrixWorld();\\n\\n\\t\\t\\t\\t\\t// compute shadow matrix\\n\\n\\t\\t\\t\\t\\tshadowMatrix.set(\\n\\t\\t\\t\\t\\t\\t0.5, 0.0, 0.0, 0.5,\\n\\t\\t\\t\\t\\t\\t0.0, 0.5, 0.0, 0.5,\\n\\t\\t\\t\\t\\t\\t0.0, 0.0, 0.5, 0.5,\\n\\t\\t\\t\\t\\t\\t0.0, 0.0, 0.0, 1.0\\n\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\tshadowMatrix.multiply( shadowCamera.projectionMatrix );\\n\\t\\t\\t\\t\\tshadowMatrix.multiply( shadowCamera.matrixWorldInverse );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t_renderer.setRenderTarget( shadowMap );\\n\\t\\t\\t\\t_renderer.clear();\\n\\n\\t\\t\\t\\t// render shadow map for each cube face (if omni-directional) or\\n\\t\\t\\t\\t// run a single pass if not\\n\\n\\t\\t\\t\\tfor ( var face = 0; face < faceCount; face ++ ) {\\n\\n\\t\\t\\t\\t\\tif ( isPointLight ) {\\n\\n\\t\\t\\t\\t\\t\\t_lookTarget.copy( shadowCamera.position );\\n\\t\\t\\t\\t\\t\\t_lookTarget.add( cubeDirections[ face ] );\\n\\t\\t\\t\\t\\t\\tshadowCamera.up.copy( cubeUps[ face ] );\\n\\t\\t\\t\\t\\t\\tshadowCamera.lookAt( _lookTarget );\\n\\t\\t\\t\\t\\t\\tshadowCamera.updateMatrixWorld();\\n\\n\\t\\t\\t\\t\\t\\tvar vpDimensions = cube2DViewPorts[ face ];\\n\\t\\t\\t\\t\\t\\t_state.viewport( vpDimensions );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t// update camera matrices and frustum\\n\\n\\t\\t\\t\\t\\t_projScreenMatrix.multiplyMatrices( shadowCamera.projectionMatrix, shadowCamera.matrixWorldInverse );\\n\\t\\t\\t\\t\\t_frustum.setFromMatrix( _projScreenMatrix );\\n\\n\\t\\t\\t\\t\\t// set object matrices & frustum culling\\n\\n\\t\\t\\t\\t\\trenderObject( scene, camera, shadowCamera, isPointLight );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tscope.needsUpdate = false;\\n\\n\\t\\t};\\n\\n\\t\\tfunction getDepthMaterial( object, material, isPointLight, lightPositionWorld, shadowCameraNear, shadowCameraFar ) {\\n\\n\\t\\t\\tvar geometry = object.geometry;\\n\\n\\t\\t\\tvar result = null;\\n\\n\\t\\t\\tvar materialVariants = _depthMaterials;\\n\\t\\t\\tvar customMaterial = object.customDepthMaterial;\\n\\n\\t\\t\\tif ( isPointLight ) {\\n\\n\\t\\t\\t\\tmaterialVariants = _distanceMaterials;\\n\\t\\t\\t\\tcustomMaterial = object.customDistanceMaterial;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( ! customMaterial ) {\\n\\n\\t\\t\\t\\tvar useMorphing = false;\\n\\n\\t\\t\\t\\tif ( material.morphTargets ) {\\n\\n\\t\\t\\t\\t\\tif ( geometry && geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\t\\t\\tuseMorphing = geometry.morphAttributes && geometry.morphAttributes.position && geometry.morphAttributes.position.length > 0;\\n\\n\\t\\t\\t\\t\\t} else if ( geometry && geometry.isGeometry ) {\\n\\n\\t\\t\\t\\t\\t\\tuseMorphing = geometry.morphTargets && geometry.morphTargets.length > 0;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( object.isSkinnedMesh && material.skinning === false ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLShadowMap: THREE.SkinnedMesh with material.skinning set to false:', object );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar useSkinning = object.isSkinnedMesh && material.skinning;\\n\\n\\t\\t\\t\\tvar variantIndex = 0;\\n\\n\\t\\t\\t\\tif ( useMorphing ) variantIndex |= _MorphingFlag;\\n\\t\\t\\t\\tif ( useSkinning ) variantIndex |= _SkinningFlag;\\n\\n\\t\\t\\t\\tresult = materialVariants[ variantIndex ];\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tresult = customMaterial;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( _renderer.localClippingEnabled &&\\n\\t\\t\\t\\t\\tmaterial.clipShadows === true &&\\n\\t\\t\\t\\t\\tmaterial.clippingPlanes.length !== 0 ) {\\n\\n\\t\\t\\t\\t// in this case we need a unique material instance reflecting the\\n\\t\\t\\t\\t// appropriate state\\n\\n\\t\\t\\t\\tvar keyA = result.uuid, keyB = material.uuid;\\n\\n\\t\\t\\t\\tvar materialsForVariant = _materialCache[ keyA ];\\n\\n\\t\\t\\t\\tif ( materialsForVariant === undefined ) {\\n\\n\\t\\t\\t\\t\\tmaterialsForVariant = {};\\n\\t\\t\\t\\t\\t_materialCache[ keyA ] = materialsForVariant;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar cachedMaterial = materialsForVariant[ keyB ];\\n\\n\\t\\t\\t\\tif ( cachedMaterial === undefined ) {\\n\\n\\t\\t\\t\\t\\tcachedMaterial = result.clone();\\n\\t\\t\\t\\t\\tmaterialsForVariant[ keyB ] = cachedMaterial;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tresult = cachedMaterial;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tresult.visible = material.visible;\\n\\t\\t\\tresult.wireframe = material.wireframe;\\n\\n\\t\\t\\tvar side = material.side;\\n\\n\\t\\t\\tif ( scope.renderSingleSided && side == DoubleSide ) {\\n\\n\\t\\t\\t\\tside = FrontSide;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( scope.renderReverseSided ) {\\n\\n\\t\\t\\t\\tif ( side === FrontSide ) side = BackSide;\\n\\t\\t\\t\\telse if ( side === BackSide ) side = FrontSide;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tresult.side = side;\\n\\n\\t\\t\\tresult.clipShadows = material.clipShadows;\\n\\t\\t\\tresult.clippingPlanes = material.clippingPlanes;\\n\\t\\t\\tresult.clipIntersection = material.clipIntersection;\\n\\n\\t\\t\\tresult.wireframeLinewidth = material.wireframeLinewidth;\\n\\t\\t\\tresult.linewidth = material.linewidth;\\n\\n\\t\\t\\tif ( isPointLight && result.isMeshDistanceMaterial ) {\\n\\n\\t\\t\\t\\tresult.referencePosition.copy( lightPositionWorld );\\n\\t\\t\\t\\tresult.nearDistance = shadowCameraNear;\\n\\t\\t\\t\\tresult.farDistance = shadowCameraFar;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn result;\\n\\n\\t\\t}\\n\\n\\t\\tfunction renderObject( object, camera, shadowCamera, isPointLight ) {\\n\\n\\t\\t\\tif ( object.visible === false ) return;\\n\\n\\t\\t\\tvar visible = object.layers.test( camera.layers );\\n\\n\\t\\t\\tif ( visible && ( object.isMesh || object.isLine || object.isPoints ) ) {\\n\\n\\t\\t\\t\\tif ( object.castShadow && ( ! object.frustumCulled || _frustum.intersectsObject( object ) ) ) {\\n\\n\\t\\t\\t\\t\\tobject.modelViewMatrix.multiplyMatrices( shadowCamera.matrixWorldInverse, object.matrixWorld );\\n\\n\\t\\t\\t\\t\\tvar geometry = _objects.update( object );\\n\\t\\t\\t\\t\\tvar material = object.material;\\n\\n\\t\\t\\t\\t\\tif ( Array.isArray( material ) ) {\\n\\n\\t\\t\\t\\t\\t\\tvar groups = geometry.groups;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var k = 0, kl = groups.length; k < kl; k ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar group = groups[ k ];\\n\\t\\t\\t\\t\\t\\t\\tvar groupMaterial = material[ group.materialIndex ];\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( groupMaterial && groupMaterial.visible ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tvar depthMaterial = getDepthMaterial( object, groupMaterial, isPointLight, _lightPositionWorld, shadowCamera.near, shadowCamera.far );\\n\\t\\t\\t\\t\\t\\t\\t\\t_renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, group );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else if ( material.visible ) {\\n\\n\\t\\t\\t\\t\\t\\tvar depthMaterial = getDepthMaterial( object, material, isPointLight, _lightPositionWorld, shadowCamera.near, shadowCamera.far );\\n\\t\\t\\t\\t\\t\\t_renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, null );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar children = object.children;\\n\\n\\t\\t\\tfor ( var i = 0, l = children.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\trenderObject( children[ i ], camera, shadowCamera, isPointLight );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLAttributes( gl ) {\\n\\n\\t\\tvar buffers = {};\\n\\n\\t\\tfunction createBuffer( attribute, bufferType ) {\\n\\n\\t\\t\\tvar array = attribute.array;\\n\\t\\t\\tvar usage = attribute.dynamic ? gl.DYNAMIC_DRAW : gl.STATIC_DRAW;\\n\\n\\t\\t\\tvar buffer = gl.createBuffer();\\n\\n\\t\\t\\tgl.bindBuffer( bufferType, buffer );\\n\\t\\t\\tgl.bufferData( bufferType, array, usage );\\n\\n\\t\\t\\tattribute.onUploadCallback();\\n\\n\\t\\t\\tvar type = gl.FLOAT;\\n\\n\\t\\t\\tif ( array instanceof Float32Array ) {\\n\\n\\t\\t\\t\\ttype = gl.FLOAT;\\n\\n\\t\\t\\t} else if ( array instanceof Float64Array ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLAttributes: Unsupported data buffer format: Float64Array.' );\\n\\n\\t\\t\\t} else if ( array instanceof Uint16Array ) {\\n\\n\\t\\t\\t\\ttype = gl.UNSIGNED_SHORT;\\n\\n\\t\\t\\t} else if ( array instanceof Int16Array ) {\\n\\n\\t\\t\\t\\ttype = gl.SHORT;\\n\\n\\t\\t\\t} else if ( array instanceof Uint32Array ) {\\n\\n\\t\\t\\t\\ttype = gl.UNSIGNED_INT;\\n\\n\\t\\t\\t} else if ( array instanceof Int32Array ) {\\n\\n\\t\\t\\t\\ttype = gl.INT;\\n\\n\\t\\t\\t} else if ( array instanceof Int8Array ) {\\n\\n\\t\\t\\t\\ttype = gl.BYTE;\\n\\n\\t\\t\\t} else if ( array instanceof Uint8Array ) {\\n\\n\\t\\t\\t\\ttype = gl.UNSIGNED_BYTE;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn {\\n\\t\\t\\t\\tbuffer: buffer,\\n\\t\\t\\t\\ttype: type,\\n\\t\\t\\t\\tbytesPerElement: array.BYTES_PER_ELEMENT,\\n\\t\\t\\t\\tversion: attribute.version\\n\\t\\t\\t};\\n\\n\\t\\t}\\n\\n\\t\\tfunction updateBuffer( buffer, attribute, bufferType ) {\\n\\n\\t\\t\\tvar array = attribute.array;\\n\\t\\t\\tvar updateRange = attribute.updateRange;\\n\\n\\t\\t\\tgl.bindBuffer( bufferType, buffer );\\n\\n\\t\\t\\tif ( attribute.dynamic === false ) {\\n\\n\\t\\t\\t\\tgl.bufferData( bufferType, array, gl.STATIC_DRAW );\\n\\n\\t\\t\\t} else if ( updateRange.count === - 1 ) {\\n\\n\\t\\t\\t\\t// Not using update ranges\\n\\n\\t\\t\\t\\tgl.bufferSubData( bufferType, 0, array );\\n\\n\\t\\t\\t} else if ( updateRange.count === 0 ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.WebGLObjects.updateBuffer: dynamic THREE.BufferAttribute marked as needsUpdate but updateRange.count is 0, ensure you are using set methods or updating manually.' );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tgl.bufferSubData( bufferType, updateRange.offset * array.BYTES_PER_ELEMENT,\\n\\t\\t\\t\\t\\tarray.subarray( updateRange.offset, updateRange.offset + updateRange.count ) );\\n\\n\\t\\t\\t\\tupdateRange.count = - 1; // reset range\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tfunction get( attribute ) {\\n\\n\\t\\t\\tif ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;\\n\\n\\t\\t\\treturn buffers[ attribute.uuid ];\\n\\n\\t\\t}\\n\\n\\t\\tfunction remove( attribute ) {\\n\\n\\t\\t\\tif ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;\\n\\n\\t\\t\\tvar data = buffers[ attribute.uuid ];\\n\\n\\t\\t\\tif ( data ) {\\n\\n\\t\\t\\t\\tgl.deleteBuffer( data.buffer );\\n\\n\\t\\t\\t\\tdelete buffers[ attribute.uuid ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction update( attribute, bufferType ) {\\n\\n\\t\\t\\tif ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;\\n\\n\\t\\t\\tvar data = buffers[ attribute.uuid ];\\n\\n\\t\\t\\tif ( data === undefined ) {\\n\\n\\t\\t\\t\\tbuffers[ attribute.uuid ] = createBuffer( attribute, bufferType );\\n\\n\\t\\t\\t} else if ( data.version < attribute.version ) {\\n\\n\\t\\t\\t\\tupdateBuffer( data.buffer, attribute, bufferType );\\n\\n\\t\\t\\t\\tdata.version = attribute.version;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tget: get,\\n\\t\\t\\tremove: remove,\\n\\t\\t\\tupdate: update\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t * @author bhouston / http://clara.io\\n\\t */\\n\\n\\tfunction Euler( x, y, z, order ) {\\n\\n\\t\\tthis._x = x || 0;\\n\\t\\tthis._y = y || 0;\\n\\t\\tthis._z = z || 0;\\n\\t\\tthis._order = order || Euler.DefaultOrder;\\n\\n\\t}\\n\\n\\tEuler.RotationOrders = [ 'XYZ', 'YZX', 'ZXY', 'XZY', 'YXZ', 'ZYX' ];\\n\\n\\tEuler.DefaultOrder = 'XYZ';\\n\\n\\tObject.defineProperties( Euler.prototype, {\\n\\n\\t\\tx: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this._x;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis._x = value;\\n\\t\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\ty: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this._y;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis._y = value;\\n\\t\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tz: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this._z;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis._z = value;\\n\\t\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\torder: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this._order;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis._order = value;\\n\\t\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Euler.prototype, {\\n\\n\\t\\tisEuler: true,\\n\\n\\t\\tset: function ( x, y, z, order ) {\\n\\n\\t\\t\\tthis._x = x;\\n\\t\\t\\tthis._y = y;\\n\\t\\t\\tthis._z = z;\\n\\t\\t\\tthis._order = order || this._order;\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this._x, this._y, this._z, this._order );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( euler ) {\\n\\n\\t\\t\\tthis._x = euler._x;\\n\\t\\t\\tthis._y = euler._y;\\n\\t\\t\\tthis._z = euler._z;\\n\\t\\t\\tthis._order = euler._order;\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromRotationMatrix: function ( m, order, update ) {\\n\\n\\t\\t\\tvar clamp = _Math.clamp;\\n\\n\\t\\t\\t// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)\\n\\n\\t\\t\\tvar te = m.elements;\\n\\t\\t\\tvar m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ];\\n\\t\\t\\tvar m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ];\\n\\t\\t\\tvar m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];\\n\\n\\t\\t\\torder = order || this._order;\\n\\n\\t\\t\\tif ( order === 'XYZ' ) {\\n\\n\\t\\t\\t\\tthis._y = Math.asin( clamp( m13, - 1, 1 ) );\\n\\n\\t\\t\\t\\tif ( Math.abs( m13 ) < 0.99999 ) {\\n\\n\\t\\t\\t\\t\\tthis._x = Math.atan2( - m23, m33 );\\n\\t\\t\\t\\t\\tthis._z = Math.atan2( - m12, m11 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthis._x = Math.atan2( m32, m22 );\\n\\t\\t\\t\\t\\tthis._z = 0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( order === 'YXZ' ) {\\n\\n\\t\\t\\t\\tthis._x = Math.asin( - clamp( m23, - 1, 1 ) );\\n\\n\\t\\t\\t\\tif ( Math.abs( m23 ) < 0.99999 ) {\\n\\n\\t\\t\\t\\t\\tthis._y = Math.atan2( m13, m33 );\\n\\t\\t\\t\\t\\tthis._z = Math.atan2( m21, m22 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthis._y = Math.atan2( - m31, m11 );\\n\\t\\t\\t\\t\\tthis._z = 0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( order === 'ZXY' ) {\\n\\n\\t\\t\\t\\tthis._x = Math.asin( clamp( m32, - 1, 1 ) );\\n\\n\\t\\t\\t\\tif ( Math.abs( m32 ) < 0.99999 ) {\\n\\n\\t\\t\\t\\t\\tthis._y = Math.atan2( - m31, m33 );\\n\\t\\t\\t\\t\\tthis._z = Math.atan2( - m12, m22 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthis._y = 0;\\n\\t\\t\\t\\t\\tthis._z = Math.atan2( m21, m11 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( order === 'ZYX' ) {\\n\\n\\t\\t\\t\\tthis._y = Math.asin( - clamp( m31, - 1, 1 ) );\\n\\n\\t\\t\\t\\tif ( Math.abs( m31 ) < 0.99999 ) {\\n\\n\\t\\t\\t\\t\\tthis._x = Math.atan2( m32, m33 );\\n\\t\\t\\t\\t\\tthis._z = Math.atan2( m21, m11 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthis._x = 0;\\n\\t\\t\\t\\t\\tthis._z = Math.atan2( - m12, m22 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( order === 'YZX' ) {\\n\\n\\t\\t\\t\\tthis._z = Math.asin( clamp( m21, - 1, 1 ) );\\n\\n\\t\\t\\t\\tif ( Math.abs( m21 ) < 0.99999 ) {\\n\\n\\t\\t\\t\\t\\tthis._x = Math.atan2( - m23, m22 );\\n\\t\\t\\t\\t\\tthis._y = Math.atan2( - m31, m11 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthis._x = 0;\\n\\t\\t\\t\\t\\tthis._y = Math.atan2( m13, m33 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( order === 'XZY' ) {\\n\\n\\t\\t\\t\\tthis._z = Math.asin( - clamp( m12, - 1, 1 ) );\\n\\n\\t\\t\\t\\tif ( Math.abs( m12 ) < 0.99999 ) {\\n\\n\\t\\t\\t\\t\\tthis._x = Math.atan2( m32, m22 );\\n\\t\\t\\t\\t\\tthis._y = Math.atan2( m13, m11 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthis._x = Math.atan2( - m23, m33 );\\n\\t\\t\\t\\t\\tthis._y = 0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Euler: .setFromRotationMatrix() given unsupported order: ' + order );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis._order = order;\\n\\n\\t\\t\\tif ( update !== false ) this.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromQuaternion: function () {\\n\\n\\t\\t\\tvar matrix = new Matrix4();\\n\\n\\t\\t\\treturn function setFromQuaternion( q, order, update ) {\\n\\n\\t\\t\\t\\tmatrix.makeRotationFromQuaternion( q );\\n\\n\\t\\t\\t\\treturn this.setFromRotationMatrix( matrix, order, update );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tsetFromVector3: function ( v, order ) {\\n\\n\\t\\t\\treturn this.set( v.x, v.y, v.z, order || this._order );\\n\\n\\t\\t},\\n\\n\\t\\treorder: function () {\\n\\n\\t\\t\\t// WARNING: this discards revolution information -bhouston\\n\\n\\t\\t\\tvar q = new Quaternion();\\n\\n\\t\\t\\treturn function reorder( newOrder ) {\\n\\n\\t\\t\\t\\tq.setFromEuler( this );\\n\\n\\t\\t\\t\\treturn this.setFromQuaternion( q, newOrder );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tequals: function ( euler ) {\\n\\n\\t\\t\\treturn ( euler._x === this._x ) && ( euler._y === this._y ) && ( euler._z === this._z ) && ( euler._order === this._order );\\n\\n\\t\\t},\\n\\n\\t\\tfromArray: function ( array ) {\\n\\n\\t\\t\\tthis._x = array[ 0 ];\\n\\t\\t\\tthis._y = array[ 1 ];\\n\\t\\t\\tthis._z = array[ 2 ];\\n\\t\\t\\tif ( array[ 3 ] !== undefined ) this._order = array[ 3 ];\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( array === undefined ) array = [];\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tarray[ offset ] = this._x;\\n\\t\\t\\tarray[ offset + 1 ] = this._y;\\n\\t\\t\\tarray[ offset + 2 ] = this._z;\\n\\t\\t\\tarray[ offset + 3 ] = this._order;\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t},\\n\\n\\t\\ttoVector3: function ( optionalResult ) {\\n\\n\\t\\t\\tif ( optionalResult ) {\\n\\n\\t\\t\\t\\treturn optionalResult.set( this._x, this._y, this._z );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\treturn new Vector3( this._x, this._y, this._z );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tonChange: function ( callback ) {\\n\\n\\t\\t\\tthis.onChangeCallback = callback;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tonChangeCallback: function () {}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Layers() {\\n\\n\\t\\tthis.mask = 1 | 0;\\n\\n\\t}\\n\\n\\tObject.assign( Layers.prototype, {\\n\\n\\t\\tset: function ( channel ) {\\n\\n\\t\\t\\tthis.mask = 1 << channel | 0;\\n\\n\\t\\t},\\n\\n\\t\\tenable: function ( channel ) {\\n\\n\\t\\t\\tthis.mask |= 1 << channel | 0;\\n\\n\\t\\t},\\n\\n\\t\\ttoggle: function ( channel ) {\\n\\n\\t\\t\\tthis.mask ^= 1 << channel | 0;\\n\\n\\t\\t},\\n\\n\\t\\tdisable: function ( channel ) {\\n\\n\\t\\t\\tthis.mask &= ~ ( 1 << channel | 0 );\\n\\n\\t\\t},\\n\\n\\t\\ttest: function ( layers ) {\\n\\n\\t\\t\\treturn ( this.mask & layers.mask ) !== 0;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t * @author elephantatwork / www.elephantatwork.ch\\n\\t */\\n\\n\\tvar object3DId = 0;\\n\\n\\tfunction Object3D() {\\n\\n\\t\\tObject.defineProperty( this, 'id', { value: object3DId ++ } );\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.name = '';\\n\\t\\tthis.type = 'Object3D';\\n\\n\\t\\tthis.parent = null;\\n\\t\\tthis.children = [];\\n\\n\\t\\tthis.up = Object3D.DefaultUp.clone();\\n\\n\\t\\tvar position = new Vector3();\\n\\t\\tvar rotation = new Euler();\\n\\t\\tvar quaternion = new Quaternion();\\n\\t\\tvar scale = new Vector3( 1, 1, 1 );\\n\\n\\t\\tfunction onRotationChange() {\\n\\n\\t\\t\\tquaternion.setFromEuler( rotation, false );\\n\\n\\t\\t}\\n\\n\\t\\tfunction onQuaternionChange() {\\n\\n\\t\\t\\trotation.setFromQuaternion( quaternion, undefined, false );\\n\\n\\t\\t}\\n\\n\\t\\trotation.onChange( onRotationChange );\\n\\t\\tquaternion.onChange( onQuaternionChange );\\n\\n\\t\\tObject.defineProperties( this, {\\n\\t\\t\\tposition: {\\n\\t\\t\\t\\tenumerable: true,\\n\\t\\t\\t\\tvalue: position\\n\\t\\t\\t},\\n\\t\\t\\trotation: {\\n\\t\\t\\t\\tenumerable: true,\\n\\t\\t\\t\\tvalue: rotation\\n\\t\\t\\t},\\n\\t\\t\\tquaternion: {\\n\\t\\t\\t\\tenumerable: true,\\n\\t\\t\\t\\tvalue: quaternion\\n\\t\\t\\t},\\n\\t\\t\\tscale: {\\n\\t\\t\\t\\tenumerable: true,\\n\\t\\t\\t\\tvalue: scale\\n\\t\\t\\t},\\n\\t\\t\\tmodelViewMatrix: {\\n\\t\\t\\t\\tvalue: new Matrix4()\\n\\t\\t\\t},\\n\\t\\t\\tnormalMatrix: {\\n\\t\\t\\t\\tvalue: new Matrix3()\\n\\t\\t\\t}\\n\\t\\t} );\\n\\n\\t\\tthis.matrix = new Matrix4();\\n\\t\\tthis.matrixWorld = new Matrix4();\\n\\n\\t\\tthis.matrixAutoUpdate = Object3D.DefaultMatrixAutoUpdate;\\n\\t\\tthis.matrixWorldNeedsUpdate = false;\\n\\n\\t\\tthis.layers = new Layers();\\n\\t\\tthis.visible = true;\\n\\n\\t\\tthis.castShadow = false;\\n\\t\\tthis.receiveShadow = false;\\n\\n\\t\\tthis.frustumCulled = true;\\n\\t\\tthis.renderOrder = 0;\\n\\n\\t\\tthis.userData = {};\\n\\n\\t}\\n\\n\\tObject3D.DefaultUp = new Vector3( 0, 1, 0 );\\n\\tObject3D.DefaultMatrixAutoUpdate = true;\\n\\n\\tObject3D.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {\\n\\n\\t\\tconstructor: Object3D,\\n\\n\\t\\tisObject3D: true,\\n\\n\\t\\tonBeforeRender: function () {},\\n\\t\\tonAfterRender: function () {},\\n\\n\\t\\tapplyMatrix: function ( matrix ) {\\n\\n\\t\\t\\tthis.matrix.multiplyMatrices( matrix, this.matrix );\\n\\n\\t\\t\\tthis.matrix.decompose( this.position, this.quaternion, this.scale );\\n\\n\\t\\t},\\n\\n\\t\\tapplyQuaternion: function ( q ) {\\n\\n\\t\\t\\tthis.quaternion.premultiply( q );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetRotationFromAxisAngle: function ( axis, angle ) {\\n\\n\\t\\t\\t// assumes axis is normalized\\n\\n\\t\\t\\tthis.quaternion.setFromAxisAngle( axis, angle );\\n\\n\\t\\t},\\n\\n\\t\\tsetRotationFromEuler: function ( euler ) {\\n\\n\\t\\t\\tthis.quaternion.setFromEuler( euler, true );\\n\\n\\t\\t},\\n\\n\\t\\tsetRotationFromMatrix: function ( m ) {\\n\\n\\t\\t\\t// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)\\n\\n\\t\\t\\tthis.quaternion.setFromRotationMatrix( m );\\n\\n\\t\\t},\\n\\n\\t\\tsetRotationFromQuaternion: function ( q ) {\\n\\n\\t\\t\\t// assumes q is normalized\\n\\n\\t\\t\\tthis.quaternion.copy( q );\\n\\n\\t\\t},\\n\\n\\t\\trotateOnAxis: function () {\\n\\n\\t\\t\\t// rotate object on axis in object space\\n\\t\\t\\t// axis is assumed to be normalized\\n\\n\\t\\t\\tvar q1 = new Quaternion();\\n\\n\\t\\t\\treturn function rotateOnAxis( axis, angle ) {\\n\\n\\t\\t\\t\\tq1.setFromAxisAngle( axis, angle );\\n\\n\\t\\t\\t\\tthis.quaternion.multiply( q1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\trotateOnWorldAxis: function () {\\n\\n\\t\\t\\t// rotate object on axis in world space\\n\\t\\t\\t// axis is assumed to be normalized\\n\\t\\t\\t// method assumes no rotated parent\\n\\n\\t\\t\\tvar q1 = new Quaternion();\\n\\n\\t\\t\\treturn function rotateOnWorldAxis( axis, angle ) {\\n\\n\\t\\t\\t\\tq1.setFromAxisAngle( axis, angle );\\n\\n\\t\\t\\t\\tthis.quaternion.premultiply( q1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\trotateX: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3( 1, 0, 0 );\\n\\n\\t\\t\\treturn function rotateX( angle ) {\\n\\n\\t\\t\\t\\treturn this.rotateOnAxis( v1, angle );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\trotateY: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3( 0, 1, 0 );\\n\\n\\t\\t\\treturn function rotateY( angle ) {\\n\\n\\t\\t\\t\\treturn this.rotateOnAxis( v1, angle );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\trotateZ: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3( 0, 0, 1 );\\n\\n\\t\\t\\treturn function rotateZ( angle ) {\\n\\n\\t\\t\\t\\treturn this.rotateOnAxis( v1, angle );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttranslateOnAxis: function () {\\n\\n\\t\\t\\t// translate object by distance along axis in object space\\n\\t\\t\\t// axis is assumed to be normalized\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function translateOnAxis( axis, distance ) {\\n\\n\\t\\t\\t\\tv1.copy( axis ).applyQuaternion( this.quaternion );\\n\\n\\t\\t\\t\\tthis.position.add( v1.multiplyScalar( distance ) );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttranslateX: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3( 1, 0, 0 );\\n\\n\\t\\t\\treturn function translateX( distance ) {\\n\\n\\t\\t\\t\\treturn this.translateOnAxis( v1, distance );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttranslateY: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3( 0, 1, 0 );\\n\\n\\t\\t\\treturn function translateY( distance ) {\\n\\n\\t\\t\\t\\treturn this.translateOnAxis( v1, distance );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttranslateZ: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3( 0, 0, 1 );\\n\\n\\t\\t\\treturn function translateZ( distance ) {\\n\\n\\t\\t\\t\\treturn this.translateOnAxis( v1, distance );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tlocalToWorld: function ( vector ) {\\n\\n\\t\\t\\treturn vector.applyMatrix4( this.matrixWorld );\\n\\n\\t\\t},\\n\\n\\t\\tworldToLocal: function () {\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function worldToLocal( vector ) {\\n\\n\\t\\t\\t\\treturn vector.applyMatrix4( m1.getInverse( this.matrixWorld ) );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tlookAt: function () {\\n\\n\\t\\t\\t// This method does not support objects with rotated and/or translated parent(s)\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\t\\t\\tvar vector = new Vector3();\\n\\n\\t\\t\\treturn function lookAt( x, y, z ) {\\n\\n\\t\\t\\t\\tif ( x.isVector3 ) {\\n\\n\\t\\t\\t\\t\\tvector.copy( x );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tvector.set( x, y, z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( this.isCamera ) {\\n\\n\\t\\t\\t\\t\\tm1.lookAt( this.position, vector, this.up );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tm1.lookAt( vector, this.position, this.up );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.quaternion.setFromRotationMatrix( m1 );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tadd: function ( object ) {\\n\\n\\t\\t\\tif ( arguments.length > 1 ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < arguments.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tthis.add( arguments[ i ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( object === this ) {\\n\\n\\t\\t\\t\\tconsole.error( \\\"THREE.Object3D.add: object can't be added as a child of itself.\\\", object );\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( ( object && object.isObject3D ) ) {\\n\\n\\t\\t\\t\\tif ( object.parent !== null ) {\\n\\n\\t\\t\\t\\t\\tobject.parent.remove( object );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tobject.parent = this;\\n\\t\\t\\t\\tobject.dispatchEvent( { type: 'added' } );\\n\\n\\t\\t\\t\\tthis.children.push( object );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tconsole.error( \\\"THREE.Object3D.add: object not an instance of THREE.Object3D.\\\", object );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tremove: function ( object ) {\\n\\n\\t\\t\\tif ( arguments.length > 1 ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < arguments.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tthis.remove( arguments[ i ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar index = this.children.indexOf( object );\\n\\n\\t\\t\\tif ( index !== - 1 ) {\\n\\n\\t\\t\\t\\tobject.parent = null;\\n\\n\\t\\t\\t\\tobject.dispatchEvent( { type: 'removed' } );\\n\\n\\t\\t\\t\\tthis.children.splice( index, 1 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetObjectById: function ( id ) {\\n\\n\\t\\t\\treturn this.getObjectByProperty( 'id', id );\\n\\n\\t\\t},\\n\\n\\t\\tgetObjectByName: function ( name ) {\\n\\n\\t\\t\\treturn this.getObjectByProperty( 'name', name );\\n\\n\\t\\t},\\n\\n\\t\\tgetObjectByProperty: function ( name, value ) {\\n\\n\\t\\t\\tif ( this[ name ] === value ) return this;\\n\\n\\t\\t\\tfor ( var i = 0, l = this.children.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar child = this.children[ i ];\\n\\t\\t\\t\\tvar object = child.getObjectByProperty( name, value );\\n\\n\\t\\t\\t\\tif ( object !== undefined ) {\\n\\n\\t\\t\\t\\t\\treturn object;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn undefined;\\n\\n\\t\\t},\\n\\n\\t\\tgetWorldPosition: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\tthis.updateMatrixWorld( true );\\n\\n\\t\\t\\treturn result.setFromMatrixPosition( this.matrixWorld );\\n\\n\\t\\t},\\n\\n\\t\\tgetWorldQuaternion: function () {\\n\\n\\t\\t\\tvar position = new Vector3();\\n\\t\\t\\tvar scale = new Vector3();\\n\\n\\t\\t\\treturn function getWorldQuaternion( optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Quaternion();\\n\\n\\t\\t\\t\\tthis.updateMatrixWorld( true );\\n\\n\\t\\t\\t\\tthis.matrixWorld.decompose( position, result, scale );\\n\\n\\t\\t\\t\\treturn result;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tgetWorldRotation: function () {\\n\\n\\t\\t\\tvar quaternion = new Quaternion();\\n\\n\\t\\t\\treturn function getWorldRotation( optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Euler();\\n\\n\\t\\t\\t\\tthis.getWorldQuaternion( quaternion );\\n\\n\\t\\t\\t\\treturn result.setFromQuaternion( quaternion, this.rotation.order, false );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tgetWorldScale: function () {\\n\\n\\t\\t\\tvar position = new Vector3();\\n\\t\\t\\tvar quaternion = new Quaternion();\\n\\n\\t\\t\\treturn function getWorldScale( optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\t\\tthis.updateMatrixWorld( true );\\n\\n\\t\\t\\t\\tthis.matrixWorld.decompose( position, quaternion, result );\\n\\n\\t\\t\\t\\treturn result;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tgetWorldDirection: function () {\\n\\n\\t\\t\\tvar quaternion = new Quaternion();\\n\\n\\t\\t\\treturn function getWorldDirection( optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\t\\tthis.getWorldQuaternion( quaternion );\\n\\n\\t\\t\\t\\treturn result.set( 0, 0, 1 ).applyQuaternion( quaternion );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\traycast: function () {},\\n\\n\\t\\ttraverse: function ( callback ) {\\n\\n\\t\\t\\tcallback( this );\\n\\n\\t\\t\\tvar children = this.children;\\n\\n\\t\\t\\tfor ( var i = 0, l = children.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tchildren[ i ].traverse( callback );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\ttraverseVisible: function ( callback ) {\\n\\n\\t\\t\\tif ( this.visible === false ) return;\\n\\n\\t\\t\\tcallback( this );\\n\\n\\t\\t\\tvar children = this.children;\\n\\n\\t\\t\\tfor ( var i = 0, l = children.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tchildren[ i ].traverseVisible( callback );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\ttraverseAncestors: function ( callback ) {\\n\\n\\t\\t\\tvar parent = this.parent;\\n\\n\\t\\t\\tif ( parent !== null ) {\\n\\n\\t\\t\\t\\tcallback( parent );\\n\\n\\t\\t\\t\\tparent.traverseAncestors( callback );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tupdateMatrix: function () {\\n\\n\\t\\t\\tthis.matrix.compose( this.position, this.quaternion, this.scale );\\n\\n\\t\\t\\tthis.matrixWorldNeedsUpdate = true;\\n\\n\\t\\t},\\n\\n\\t\\tupdateMatrixWorld: function ( force ) {\\n\\n\\t\\t\\tif ( this.matrixAutoUpdate ) this.updateMatrix();\\n\\n\\t\\t\\tif ( this.matrixWorldNeedsUpdate || force ) {\\n\\n\\t\\t\\t\\tif ( this.parent === null ) {\\n\\n\\t\\t\\t\\t\\tthis.matrixWorld.copy( this.matrix );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthis.matrixWorld.multiplyMatrices( this.parent.matrixWorld, this.matrix );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.matrixWorldNeedsUpdate = false;\\n\\n\\t\\t\\t\\tforce = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// update children\\n\\n\\t\\t\\tvar children = this.children;\\n\\n\\t\\t\\tfor ( var i = 0, l = children.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tchildren[ i ].updateMatrixWorld( force );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\t// meta is a string when called from JSON.stringify\\n\\t\\t\\tvar isRootObject = ( meta === undefined || typeof meta === 'string' );\\n\\n\\t\\t\\tvar output = {};\\n\\n\\t\\t\\t// meta is a hash used to collect geometries, materials.\\n\\t\\t\\t// not providing it implies that this is the root object\\n\\t\\t\\t// being serialized.\\n\\t\\t\\tif ( isRootObject ) {\\n\\n\\t\\t\\t\\t// initialize meta obj\\n\\t\\t\\t\\tmeta = {\\n\\t\\t\\t\\t\\tgeometries: {},\\n\\t\\t\\t\\t\\tmaterials: {},\\n\\t\\t\\t\\t\\ttextures: {},\\n\\t\\t\\t\\t\\timages: {},\\n\\t\\t\\t\\t\\tshapes: {}\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\toutput.metadata = {\\n\\t\\t\\t\\t\\tversion: 4.5,\\n\\t\\t\\t\\t\\ttype: 'Object',\\n\\t\\t\\t\\t\\tgenerator: 'Object3D.toJSON'\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// standard Object3D serialization\\n\\n\\t\\t\\tvar object = {};\\n\\n\\t\\t\\tobject.uuid = this.uuid;\\n\\t\\t\\tobject.type = this.type;\\n\\n\\t\\t\\tif ( this.name !== '' ) object.name = this.name;\\n\\t\\t\\tif ( this.castShadow === true ) object.castShadow = true;\\n\\t\\t\\tif ( this.receiveShadow === true ) object.receiveShadow = true;\\n\\t\\t\\tif ( this.visible === false ) object.visible = false;\\n\\t\\t\\tif ( JSON.stringify( this.userData ) !== '{}' ) object.userData = this.userData;\\n\\n\\t\\t\\tobject.matrix = this.matrix.toArray();\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tfunction serialize( library, element ) {\\n\\n\\t\\t\\t\\tif ( library[ element.uuid ] === undefined ) {\\n\\n\\t\\t\\t\\t\\tlibrary[ element.uuid ] = element.toJSON( meta );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn element.uuid;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.geometry !== undefined ) {\\n\\n\\t\\t\\t\\tobject.geometry = serialize( meta.geometries, this.geometry );\\n\\n\\t\\t\\t\\tvar parameters = this.geometry.parameters;\\n\\n\\t\\t\\t\\tif ( parameters !== undefined && parameters.shapes !== undefined ) {\\n\\n\\t\\t\\t\\t\\tvar shapes = parameters.shapes;\\n\\n\\t\\t\\t\\t\\tif ( Array.isArray( shapes ) ) {\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, l = shapes.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar shape = shapes[ i ];\\n\\n\\t\\t\\t\\t\\t\\t\\tserialize( meta.shapes, shape );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tserialize( meta.shapes, shapes );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.material !== undefined ) {\\n\\n\\t\\t\\t\\tif ( Array.isArray( this.material ) ) {\\n\\n\\t\\t\\t\\t\\tvar uuids = [];\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, l = this.material.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tuuids.push( serialize( meta.materials, this.material[ i ] ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tobject.material = uuids;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tobject.material = serialize( meta.materials, this.material );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tif ( this.children.length > 0 ) {\\n\\n\\t\\t\\t\\tobject.children = [];\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < this.children.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tobject.children.push( this.children[ i ].toJSON( meta ).object );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( isRootObject ) {\\n\\n\\t\\t\\t\\tvar geometries = extractFromCache( meta.geometries );\\n\\t\\t\\t\\tvar materials = extractFromCache( meta.materials );\\n\\t\\t\\t\\tvar textures = extractFromCache( meta.textures );\\n\\t\\t\\t\\tvar images = extractFromCache( meta.images );\\n\\t\\t\\t\\tvar shapes = extractFromCache( meta.shapes );\\n\\n\\t\\t\\t\\tif ( geometries.length > 0 ) output.geometries = geometries;\\n\\t\\t\\t\\tif ( materials.length > 0 ) output.materials = materials;\\n\\t\\t\\t\\tif ( textures.length > 0 ) output.textures = textures;\\n\\t\\t\\t\\tif ( images.length > 0 ) output.images = images;\\n\\t\\t\\t\\tif ( shapes.length > 0 ) output.shapes = shapes;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\toutput.object = object;\\n\\n\\t\\t\\treturn output;\\n\\n\\t\\t\\t// extract data from the cache hash\\n\\t\\t\\t// remove metadata on each item\\n\\t\\t\\t// and return as array\\n\\t\\t\\tfunction extractFromCache( cache ) {\\n\\n\\t\\t\\t\\tvar values = [];\\n\\t\\t\\t\\tfor ( var key in cache ) {\\n\\n\\t\\t\\t\\t\\tvar data = cache[ key ];\\n\\t\\t\\t\\t\\tdelete data.metadata;\\n\\t\\t\\t\\t\\tvalues.push( data );\\n\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\treturn values;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tclone: function ( recursive ) {\\n\\n\\t\\t\\treturn new this.constructor().copy( this, recursive );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source, recursive ) {\\n\\n\\t\\t\\tif ( recursive === undefined ) recursive = true;\\n\\n\\t\\t\\tthis.name = source.name;\\n\\n\\t\\t\\tthis.up.copy( source.up );\\n\\n\\t\\t\\tthis.position.copy( source.position );\\n\\t\\t\\tthis.quaternion.copy( source.quaternion );\\n\\t\\t\\tthis.scale.copy( source.scale );\\n\\n\\t\\t\\tthis.matrix.copy( source.matrix );\\n\\t\\t\\tthis.matrixWorld.copy( source.matrixWorld );\\n\\n\\t\\t\\tthis.matrixAutoUpdate = source.matrixAutoUpdate;\\n\\t\\t\\tthis.matrixWorldNeedsUpdate = source.matrixWorldNeedsUpdate;\\n\\n\\t\\t\\tthis.layers.mask = source.layers.mask;\\n\\t\\t\\tthis.visible = source.visible;\\n\\n\\t\\t\\tthis.castShadow = source.castShadow;\\n\\t\\t\\tthis.receiveShadow = source.receiveShadow;\\n\\n\\t\\t\\tthis.frustumCulled = source.frustumCulled;\\n\\t\\t\\tthis.renderOrder = source.renderOrder;\\n\\n\\t\\t\\tthis.userData = JSON.parse( JSON.stringify( source.userData ) );\\n\\n\\t\\t\\tif ( recursive === true ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < source.children.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar child = source.children[ i ];\\n\\t\\t\\t\\t\\tthis.add( child.clone() );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t*/\\n\\n\\tfunction Camera() {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Camera';\\n\\n\\t\\tthis.matrixWorldInverse = new Matrix4();\\n\\t\\tthis.projectionMatrix = new Matrix4();\\n\\n\\t}\\n\\n\\tCamera.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Camera,\\n\\n\\t\\tisCamera: true,\\n\\n\\t\\tcopy: function ( source, recursive ) {\\n\\n\\t\\t\\tObject3D.prototype.copy.call( this, source, recursive );\\n\\n\\t\\t\\tthis.matrixWorldInverse.copy( source.matrixWorldInverse );\\n\\t\\t\\tthis.projectionMatrix.copy( source.projectionMatrix );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetWorldDirection: function () {\\n\\n\\t\\t\\tvar quaternion = new Quaternion();\\n\\n\\t\\t\\treturn function getWorldDirection( optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\t\\tthis.getWorldQuaternion( quaternion );\\n\\n\\t\\t\\t\\treturn result.set( 0, 0, - 1 ).applyQuaternion( quaternion );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tupdateMatrixWorld: function ( force ) {\\n\\n\\t\\t\\tObject3D.prototype.updateMatrixWorld.call( this, force );\\n\\n\\t\\t\\tthis.matrixWorldInverse.getInverse( this.matrixWorld );\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author arose / http://github.com/arose\\n\\t */\\n\\n\\tfunction OrthographicCamera( left, right, top, bottom, near, far ) {\\n\\n\\t\\tCamera.call( this );\\n\\n\\t\\tthis.type = 'OrthographicCamera';\\n\\n\\t\\tthis.zoom = 1;\\n\\t\\tthis.view = null;\\n\\n\\t\\tthis.left = left;\\n\\t\\tthis.right = right;\\n\\t\\tthis.top = top;\\n\\t\\tthis.bottom = bottom;\\n\\n\\t\\tthis.near = ( near !== undefined ) ? near : 0.1;\\n\\t\\tthis.far = ( far !== undefined ) ? far : 2000;\\n\\n\\t\\tthis.updateProjectionMatrix();\\n\\n\\t}\\n\\n\\tOrthographicCamera.prototype = Object.assign( Object.create( Camera.prototype ), {\\n\\n\\t\\tconstructor: OrthographicCamera,\\n\\n\\t\\tisOrthographicCamera: true,\\n\\n\\t\\tcopy: function ( source, recursive ) {\\n\\n\\t\\t\\tCamera.prototype.copy.call( this, source, recursive );\\n\\n\\t\\t\\tthis.left = source.left;\\n\\t\\t\\tthis.right = source.right;\\n\\t\\t\\tthis.top = source.top;\\n\\t\\t\\tthis.bottom = source.bottom;\\n\\t\\t\\tthis.near = source.near;\\n\\t\\t\\tthis.far = source.far;\\n\\n\\t\\t\\tthis.zoom = source.zoom;\\n\\t\\t\\tthis.view = source.view === null ? null : Object.assign( {}, source.view );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetViewOffset: function ( fullWidth, fullHeight, x, y, width, height ) {\\n\\n\\t\\t\\tif ( this.view === null ) {\\n\\n\\t\\t\\t\\tthis.view = {\\n\\t\\t\\t\\t\\tenabled: true,\\n\\t\\t\\t\\t\\tfullWidth: 1,\\n\\t\\t\\t\\t\\tfullHeight: 1,\\n\\t\\t\\t\\t\\toffsetX: 0,\\n\\t\\t\\t\\t\\toffsetY: 0,\\n\\t\\t\\t\\t\\twidth: 1,\\n\\t\\t\\t\\t\\theight: 1\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.view.enabled = true;\\n\\t\\t\\tthis.view.fullWidth = fullWidth;\\n\\t\\t\\tthis.view.fullHeight = fullHeight;\\n\\t\\t\\tthis.view.offsetX = x;\\n\\t\\t\\tthis.view.offsetY = y;\\n\\t\\t\\tthis.view.width = width;\\n\\t\\t\\tthis.view.height = height;\\n\\n\\t\\t\\tthis.updateProjectionMatrix();\\n\\n\\t\\t},\\n\\n\\t\\tclearViewOffset: function () {\\n\\n\\t\\t\\tif ( this.view !== null ) {\\n\\n\\t\\t\\t\\tthis.view.enabled = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.updateProjectionMatrix();\\n\\n\\t\\t},\\n\\n\\t\\tupdateProjectionMatrix: function () {\\n\\n\\t\\t\\tvar dx = ( this.right - this.left ) / ( 2 * this.zoom );\\n\\t\\t\\tvar dy = ( this.top - this.bottom ) / ( 2 * this.zoom );\\n\\t\\t\\tvar cx = ( this.right + this.left ) / 2;\\n\\t\\t\\tvar cy = ( this.top + this.bottom ) / 2;\\n\\n\\t\\t\\tvar left = cx - dx;\\n\\t\\t\\tvar right = cx + dx;\\n\\t\\t\\tvar top = cy + dy;\\n\\t\\t\\tvar bottom = cy - dy;\\n\\n\\t\\t\\tif ( this.view !== null && this.view.enabled ) {\\n\\n\\t\\t\\t\\tvar zoomW = this.zoom / ( this.view.width / this.view.fullWidth );\\n\\t\\t\\t\\tvar zoomH = this.zoom / ( this.view.height / this.view.fullHeight );\\n\\t\\t\\t\\tvar scaleW = ( this.right - this.left ) / this.view.width;\\n\\t\\t\\t\\tvar scaleH = ( this.top - this.bottom ) / this.view.height;\\n\\n\\t\\t\\t\\tleft += scaleW * ( this.view.offsetX / zoomW );\\n\\t\\t\\t\\tright = left + scaleW * ( this.view.width / zoomW );\\n\\t\\t\\t\\ttop -= scaleH * ( this.view.offsetY / zoomH );\\n\\t\\t\\t\\tbottom = top - scaleH * ( this.view.height / zoomH );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.projectionMatrix.makeOrthographic( left, right, top, bottom, this.near, this.far );\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\tvar data = Object3D.prototype.toJSON.call( this, meta );\\n\\n\\t\\t\\tdata.object.zoom = this.zoom;\\n\\t\\t\\tdata.object.left = this.left;\\n\\t\\t\\tdata.object.right = this.right;\\n\\t\\t\\tdata.object.top = this.top;\\n\\t\\t\\tdata.object.bottom = this.bottom;\\n\\t\\t\\tdata.object.near = this.near;\\n\\t\\t\\tdata.object.far = this.far;\\n\\n\\t\\t\\tif ( this.view !== null ) data.object.view = Object.assign( {}, this.view );\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction Face3( a, b, c, normal, color, materialIndex ) {\\n\\n\\t\\tthis.a = a;\\n\\t\\tthis.b = b;\\n\\t\\tthis.c = c;\\n\\n\\t\\tthis.normal = ( normal && normal.isVector3 ) ? normal : new Vector3();\\n\\t\\tthis.vertexNormals = Array.isArray( normal ) ? normal : [];\\n\\n\\t\\tthis.color = ( color && color.isColor ) ? color : new Color();\\n\\t\\tthis.vertexColors = Array.isArray( color ) ? color : [];\\n\\n\\t\\tthis.materialIndex = materialIndex !== undefined ? materialIndex : 0;\\n\\n\\t}\\n\\n\\tObject.assign( Face3.prototype, {\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tthis.a = source.a;\\n\\t\\t\\tthis.b = source.b;\\n\\t\\t\\tthis.c = source.c;\\n\\n\\t\\t\\tthis.normal.copy( source.normal );\\n\\t\\t\\tthis.color.copy( source.color );\\n\\n\\t\\t\\tthis.materialIndex = source.materialIndex;\\n\\n\\t\\t\\tfor ( var i = 0, il = source.vertexNormals.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.vertexNormals[ i ] = source.vertexNormals[ i ].clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = 0, il = source.vertexColors.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.vertexColors[ i ] = source.vertexColors[ i ].clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author kile / http://kile.stravaganza.org/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t * @author bhouston / http://clara.io\\n\\t */\\n\\n\\tvar geometryId = 0; // Geometry uses even numbers as Id\\n\\n\\tfunction Geometry() {\\n\\n\\t\\tObject.defineProperty( this, 'id', { value: geometryId += 2 } );\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.name = '';\\n\\t\\tthis.type = 'Geometry';\\n\\n\\t\\tthis.vertices = [];\\n\\t\\tthis.colors = [];\\n\\t\\tthis.faces = [];\\n\\t\\tthis.faceVertexUvs = [[]];\\n\\n\\t\\tthis.morphTargets = [];\\n\\t\\tthis.morphNormals = [];\\n\\n\\t\\tthis.skinWeights = [];\\n\\t\\tthis.skinIndices = [];\\n\\n\\t\\tthis.lineDistances = [];\\n\\n\\t\\tthis.boundingBox = null;\\n\\t\\tthis.boundingSphere = null;\\n\\n\\t\\t// update flags\\n\\n\\t\\tthis.elementsNeedUpdate = false;\\n\\t\\tthis.verticesNeedUpdate = false;\\n\\t\\tthis.uvsNeedUpdate = false;\\n\\t\\tthis.normalsNeedUpdate = false;\\n\\t\\tthis.colorsNeedUpdate = false;\\n\\t\\tthis.lineDistancesNeedUpdate = false;\\n\\t\\tthis.groupsNeedUpdate = false;\\n\\n\\t}\\n\\n\\tGeometry.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {\\n\\n\\t\\tconstructor: Geometry,\\n\\n\\t\\tisGeometry: true,\\n\\n\\t\\tapplyMatrix: function ( matrix ) {\\n\\n\\t\\t\\tvar normalMatrix = new Matrix3().getNormalMatrix( matrix );\\n\\n\\t\\t\\tfor ( var i = 0, il = this.vertices.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar vertex = this.vertices[ i ];\\n\\t\\t\\t\\tvertex.applyMatrix4( matrix );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = 0, il = this.faces.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar face = this.faces[ i ];\\n\\t\\t\\t\\tface.normal.applyMatrix3( normalMatrix ).normalize();\\n\\n\\t\\t\\t\\tfor ( var j = 0, jl = face.vertexNormals.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\tface.vertexNormals[ j ].applyMatrix3( normalMatrix ).normalize();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.boundingBox !== null ) {\\n\\n\\t\\t\\t\\tthis.computeBoundingBox();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.boundingSphere !== null ) {\\n\\n\\t\\t\\t\\tthis.computeBoundingSphere();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.verticesNeedUpdate = true;\\n\\t\\t\\tthis.normalsNeedUpdate = true;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\trotateX: function () {\\n\\n\\t\\t\\t// rotate geometry around world x-axis\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function rotateX( angle ) {\\n\\n\\t\\t\\t\\tm1.makeRotationX( angle );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\trotateY: function () {\\n\\n\\t\\t\\t// rotate geometry around world y-axis\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function rotateY( angle ) {\\n\\n\\t\\t\\t\\tm1.makeRotationY( angle );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\trotateZ: function () {\\n\\n\\t\\t\\t// rotate geometry around world z-axis\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function rotateZ( angle ) {\\n\\n\\t\\t\\t\\tm1.makeRotationZ( angle );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttranslate: function () {\\n\\n\\t\\t\\t// translate geometry\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function translate( x, y, z ) {\\n\\n\\t\\t\\t\\tm1.makeTranslation( x, y, z );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tscale: function () {\\n\\n\\t\\t\\t// scale geometry\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function scale( x, y, z ) {\\n\\n\\t\\t\\t\\tm1.makeScale( x, y, z );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tlookAt: function () {\\n\\n\\t\\t\\tvar obj = new Object3D();\\n\\n\\t\\t\\treturn function lookAt( vector ) {\\n\\n\\t\\t\\t\\tobj.lookAt( vector );\\n\\n\\t\\t\\t\\tobj.updateMatrix();\\n\\n\\t\\t\\t\\tthis.applyMatrix( obj.matrix );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tfromBufferGeometry: function ( geometry ) {\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar indices = geometry.index !== null ? geometry.index.array : undefined;\\n\\t\\t\\tvar attributes = geometry.attributes;\\n\\n\\t\\t\\tvar positions = attributes.position.array;\\n\\t\\t\\tvar normals = attributes.normal !== undefined ? attributes.normal.array : undefined;\\n\\t\\t\\tvar colors = attributes.color !== undefined ? attributes.color.array : undefined;\\n\\t\\t\\tvar uvs = attributes.uv !== undefined ? attributes.uv.array : undefined;\\n\\t\\t\\tvar uvs2 = attributes.uv2 !== undefined ? attributes.uv2.array : undefined;\\n\\n\\t\\t\\tif ( uvs2 !== undefined ) this.faceVertexUvs[ 1 ] = [];\\n\\n\\t\\t\\tvar tempNormals = [];\\n\\t\\t\\tvar tempUVs = [];\\n\\t\\t\\tvar tempUVs2 = [];\\n\\n\\t\\t\\tfor ( var i = 0, j = 0; i < positions.length; i += 3, j += 2 ) {\\n\\n\\t\\t\\t\\tscope.vertices.push( new Vector3( positions[ i ], positions[ i + 1 ], positions[ i + 2 ] ) );\\n\\n\\t\\t\\t\\tif ( normals !== undefined ) {\\n\\n\\t\\t\\t\\t\\ttempNormals.push( new Vector3( normals[ i ], normals[ i + 1 ], normals[ i + 2 ] ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( colors !== undefined ) {\\n\\n\\t\\t\\t\\t\\tscope.colors.push( new Color( colors[ i ], colors[ i + 1 ], colors[ i + 2 ] ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( uvs !== undefined ) {\\n\\n\\t\\t\\t\\t\\ttempUVs.push( new Vector2( uvs[ j ], uvs[ j + 1 ] ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( uvs2 !== undefined ) {\\n\\n\\t\\t\\t\\t\\ttempUVs2.push( new Vector2( uvs2[ j ], uvs2[ j + 1 ] ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction addFace( a, b, c, materialIndex ) {\\n\\n\\t\\t\\t\\tvar vertexNormals = normals !== undefined ? [ tempNormals[ a ].clone(), tempNormals[ b ].clone(), tempNormals[ c ].clone() ] : [];\\n\\t\\t\\t\\tvar vertexColors = colors !== undefined ? [ scope.colors[ a ].clone(), scope.colors[ b ].clone(), scope.colors[ c ].clone() ] : [];\\n\\n\\t\\t\\t\\tvar face = new Face3( a, b, c, vertexNormals, vertexColors, materialIndex );\\n\\n\\t\\t\\t\\tscope.faces.push( face );\\n\\n\\t\\t\\t\\tif ( uvs !== undefined ) {\\n\\n\\t\\t\\t\\t\\tscope.faceVertexUvs[ 0 ].push( [ tempUVs[ a ].clone(), tempUVs[ b ].clone(), tempUVs[ c ].clone() ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( uvs2 !== undefined ) {\\n\\n\\t\\t\\t\\t\\tscope.faceVertexUvs[ 1 ].push( [ tempUVs2[ a ].clone(), tempUVs2[ b ].clone(), tempUVs2[ c ].clone() ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar groups = geometry.groups;\\n\\n\\t\\t\\tif ( groups.length > 0 ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < groups.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar group = groups[ i ];\\n\\n\\t\\t\\t\\t\\tvar start = group.start;\\n\\t\\t\\t\\t\\tvar count = group.count;\\n\\n\\t\\t\\t\\t\\tfor ( var j = start, jl = start + count; j < jl; j += 3 ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( indices !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\taddFace( indices[ j ], indices[ j + 1 ], indices[ j + 2 ], group.materialIndex );\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\taddFace( j, j + 1, j + 2, group.materialIndex );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tif ( indices !== undefined ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < indices.length; i += 3 ) {\\n\\n\\t\\t\\t\\t\\t\\taddFace( indices[ i ], indices[ i + 1 ], indices[ i + 2 ] );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < positions.length / 3; i += 3 ) {\\n\\n\\t\\t\\t\\t\\t\\taddFace( i, i + 1, i + 2 );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.computeFaceNormals();\\n\\n\\t\\t\\tif ( geometry.boundingBox !== null ) {\\n\\n\\t\\t\\t\\tthis.boundingBox = geometry.boundingBox.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.boundingSphere !== null ) {\\n\\n\\t\\t\\t\\tthis.boundingSphere = geometry.boundingSphere.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcenter: function () {\\n\\n\\t\\t\\tthis.computeBoundingBox();\\n\\n\\t\\t\\tvar offset = this.boundingBox.getCenter().negate();\\n\\n\\t\\t\\tthis.translate( offset.x, offset.y, offset.z );\\n\\n\\t\\t\\treturn offset;\\n\\n\\t\\t},\\n\\n\\t\\tnormalize: function () {\\n\\n\\t\\t\\tthis.computeBoundingSphere();\\n\\n\\t\\t\\tvar center = this.boundingSphere.center;\\n\\t\\t\\tvar radius = this.boundingSphere.radius;\\n\\n\\t\\t\\tvar s = radius === 0 ? 1 : 1.0 / radius;\\n\\n\\t\\t\\tvar matrix = new Matrix4();\\n\\t\\t\\tmatrix.set(\\n\\t\\t\\t\\ts, 0, 0, - s * center.x,\\n\\t\\t\\t\\t0, s, 0, - s * center.y,\\n\\t\\t\\t\\t0, 0, s, - s * center.z,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\t\\t\\t);\\n\\n\\t\\t\\tthis.applyMatrix( matrix );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcomputeFaceNormals: function () {\\n\\n\\t\\t\\tvar cb = new Vector3(), ab = new Vector3();\\n\\n\\t\\t\\tfor ( var f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\tvar face = this.faces[ f ];\\n\\n\\t\\t\\t\\tvar vA = this.vertices[ face.a ];\\n\\t\\t\\t\\tvar vB = this.vertices[ face.b ];\\n\\t\\t\\t\\tvar vC = this.vertices[ face.c ];\\n\\n\\t\\t\\t\\tcb.subVectors( vC, vB );\\n\\t\\t\\t\\tab.subVectors( vA, vB );\\n\\t\\t\\t\\tcb.cross( ab );\\n\\n\\t\\t\\t\\tcb.normalize();\\n\\n\\t\\t\\t\\tface.normal.copy( cb );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tcomputeVertexNormals: function ( areaWeighted ) {\\n\\n\\t\\t\\tif ( areaWeighted === undefined ) areaWeighted = true;\\n\\n\\t\\t\\tvar v, vl, f, fl, face, vertices;\\n\\n\\t\\t\\tvertices = new Array( this.vertices.length );\\n\\n\\t\\t\\tfor ( v = 0, vl = this.vertices.length; v < vl; v ++ ) {\\n\\n\\t\\t\\t\\tvertices[ v ] = new Vector3();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( areaWeighted ) {\\n\\n\\t\\t\\t\\t// vertex normals weighted by triangle areas\\n\\t\\t\\t\\t// http://www.iquilezles.org/www/articles/normals/normals.htm\\n\\n\\t\\t\\t\\tvar vA, vB, vC;\\n\\t\\t\\t\\tvar cb = new Vector3(), ab = new Vector3();\\n\\n\\t\\t\\t\\tfor ( f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\t\\tface = this.faces[ f ];\\n\\n\\t\\t\\t\\t\\tvA = this.vertices[ face.a ];\\n\\t\\t\\t\\t\\tvB = this.vertices[ face.b ];\\n\\t\\t\\t\\t\\tvC = this.vertices[ face.c ];\\n\\n\\t\\t\\t\\t\\tcb.subVectors( vC, vB );\\n\\t\\t\\t\\t\\tab.subVectors( vA, vB );\\n\\t\\t\\t\\t\\tcb.cross( ab );\\n\\n\\t\\t\\t\\t\\tvertices[ face.a ].add( cb );\\n\\t\\t\\t\\t\\tvertices[ face.b ].add( cb );\\n\\t\\t\\t\\t\\tvertices[ face.c ].add( cb );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.computeFaceNormals();\\n\\n\\t\\t\\t\\tfor ( f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\t\\tface = this.faces[ f ];\\n\\n\\t\\t\\t\\t\\tvertices[ face.a ].add( face.normal );\\n\\t\\t\\t\\t\\tvertices[ face.b ].add( face.normal );\\n\\t\\t\\t\\t\\tvertices[ face.c ].add( face.normal );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( v = 0, vl = this.vertices.length; v < vl; v ++ ) {\\n\\n\\t\\t\\t\\tvertices[ v ].normalize();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\tface = this.faces[ f ];\\n\\n\\t\\t\\t\\tvar vertexNormals = face.vertexNormals;\\n\\n\\t\\t\\t\\tif ( vertexNormals.length === 3 ) {\\n\\n\\t\\t\\t\\t\\tvertexNormals[ 0 ].copy( vertices[ face.a ] );\\n\\t\\t\\t\\t\\tvertexNormals[ 1 ].copy( vertices[ face.b ] );\\n\\t\\t\\t\\t\\tvertexNormals[ 2 ].copy( vertices[ face.c ] );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tvertexNormals[ 0 ] = vertices[ face.a ].clone();\\n\\t\\t\\t\\t\\tvertexNormals[ 1 ] = vertices[ face.b ].clone();\\n\\t\\t\\t\\t\\tvertexNormals[ 2 ] = vertices[ face.c ].clone();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.faces.length > 0 ) {\\n\\n\\t\\t\\t\\tthis.normalsNeedUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tcomputeFlatVertexNormals: function () {\\n\\n\\t\\t\\tvar f, fl, face;\\n\\n\\t\\t\\tthis.computeFaceNormals();\\n\\n\\t\\t\\tfor ( f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\tface = this.faces[ f ];\\n\\n\\t\\t\\t\\tvar vertexNormals = face.vertexNormals;\\n\\n\\t\\t\\t\\tif ( vertexNormals.length === 3 ) {\\n\\n\\t\\t\\t\\t\\tvertexNormals[ 0 ].copy( face.normal );\\n\\t\\t\\t\\t\\tvertexNormals[ 1 ].copy( face.normal );\\n\\t\\t\\t\\t\\tvertexNormals[ 2 ].copy( face.normal );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tvertexNormals[ 0 ] = face.normal.clone();\\n\\t\\t\\t\\t\\tvertexNormals[ 1 ] = face.normal.clone();\\n\\t\\t\\t\\t\\tvertexNormals[ 2 ] = face.normal.clone();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.faces.length > 0 ) {\\n\\n\\t\\t\\t\\tthis.normalsNeedUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tcomputeMorphNormals: function () {\\n\\n\\t\\t\\tvar i, il, f, fl, face;\\n\\n\\t\\t\\t// save original normals\\n\\t\\t\\t// - create temp variables on first access\\n\\t\\t\\t// otherwise just copy (for faster repeated calls)\\n\\n\\t\\t\\tfor ( f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\tface = this.faces[ f ];\\n\\n\\t\\t\\t\\tif ( ! face.__originalFaceNormal ) {\\n\\n\\t\\t\\t\\t\\tface.__originalFaceNormal = face.normal.clone();\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tface.__originalFaceNormal.copy( face.normal );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( ! face.__originalVertexNormals ) face.__originalVertexNormals = [];\\n\\n\\t\\t\\t\\tfor ( i = 0, il = face.vertexNormals.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tif ( ! face.__originalVertexNormals[ i ] ) {\\n\\n\\t\\t\\t\\t\\t\\tface.__originalVertexNormals[ i ] = face.vertexNormals[ i ].clone();\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tface.__originalVertexNormals[ i ].copy( face.vertexNormals[ i ] );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// use temp geometry to compute face and vertex normals for each morph\\n\\n\\t\\t\\tvar tmpGeo = new Geometry();\\n\\t\\t\\ttmpGeo.faces = this.faces;\\n\\n\\t\\t\\tfor ( i = 0, il = this.morphTargets.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t// create on first access\\n\\n\\t\\t\\t\\tif ( ! this.morphNormals[ i ] ) {\\n\\n\\t\\t\\t\\t\\tthis.morphNormals[ i ] = {};\\n\\t\\t\\t\\t\\tthis.morphNormals[ i ].faceNormals = [];\\n\\t\\t\\t\\t\\tthis.morphNormals[ i ].vertexNormals = [];\\n\\n\\t\\t\\t\\t\\tvar dstNormalsFace = this.morphNormals[ i ].faceNormals;\\n\\t\\t\\t\\t\\tvar dstNormalsVertex = this.morphNormals[ i ].vertexNormals;\\n\\n\\t\\t\\t\\t\\tvar faceNormal, vertexNormals;\\n\\n\\t\\t\\t\\t\\tfor ( f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tfaceNormal = new Vector3();\\n\\t\\t\\t\\t\\t\\tvertexNormals = { a: new Vector3(), b: new Vector3(), c: new Vector3() };\\n\\n\\t\\t\\t\\t\\t\\tdstNormalsFace.push( faceNormal );\\n\\t\\t\\t\\t\\t\\tdstNormalsVertex.push( vertexNormals );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar morphNormals = this.morphNormals[ i ];\\n\\n\\t\\t\\t\\t// set vertices to morph target\\n\\n\\t\\t\\t\\ttmpGeo.vertices = this.morphTargets[ i ].vertices;\\n\\n\\t\\t\\t\\t// compute morph normals\\n\\n\\t\\t\\t\\ttmpGeo.computeFaceNormals();\\n\\t\\t\\t\\ttmpGeo.computeVertexNormals();\\n\\n\\t\\t\\t\\t// store morph normals\\n\\n\\t\\t\\t\\tvar faceNormal, vertexNormals;\\n\\n\\t\\t\\t\\tfor ( f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\t\\tface = this.faces[ f ];\\n\\n\\t\\t\\t\\t\\tfaceNormal = morphNormals.faceNormals[ f ];\\n\\t\\t\\t\\t\\tvertexNormals = morphNormals.vertexNormals[ f ];\\n\\n\\t\\t\\t\\t\\tfaceNormal.copy( face.normal );\\n\\n\\t\\t\\t\\t\\tvertexNormals.a.copy( face.vertexNormals[ 0 ] );\\n\\t\\t\\t\\t\\tvertexNormals.b.copy( face.vertexNormals[ 1 ] );\\n\\t\\t\\t\\t\\tvertexNormals.c.copy( face.vertexNormals[ 2 ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// restore original normals\\n\\n\\t\\t\\tfor ( f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\tface = this.faces[ f ];\\n\\n\\t\\t\\t\\tface.normal = face.__originalFaceNormal;\\n\\t\\t\\t\\tface.vertexNormals = face.__originalVertexNormals;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tcomputeLineDistances: function () {\\n\\n\\t\\t\\tvar d = 0;\\n\\t\\t\\tvar vertices = this.vertices;\\n\\n\\t\\t\\tfor ( var i = 0, il = vertices.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tif ( i > 0 ) {\\n\\n\\t\\t\\t\\t\\td += vertices[ i ].distanceTo( vertices[ i - 1 ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.lineDistances[ i ] = d;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tcomputeBoundingBox: function () {\\n\\n\\t\\t\\tif ( this.boundingBox === null ) {\\n\\n\\t\\t\\t\\tthis.boundingBox = new Box3();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.boundingBox.setFromPoints( this.vertices );\\n\\n\\t\\t},\\n\\n\\t\\tcomputeBoundingSphere: function () {\\n\\n\\t\\t\\tif ( this.boundingSphere === null ) {\\n\\n\\t\\t\\t\\tthis.boundingSphere = new Sphere();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.boundingSphere.setFromPoints( this.vertices );\\n\\n\\t\\t},\\n\\n\\t\\tmerge: function ( geometry, matrix, materialIndexOffset ) {\\n\\n\\t\\t\\tif ( ! ( geometry && geometry.isGeometry ) ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.', geometry );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar normalMatrix,\\n\\t\\t\\t\\tvertexOffset = this.vertices.length,\\n\\t\\t\\t\\tvertices1 = this.vertices,\\n\\t\\t\\t\\tvertices2 = geometry.vertices,\\n\\t\\t\\t\\tfaces1 = this.faces,\\n\\t\\t\\t\\tfaces2 = geometry.faces,\\n\\t\\t\\t\\tuvs1 = this.faceVertexUvs[ 0 ],\\n\\t\\t\\t\\tuvs2 = geometry.faceVertexUvs[ 0 ],\\n\\t\\t\\t\\tcolors1 = this.colors,\\n\\t\\t\\t\\tcolors2 = geometry.colors;\\n\\n\\t\\t\\tif ( materialIndexOffset === undefined ) materialIndexOffset = 0;\\n\\n\\t\\t\\tif ( matrix !== undefined ) {\\n\\n\\t\\t\\t\\tnormalMatrix = new Matrix3().getNormalMatrix( matrix );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// vertices\\n\\n\\t\\t\\tfor ( var i = 0, il = vertices2.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar vertex = vertices2[ i ];\\n\\n\\t\\t\\t\\tvar vertexCopy = vertex.clone();\\n\\n\\t\\t\\t\\tif ( matrix !== undefined ) vertexCopy.applyMatrix4( matrix );\\n\\n\\t\\t\\t\\tvertices1.push( vertexCopy );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// colors\\n\\n\\t\\t\\tfor ( var i = 0, il = colors2.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tcolors1.push( colors2[ i ].clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// faces\\n\\n\\t\\t\\tfor ( i = 0, il = faces2.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar face = faces2[ i ], faceCopy, normal, color,\\n\\t\\t\\t\\t\\tfaceVertexNormals = face.vertexNormals,\\n\\t\\t\\t\\t\\tfaceVertexColors = face.vertexColors;\\n\\n\\t\\t\\t\\tfaceCopy = new Face3( face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset );\\n\\t\\t\\t\\tfaceCopy.normal.copy( face.normal );\\n\\n\\t\\t\\t\\tif ( normalMatrix !== undefined ) {\\n\\n\\t\\t\\t\\t\\tfaceCopy.normal.applyMatrix3( normalMatrix ).normalize();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfor ( var j = 0, jl = faceVertexNormals.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\tnormal = faceVertexNormals[ j ].clone();\\n\\n\\t\\t\\t\\t\\tif ( normalMatrix !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tnormal.applyMatrix3( normalMatrix ).normalize();\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tfaceCopy.vertexNormals.push( normal );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfaceCopy.color.copy( face.color );\\n\\n\\t\\t\\t\\tfor ( var j = 0, jl = faceVertexColors.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\tcolor = faceVertexColors[ j ];\\n\\t\\t\\t\\t\\tfaceCopy.vertexColors.push( color.clone() );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfaceCopy.materialIndex = face.materialIndex + materialIndexOffset;\\n\\n\\t\\t\\t\\tfaces1.push( faceCopy );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// uvs\\n\\n\\t\\t\\tfor ( i = 0, il = uvs2.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar uv = uvs2[ i ], uvCopy = [];\\n\\n\\t\\t\\t\\tif ( uv === undefined ) {\\n\\n\\t\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfor ( var j = 0, jl = uv.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\tuvCopy.push( uv[ j ].clone() );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tuvs1.push( uvCopy );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tmergeMesh: function ( mesh ) {\\n\\n\\t\\t\\tif ( ! ( mesh && mesh.isMesh ) ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.', mesh );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tmesh.matrixAutoUpdate && mesh.updateMatrix();\\n\\n\\t\\t\\tthis.merge( mesh.geometry, mesh.matrix );\\n\\n\\t\\t},\\n\\n\\t\\t/*\\n\\t\\t * Checks for duplicate vertices with hashmap.\\n\\t\\t * Duplicated vertices are removed\\n\\t\\t * and faces' vertices are updated.\\n\\t\\t */\\n\\n\\t\\tmergeVertices: function () {\\n\\n\\t\\t\\tvar verticesMap = {}; // Hashmap for looking up vertices by position coordinates (and making sure they are unique)\\n\\t\\t\\tvar unique = [], changes = [];\\n\\n\\t\\t\\tvar v, key;\\n\\t\\t\\tvar precisionPoints = 4; // number of decimal points, e.g. 4 for epsilon of 0.0001\\n\\t\\t\\tvar precision = Math.pow( 10, precisionPoints );\\n\\t\\t\\tvar i, il, face;\\n\\t\\t\\tvar indices, j, jl;\\n\\n\\t\\t\\tfor ( i = 0, il = this.vertices.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tv = this.vertices[ i ];\\n\\t\\t\\t\\tkey = Math.round( v.x * precision ) + '_' + Math.round( v.y * precision ) + '_' + Math.round( v.z * precision );\\n\\n\\t\\t\\t\\tif ( verticesMap[ key ] === undefined ) {\\n\\n\\t\\t\\t\\t\\tverticesMap[ key ] = i;\\n\\t\\t\\t\\t\\tunique.push( this.vertices[ i ] );\\n\\t\\t\\t\\t\\tchanges[ i ] = unique.length - 1;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t//console.log('Duplicate vertex found. ', i, ' could be using ', verticesMap[key]);\\n\\t\\t\\t\\t\\tchanges[ i ] = changes[ verticesMap[ key ] ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\n\\t\\t\\t// if faces are completely degenerate after merging vertices, we\\n\\t\\t\\t// have to remove them from the geometry.\\n\\t\\t\\tvar faceIndicesToRemove = [];\\n\\n\\t\\t\\tfor ( i = 0, il = this.faces.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tface = this.faces[ i ];\\n\\n\\t\\t\\t\\tface.a = changes[ face.a ];\\n\\t\\t\\t\\tface.b = changes[ face.b ];\\n\\t\\t\\t\\tface.c = changes[ face.c ];\\n\\n\\t\\t\\t\\tindices = [ face.a, face.b, face.c ];\\n\\n\\t\\t\\t\\t// if any duplicate vertices are found in a Face3\\n\\t\\t\\t\\t// we have to remove the face as nothing can be saved\\n\\t\\t\\t\\tfor ( var n = 0; n < 3; n ++ ) {\\n\\n\\t\\t\\t\\t\\tif ( indices[ n ] === indices[ ( n + 1 ) % 3 ] ) {\\n\\n\\t\\t\\t\\t\\t\\tfaceIndicesToRemove.push( i );\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( i = faceIndicesToRemove.length - 1; i >= 0; i -- ) {\\n\\n\\t\\t\\t\\tvar idx = faceIndicesToRemove[ i ];\\n\\n\\t\\t\\t\\tthis.faces.splice( idx, 1 );\\n\\n\\t\\t\\t\\tfor ( j = 0, jl = this.faceVertexUvs.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\tthis.faceVertexUvs[ j ].splice( idx, 1 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Use unique set of vertices\\n\\n\\t\\t\\tvar diff = this.vertices.length - unique.length;\\n\\t\\t\\tthis.vertices = unique;\\n\\t\\t\\treturn diff;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromPoints: function ( points ) {\\n\\n\\t\\t\\tthis.vertices = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = points.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar point = points[ i ];\\n\\t\\t\\t\\tthis.vertices.push( new Vector3( point.x, point.y, point.z || 0 ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsortFacesByMaterialIndex: function () {\\n\\n\\t\\t\\tvar faces = this.faces;\\n\\t\\t\\tvar length = faces.length;\\n\\n\\t\\t\\t// tag faces\\n\\n\\t\\t\\tfor ( var i = 0; i < length; i ++ ) {\\n\\n\\t\\t\\t\\tfaces[ i ]._id = i;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// sort faces\\n\\n\\t\\t\\tfunction materialIndexSort( a, b ) {\\n\\n\\t\\t\\t\\treturn a.materialIndex - b.materialIndex;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfaces.sort( materialIndexSort );\\n\\n\\t\\t\\t// sort uvs\\n\\n\\t\\t\\tvar uvs1 = this.faceVertexUvs[ 0 ];\\n\\t\\t\\tvar uvs2 = this.faceVertexUvs[ 1 ];\\n\\n\\t\\t\\tvar newUvs1, newUvs2;\\n\\n\\t\\t\\tif ( uvs1 && uvs1.length === length ) newUvs1 = [];\\n\\t\\t\\tif ( uvs2 && uvs2.length === length ) newUvs2 = [];\\n\\n\\t\\t\\tfor ( var i = 0; i < length; i ++ ) {\\n\\n\\t\\t\\t\\tvar id = faces[ i ]._id;\\n\\n\\t\\t\\t\\tif ( newUvs1 ) newUvs1.push( uvs1[ id ] );\\n\\t\\t\\t\\tif ( newUvs2 ) newUvs2.push( uvs2[ id ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( newUvs1 ) this.faceVertexUvs[ 0 ] = newUvs1;\\n\\t\\t\\tif ( newUvs2 ) this.faceVertexUvs[ 1 ] = newUvs2;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function () {\\n\\n\\t\\t\\tvar data = {\\n\\t\\t\\t\\tmetadata: {\\n\\t\\t\\t\\t\\tversion: 4.5,\\n\\t\\t\\t\\t\\ttype: 'Geometry',\\n\\t\\t\\t\\t\\tgenerator: 'Geometry.toJSON'\\n\\t\\t\\t\\t}\\n\\t\\t\\t};\\n\\n\\t\\t\\t// standard Geometry serialization\\n\\n\\t\\t\\tdata.uuid = this.uuid;\\n\\t\\t\\tdata.type = this.type;\\n\\t\\t\\tif ( this.name !== '' ) data.name = this.name;\\n\\n\\t\\t\\tif ( this.parameters !== undefined ) {\\n\\n\\t\\t\\t\\tvar parameters = this.parameters;\\n\\n\\t\\t\\t\\tfor ( var key in parameters ) {\\n\\n\\t\\t\\t\\t\\tif ( parameters[ key ] !== undefined ) data[ key ] = parameters[ key ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn data;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar vertices = [];\\n\\n\\t\\t\\tfor ( var i = 0; i < this.vertices.length; i ++ ) {\\n\\n\\t\\t\\t\\tvar vertex = this.vertices[ i ];\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar faces = [];\\n\\t\\t\\tvar normals = [];\\n\\t\\t\\tvar normalsHash = {};\\n\\t\\t\\tvar colors = [];\\n\\t\\t\\tvar colorsHash = {};\\n\\t\\t\\tvar uvs = [];\\n\\t\\t\\tvar uvsHash = {};\\n\\n\\t\\t\\tfor ( var i = 0; i < this.faces.length; i ++ ) {\\n\\n\\t\\t\\t\\tvar face = this.faces[ i ];\\n\\n\\t\\t\\t\\tvar hasMaterial = true;\\n\\t\\t\\t\\tvar hasFaceUv = false; // deprecated\\n\\t\\t\\t\\tvar hasFaceVertexUv = this.faceVertexUvs[ 0 ][ i ] !== undefined;\\n\\t\\t\\t\\tvar hasFaceNormal = face.normal.length() > 0;\\n\\t\\t\\t\\tvar hasFaceVertexNormal = face.vertexNormals.length > 0;\\n\\t\\t\\t\\tvar hasFaceColor = face.color.r !== 1 || face.color.g !== 1 || face.color.b !== 1;\\n\\t\\t\\t\\tvar hasFaceVertexColor = face.vertexColors.length > 0;\\n\\n\\t\\t\\t\\tvar faceType = 0;\\n\\n\\t\\t\\t\\tfaceType = setBit( faceType, 0, 0 ); // isQuad\\n\\t\\t\\t\\tfaceType = setBit( faceType, 1, hasMaterial );\\n\\t\\t\\t\\tfaceType = setBit( faceType, 2, hasFaceUv );\\n\\t\\t\\t\\tfaceType = setBit( faceType, 3, hasFaceVertexUv );\\n\\t\\t\\t\\tfaceType = setBit( faceType, 4, hasFaceNormal );\\n\\t\\t\\t\\tfaceType = setBit( faceType, 5, hasFaceVertexNormal );\\n\\t\\t\\t\\tfaceType = setBit( faceType, 6, hasFaceColor );\\n\\t\\t\\t\\tfaceType = setBit( faceType, 7, hasFaceVertexColor );\\n\\n\\t\\t\\t\\tfaces.push( faceType );\\n\\t\\t\\t\\tfaces.push( face.a, face.b, face.c );\\n\\t\\t\\t\\tfaces.push( face.materialIndex );\\n\\n\\t\\t\\t\\tif ( hasFaceVertexUv ) {\\n\\n\\t\\t\\t\\t\\tvar faceVertexUvs = this.faceVertexUvs[ 0 ][ i ];\\n\\n\\t\\t\\t\\t\\tfaces.push(\\n\\t\\t\\t\\t\\t\\tgetUvIndex( faceVertexUvs[ 0 ] ),\\n\\t\\t\\t\\t\\t\\tgetUvIndex( faceVertexUvs[ 1 ] ),\\n\\t\\t\\t\\t\\t\\tgetUvIndex( faceVertexUvs[ 2 ] )\\n\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( hasFaceNormal ) {\\n\\n\\t\\t\\t\\t\\tfaces.push( getNormalIndex( face.normal ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( hasFaceVertexNormal ) {\\n\\n\\t\\t\\t\\t\\tvar vertexNormals = face.vertexNormals;\\n\\n\\t\\t\\t\\t\\tfaces.push(\\n\\t\\t\\t\\t\\t\\tgetNormalIndex( vertexNormals[ 0 ] ),\\n\\t\\t\\t\\t\\t\\tgetNormalIndex( vertexNormals[ 1 ] ),\\n\\t\\t\\t\\t\\t\\tgetNormalIndex( vertexNormals[ 2 ] )\\n\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( hasFaceColor ) {\\n\\n\\t\\t\\t\\t\\tfaces.push( getColorIndex( face.color ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( hasFaceVertexColor ) {\\n\\n\\t\\t\\t\\t\\tvar vertexColors = face.vertexColors;\\n\\n\\t\\t\\t\\t\\tfaces.push(\\n\\t\\t\\t\\t\\t\\tgetColorIndex( vertexColors[ 0 ] ),\\n\\t\\t\\t\\t\\t\\tgetColorIndex( vertexColors[ 1 ] ),\\n\\t\\t\\t\\t\\t\\tgetColorIndex( vertexColors[ 2 ] )\\n\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction setBit( value, position, enabled ) {\\n\\n\\t\\t\\t\\treturn enabled ? value | ( 1 << position ) : value & ( ~ ( 1 << position ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction getNormalIndex( normal ) {\\n\\n\\t\\t\\t\\tvar hash = normal.x.toString() + normal.y.toString() + normal.z.toString();\\n\\n\\t\\t\\t\\tif ( normalsHash[ hash ] !== undefined ) {\\n\\n\\t\\t\\t\\t\\treturn normalsHash[ hash ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tnormalsHash[ hash ] = normals.length / 3;\\n\\t\\t\\t\\tnormals.push( normal.x, normal.y, normal.z );\\n\\n\\t\\t\\t\\treturn normalsHash[ hash ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction getColorIndex( color ) {\\n\\n\\t\\t\\t\\tvar hash = color.r.toString() + color.g.toString() + color.b.toString();\\n\\n\\t\\t\\t\\tif ( colorsHash[ hash ] !== undefined ) {\\n\\n\\t\\t\\t\\t\\treturn colorsHash[ hash ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tcolorsHash[ hash ] = colors.length;\\n\\t\\t\\t\\tcolors.push( color.getHex() );\\n\\n\\t\\t\\t\\treturn colorsHash[ hash ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction getUvIndex( uv ) {\\n\\n\\t\\t\\t\\tvar hash = uv.x.toString() + uv.y.toString();\\n\\n\\t\\t\\t\\tif ( uvsHash[ hash ] !== undefined ) {\\n\\n\\t\\t\\t\\t\\treturn uvsHash[ hash ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tuvsHash[ hash ] = uvs.length / 2;\\n\\t\\t\\t\\tuvs.push( uv.x, uv.y );\\n\\n\\t\\t\\t\\treturn uvsHash[ hash ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tdata.data = {};\\n\\n\\t\\t\\tdata.data.vertices = vertices;\\n\\t\\t\\tdata.data.normals = normals;\\n\\t\\t\\tif ( colors.length > 0 ) data.data.colors = colors;\\n\\t\\t\\tif ( uvs.length > 0 ) data.data.uvs = [ uvs ]; // temporal backward compatibility\\n\\t\\t\\tdata.data.faces = faces;\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\t/*\\n\\t\\t\\t // Handle primitives\\n\\n\\t\\t\\t var parameters = this.parameters;\\n\\n\\t\\t\\t if ( parameters !== undefined ) {\\n\\n\\t\\t\\t var values = [];\\n\\n\\t\\t\\t for ( var key in parameters ) {\\n\\n\\t\\t\\t values.push( parameters[ key ] );\\n\\n\\t\\t\\t }\\n\\n\\t\\t\\t var geometry = Object.create( this.constructor.prototype );\\n\\t\\t\\t this.constructor.apply( geometry, values );\\n\\t\\t\\t return geometry;\\n\\n\\t\\t\\t }\\n\\n\\t\\t\\t return new this.constructor().copy( this );\\n\\t\\t\\t */\\n\\n\\t\\t\\treturn new Geometry().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tvar i, il, j, jl, k, kl;\\n\\n\\t\\t\\t// reset\\n\\n\\t\\t\\tthis.vertices = [];\\n\\t\\t\\tthis.colors = [];\\n\\t\\t\\tthis.faces = [];\\n\\t\\t\\tthis.faceVertexUvs = [[]];\\n\\t\\t\\tthis.morphTargets = [];\\n\\t\\t\\tthis.morphNormals = [];\\n\\t\\t\\tthis.skinWeights = [];\\n\\t\\t\\tthis.skinIndices = [];\\n\\t\\t\\tthis.lineDistances = [];\\n\\t\\t\\tthis.boundingBox = null;\\n\\t\\t\\tthis.boundingSphere = null;\\n\\n\\t\\t\\t// name\\n\\n\\t\\t\\tthis.name = source.name;\\n\\n\\t\\t\\t// vertices\\n\\n\\t\\t\\tvar vertices = source.vertices;\\n\\n\\t\\t\\tfor ( i = 0, il = vertices.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.vertices.push( vertices[ i ].clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// colors\\n\\n\\t\\t\\tvar colors = source.colors;\\n\\n\\t\\t\\tfor ( i = 0, il = colors.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.colors.push( colors[ i ].clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// faces\\n\\n\\t\\t\\tvar faces = source.faces;\\n\\n\\t\\t\\tfor ( i = 0, il = faces.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.faces.push( faces[ i ].clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// face vertex uvs\\n\\n\\t\\t\\tfor ( i = 0, il = source.faceVertexUvs.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar faceVertexUvs = source.faceVertexUvs[ i ];\\n\\n\\t\\t\\t\\tif ( this.faceVertexUvs[ i ] === undefined ) {\\n\\n\\t\\t\\t\\t\\tthis.faceVertexUvs[ i ] = [];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfor ( j = 0, jl = faceVertexUvs.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\tvar uvs = faceVertexUvs[ j ], uvsCopy = [];\\n\\n\\t\\t\\t\\t\\tfor ( k = 0, kl = uvs.length; k < kl; k ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar uv = uvs[ k ];\\n\\n\\t\\t\\t\\t\\t\\tuvsCopy.push( uv.clone() );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tthis.faceVertexUvs[ i ].push( uvsCopy );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// morph targets\\n\\n\\t\\t\\tvar morphTargets = source.morphTargets;\\n\\n\\t\\t\\tfor ( i = 0, il = morphTargets.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar morphTarget = {};\\n\\t\\t\\t\\tmorphTarget.name = morphTargets[ i ].name;\\n\\n\\t\\t\\t\\t// vertices\\n\\n\\t\\t\\t\\tif ( morphTargets[ i ].vertices !== undefined ) {\\n\\n\\t\\t\\t\\t\\tmorphTarget.vertices = [];\\n\\n\\t\\t\\t\\t\\tfor ( j = 0, jl = morphTargets[ i ].vertices.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tmorphTarget.vertices.push( morphTargets[ i ].vertices[ j ].clone() );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// normals\\n\\n\\t\\t\\t\\tif ( morphTargets[ i ].normals !== undefined ) {\\n\\n\\t\\t\\t\\t\\tmorphTarget.normals = [];\\n\\n\\t\\t\\t\\t\\tfor ( j = 0, jl = morphTargets[ i ].normals.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tmorphTarget.normals.push( morphTargets[ i ].normals[ j ].clone() );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.morphTargets.push( morphTarget );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// morph normals\\n\\n\\t\\t\\tvar morphNormals = source.morphNormals;\\n\\n\\t\\t\\tfor ( i = 0, il = morphNormals.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar morphNormal = {};\\n\\n\\t\\t\\t\\t// vertex normals\\n\\n\\t\\t\\t\\tif ( morphNormals[ i ].vertexNormals !== undefined ) {\\n\\n\\t\\t\\t\\t\\tmorphNormal.vertexNormals = [];\\n\\n\\t\\t\\t\\t\\tfor ( j = 0, jl = morphNormals[ i ].vertexNormals.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar srcVertexNormal = morphNormals[ i ].vertexNormals[ j ];\\n\\t\\t\\t\\t\\t\\tvar destVertexNormal = {};\\n\\n\\t\\t\\t\\t\\t\\tdestVertexNormal.a = srcVertexNormal.a.clone();\\n\\t\\t\\t\\t\\t\\tdestVertexNormal.b = srcVertexNormal.b.clone();\\n\\t\\t\\t\\t\\t\\tdestVertexNormal.c = srcVertexNormal.c.clone();\\n\\n\\t\\t\\t\\t\\t\\tmorphNormal.vertexNormals.push( destVertexNormal );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// face normals\\n\\n\\t\\t\\t\\tif ( morphNormals[ i ].faceNormals !== undefined ) {\\n\\n\\t\\t\\t\\t\\tmorphNormal.faceNormals = [];\\n\\n\\t\\t\\t\\t\\tfor ( j = 0, jl = morphNormals[ i ].faceNormals.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tmorphNormal.faceNormals.push( morphNormals[ i ].faceNormals[ j ].clone() );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.morphNormals.push( morphNormal );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// skin weights\\n\\n\\t\\t\\tvar skinWeights = source.skinWeights;\\n\\n\\t\\t\\tfor ( i = 0, il = skinWeights.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.skinWeights.push( skinWeights[ i ].clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// skin indices\\n\\n\\t\\t\\tvar skinIndices = source.skinIndices;\\n\\n\\t\\t\\tfor ( i = 0, il = skinIndices.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.skinIndices.push( skinIndices[ i ].clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// line distances\\n\\n\\t\\t\\tvar lineDistances = source.lineDistances;\\n\\n\\t\\t\\tfor ( i = 0, il = lineDistances.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.lineDistances.push( lineDistances[ i ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// bounding box\\n\\n\\t\\t\\tvar boundingBox = source.boundingBox;\\n\\n\\t\\t\\tif ( boundingBox !== null ) {\\n\\n\\t\\t\\t\\tthis.boundingBox = boundingBox.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// bounding sphere\\n\\n\\t\\t\\tvar boundingSphere = source.boundingSphere;\\n\\n\\t\\t\\tif ( boundingSphere !== null ) {\\n\\n\\t\\t\\t\\tthis.boundingSphere = boundingSphere.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// update flags\\n\\n\\t\\t\\tthis.elementsNeedUpdate = source.elementsNeedUpdate;\\n\\t\\t\\tthis.verticesNeedUpdate = source.verticesNeedUpdate;\\n\\t\\t\\tthis.uvsNeedUpdate = source.uvsNeedUpdate;\\n\\t\\t\\tthis.normalsNeedUpdate = source.normalsNeedUpdate;\\n\\t\\t\\tthis.colorsNeedUpdate = source.colorsNeedUpdate;\\n\\t\\t\\tthis.lineDistancesNeedUpdate = source.lineDistancesNeedUpdate;\\n\\t\\t\\tthis.groupsNeedUpdate = source.groupsNeedUpdate;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdispose: function () {\\n\\n\\t\\t\\tthis.dispatchEvent( { type: 'dispose' } );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tif ( Array.isArray( array ) ) {\\n\\n\\t\\t\\tthrow new TypeError( 'THREE.BufferAttribute: array should be a Typed Array.' );\\n\\n\\t\\t}\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\t\\tthis.name = '';\\n\\n\\t\\tthis.array = array;\\n\\t\\tthis.itemSize = itemSize;\\n\\t\\tthis.count = array !== undefined ? array.length / itemSize : 0;\\n\\t\\tthis.normalized = normalized === true;\\n\\n\\t\\tthis.dynamic = false;\\n\\t\\tthis.updateRange = { offset: 0, count: - 1 };\\n\\n\\t\\tthis.onUploadCallback = function () {};\\n\\n\\t\\tthis.version = 0;\\n\\n\\t}\\n\\n\\tObject.defineProperty( BufferAttribute.prototype, 'needsUpdate', {\\n\\n\\t\\tset: function ( value ) {\\n\\n\\t\\t\\tif ( value === true ) this.version ++;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( BufferAttribute.prototype, {\\n\\n\\t\\tisBufferAttribute: true,\\n\\n\\t\\tsetArray: function ( array ) {\\n\\n\\t\\t\\tif ( Array.isArray( array ) ) {\\n\\n\\t\\t\\t\\tthrow new TypeError( 'THREE.BufferAttribute: array should be a Typed Array.' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.count = array !== undefined ? array.length / this.itemSize : 0;\\n\\t\\t\\tthis.array = array;\\n\\n\\t\\t},\\n\\n\\t\\tsetDynamic: function ( value ) {\\n\\n\\t\\t\\tthis.dynamic = value;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tthis.array = new source.array.constructor( source.array );\\n\\t\\t\\tthis.itemSize = source.itemSize;\\n\\t\\t\\tthis.count = source.count;\\n\\t\\t\\tthis.normalized = source.normalized;\\n\\n\\t\\t\\tthis.dynamic = source.dynamic;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyAt: function ( index1, attribute, index2 ) {\\n\\n\\t\\t\\tindex1 *= this.itemSize;\\n\\t\\t\\tindex2 *= attribute.itemSize;\\n\\n\\t\\t\\tfor ( var i = 0, l = this.itemSize; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tthis.array[ index1 + i ] = attribute.array[ index2 + i ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyArray: function ( array ) {\\n\\n\\t\\t\\tthis.array.set( array );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyColorsArray: function ( colors ) {\\n\\n\\t\\t\\tvar array = this.array, offset = 0;\\n\\n\\t\\t\\tfor ( var i = 0, l = colors.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar color = colors[ i ];\\n\\n\\t\\t\\t\\tif ( color === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.BufferAttribute.copyColorsArray(): color is undefined', i );\\n\\t\\t\\t\\t\\tcolor = new Color();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tarray[ offset ++ ] = color.r;\\n\\t\\t\\t\\tarray[ offset ++ ] = color.g;\\n\\t\\t\\t\\tarray[ offset ++ ] = color.b;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyIndicesArray: function ( indices ) {\\n\\n\\t\\t\\tvar array = this.array, offset = 0;\\n\\n\\t\\t\\tfor ( var i = 0, l = indices.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar index = indices[ i ];\\n\\n\\t\\t\\t\\tarray[ offset ++ ] = index.a;\\n\\t\\t\\t\\tarray[ offset ++ ] = index.b;\\n\\t\\t\\t\\tarray[ offset ++ ] = index.c;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyVector2sArray: function ( vectors ) {\\n\\n\\t\\t\\tvar array = this.array, offset = 0;\\n\\n\\t\\t\\tfor ( var i = 0, l = vectors.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar vector = vectors[ i ];\\n\\n\\t\\t\\t\\tif ( vector === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.BufferAttribute.copyVector2sArray(): vector is undefined', i );\\n\\t\\t\\t\\t\\tvector = new Vector2();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.x;\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.y;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyVector3sArray: function ( vectors ) {\\n\\n\\t\\t\\tvar array = this.array, offset = 0;\\n\\n\\t\\t\\tfor ( var i = 0, l = vectors.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar vector = vectors[ i ];\\n\\n\\t\\t\\t\\tif ( vector === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.BufferAttribute.copyVector3sArray(): vector is undefined', i );\\n\\t\\t\\t\\t\\tvector = new Vector3();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.x;\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.y;\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.z;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyVector4sArray: function ( vectors ) {\\n\\n\\t\\t\\tvar array = this.array, offset = 0;\\n\\n\\t\\t\\tfor ( var i = 0, l = vectors.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar vector = vectors[ i ];\\n\\n\\t\\t\\t\\tif ( vector === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.BufferAttribute.copyVector4sArray(): vector is undefined', i );\\n\\t\\t\\t\\t\\tvector = new Vector4();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.x;\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.y;\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.z;\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.w;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tset: function ( value, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tthis.array.set( value, offset );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetX: function ( index ) {\\n\\n\\t\\t\\treturn this.array[ index * this.itemSize ];\\n\\n\\t\\t},\\n\\n\\t\\tsetX: function ( index, x ) {\\n\\n\\t\\t\\tthis.array[ index * this.itemSize ] = x;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetY: function ( index ) {\\n\\n\\t\\t\\treturn this.array[ index * this.itemSize + 1 ];\\n\\n\\t\\t},\\n\\n\\t\\tsetY: function ( index, y ) {\\n\\n\\t\\t\\tthis.array[ index * this.itemSize + 1 ] = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetZ: function ( index ) {\\n\\n\\t\\t\\treturn this.array[ index * this.itemSize + 2 ];\\n\\n\\t\\t},\\n\\n\\t\\tsetZ: function ( index, z ) {\\n\\n\\t\\t\\tthis.array[ index * this.itemSize + 2 ] = z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetW: function ( index ) {\\n\\n\\t\\t\\treturn this.array[ index * this.itemSize + 3 ];\\n\\n\\t\\t},\\n\\n\\t\\tsetW: function ( index, w ) {\\n\\n\\t\\t\\tthis.array[ index * this.itemSize + 3 ] = w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetXY: function ( index, x, y ) {\\n\\n\\t\\t\\tindex *= this.itemSize;\\n\\n\\t\\t\\tthis.array[ index + 0 ] = x;\\n\\t\\t\\tthis.array[ index + 1 ] = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetXYZ: function ( index, x, y, z ) {\\n\\n\\t\\t\\tindex *= this.itemSize;\\n\\n\\t\\t\\tthis.array[ index + 0 ] = x;\\n\\t\\t\\tthis.array[ index + 1 ] = y;\\n\\t\\t\\tthis.array[ index + 2 ] = z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetXYZW: function ( index, x, y, z, w ) {\\n\\n\\t\\t\\tindex *= this.itemSize;\\n\\n\\t\\t\\tthis.array[ index + 0 ] = x;\\n\\t\\t\\tthis.array[ index + 1 ] = y;\\n\\t\\t\\tthis.array[ index + 2 ] = z;\\n\\t\\t\\tthis.array[ index + 3 ] = w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tonUpload: function ( callback ) {\\n\\n\\t\\t\\tthis.onUploadCallback = callback;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.array, this.itemSize ).copy( this );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tfunction Int8BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Int8Array( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tInt8BufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tInt8BufferAttribute.prototype.constructor = Int8BufferAttribute;\\n\\n\\n\\tfunction Uint8BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Uint8Array( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tUint8BufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tUint8BufferAttribute.prototype.constructor = Uint8BufferAttribute;\\n\\n\\n\\tfunction Uint8ClampedBufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Uint8ClampedArray( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tUint8ClampedBufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tUint8ClampedBufferAttribute.prototype.constructor = Uint8ClampedBufferAttribute;\\n\\n\\n\\tfunction Int16BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Int16Array( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tInt16BufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tInt16BufferAttribute.prototype.constructor = Int16BufferAttribute;\\n\\n\\n\\tfunction Uint16BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Uint16Array( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tUint16BufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tUint16BufferAttribute.prototype.constructor = Uint16BufferAttribute;\\n\\n\\n\\tfunction Int32BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Int32Array( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tInt32BufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tInt32BufferAttribute.prototype.constructor = Int32BufferAttribute;\\n\\n\\n\\tfunction Uint32BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Uint32Array( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tUint32BufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tUint32BufferAttribute.prototype.constructor = Uint32BufferAttribute;\\n\\n\\n\\tfunction Float32BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Float32Array( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tFloat32BufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tFloat32BufferAttribute.prototype.constructor = Float32BufferAttribute;\\n\\n\\n\\tfunction Float64BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Float64Array( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tFloat64BufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tFloat64BufferAttribute.prototype.constructor = Float64BufferAttribute;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction DirectGeometry() {\\n\\n\\t\\tthis.indices = [];\\n\\t\\tthis.vertices = [];\\n\\t\\tthis.normals = [];\\n\\t\\tthis.colors = [];\\n\\t\\tthis.uvs = [];\\n\\t\\tthis.uvs2 = [];\\n\\n\\t\\tthis.groups = [];\\n\\n\\t\\tthis.morphTargets = {};\\n\\n\\t\\tthis.skinWeights = [];\\n\\t\\tthis.skinIndices = [];\\n\\n\\t\\t// this.lineDistances = [];\\n\\n\\t\\tthis.boundingBox = null;\\n\\t\\tthis.boundingSphere = null;\\n\\n\\t\\t// update flags\\n\\n\\t\\tthis.verticesNeedUpdate = false;\\n\\t\\tthis.normalsNeedUpdate = false;\\n\\t\\tthis.colorsNeedUpdate = false;\\n\\t\\tthis.uvsNeedUpdate = false;\\n\\t\\tthis.groupsNeedUpdate = false;\\n\\n\\t}\\n\\n\\tObject.assign( DirectGeometry.prototype, {\\n\\n\\t\\tcomputeGroups: function ( geometry ) {\\n\\n\\t\\t\\tvar group;\\n\\t\\t\\tvar groups = [];\\n\\t\\t\\tvar materialIndex = undefined;\\n\\n\\t\\t\\tvar faces = geometry.faces;\\n\\n\\t\\t\\tfor ( var i = 0; i < faces.length; i ++ ) {\\n\\n\\t\\t\\t\\tvar face = faces[ i ];\\n\\n\\t\\t\\t\\t// materials\\n\\n\\t\\t\\t\\tif ( face.materialIndex !== materialIndex ) {\\n\\n\\t\\t\\t\\t\\tmaterialIndex = face.materialIndex;\\n\\n\\t\\t\\t\\t\\tif ( group !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tgroup.count = ( i * 3 ) - group.start;\\n\\t\\t\\t\\t\\t\\tgroups.push( group );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tgroup = {\\n\\t\\t\\t\\t\\t\\tstart: i * 3,\\n\\t\\t\\t\\t\\t\\tmaterialIndex: materialIndex\\n\\t\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( group !== undefined ) {\\n\\n\\t\\t\\t\\tgroup.count = ( i * 3 ) - group.start;\\n\\t\\t\\t\\tgroups.push( group );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.groups = groups;\\n\\n\\t\\t},\\n\\n\\t\\tfromGeometry: function ( geometry ) {\\n\\n\\t\\t\\tvar faces = geometry.faces;\\n\\t\\t\\tvar vertices = geometry.vertices;\\n\\t\\t\\tvar faceVertexUvs = geometry.faceVertexUvs;\\n\\n\\t\\t\\tvar hasFaceVertexUv = faceVertexUvs[ 0 ] && faceVertexUvs[ 0 ].length > 0;\\n\\t\\t\\tvar hasFaceVertexUv2 = faceVertexUvs[ 1 ] && faceVertexUvs[ 1 ].length > 0;\\n\\n\\t\\t\\t// morphs\\n\\n\\t\\t\\tvar morphTargets = geometry.morphTargets;\\n\\t\\t\\tvar morphTargetsLength = morphTargets.length;\\n\\n\\t\\t\\tvar morphTargetsPosition;\\n\\n\\t\\t\\tif ( morphTargetsLength > 0 ) {\\n\\n\\t\\t\\t\\tmorphTargetsPosition = [];\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < morphTargetsLength; i ++ ) {\\n\\n\\t\\t\\t\\t\\tmorphTargetsPosition[ i ] = [];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.morphTargets.position = morphTargetsPosition;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar morphNormals = geometry.morphNormals;\\n\\t\\t\\tvar morphNormalsLength = morphNormals.length;\\n\\n\\t\\t\\tvar morphTargetsNormal;\\n\\n\\t\\t\\tif ( morphNormalsLength > 0 ) {\\n\\n\\t\\t\\t\\tmorphTargetsNormal = [];\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < morphNormalsLength; i ++ ) {\\n\\n\\t\\t\\t\\t\\tmorphTargetsNormal[ i ] = [];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.morphTargets.normal = morphTargetsNormal;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// skins\\n\\n\\t\\t\\tvar skinIndices = geometry.skinIndices;\\n\\t\\t\\tvar skinWeights = geometry.skinWeights;\\n\\n\\t\\t\\tvar hasSkinIndices = skinIndices.length === vertices.length;\\n\\t\\t\\tvar hasSkinWeights = skinWeights.length === vertices.length;\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tfor ( var i = 0; i < faces.length; i ++ ) {\\n\\n\\t\\t\\t\\tvar face = faces[ i ];\\n\\n\\t\\t\\t\\tthis.vertices.push( vertices[ face.a ], vertices[ face.b ], vertices[ face.c ] );\\n\\n\\t\\t\\t\\tvar vertexNormals = face.vertexNormals;\\n\\n\\t\\t\\t\\tif ( vertexNormals.length === 3 ) {\\n\\n\\t\\t\\t\\t\\tthis.normals.push( vertexNormals[ 0 ], vertexNormals[ 1 ], vertexNormals[ 2 ] );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tvar normal = face.normal;\\n\\n\\t\\t\\t\\t\\tthis.normals.push( normal, normal, normal );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar vertexColors = face.vertexColors;\\n\\n\\t\\t\\t\\tif ( vertexColors.length === 3 ) {\\n\\n\\t\\t\\t\\t\\tthis.colors.push( vertexColors[ 0 ], vertexColors[ 1 ], vertexColors[ 2 ] );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tvar color = face.color;\\n\\n\\t\\t\\t\\t\\tthis.colors.push( color, color, color );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( hasFaceVertexUv === true ) {\\n\\n\\t\\t\\t\\t\\tvar vertexUvs = faceVertexUvs[ 0 ][ i ];\\n\\n\\t\\t\\t\\t\\tif ( vertexUvs !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tthis.uvs.push( vertexUvs[ 0 ], vertexUvs[ 1 ], vertexUvs[ 2 ] );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.DirectGeometry.fromGeometry(): Undefined vertexUv ', i );\\n\\n\\t\\t\\t\\t\\t\\tthis.uvs.push( new Vector2(), new Vector2(), new Vector2() );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( hasFaceVertexUv2 === true ) {\\n\\n\\t\\t\\t\\t\\tvar vertexUvs = faceVertexUvs[ 1 ][ i ];\\n\\n\\t\\t\\t\\t\\tif ( vertexUvs !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tthis.uvs2.push( vertexUvs[ 0 ], vertexUvs[ 1 ], vertexUvs[ 2 ] );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.DirectGeometry.fromGeometry(): Undefined vertexUv2 ', i );\\n\\n\\t\\t\\t\\t\\t\\tthis.uvs2.push( new Vector2(), new Vector2(), new Vector2() );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// morphs\\n\\n\\t\\t\\t\\tfor ( var j = 0; j < morphTargetsLength; j ++ ) {\\n\\n\\t\\t\\t\\t\\tvar morphTarget = morphTargets[ j ].vertices;\\n\\n\\t\\t\\t\\t\\tmorphTargetsPosition[ j ].push( morphTarget[ face.a ], morphTarget[ face.b ], morphTarget[ face.c ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfor ( var j = 0; j < morphNormalsLength; j ++ ) {\\n\\n\\t\\t\\t\\t\\tvar morphNormal = morphNormals[ j ].vertexNormals[ i ];\\n\\n\\t\\t\\t\\t\\tmorphTargetsNormal[ j ].push( morphNormal.a, morphNormal.b, morphNormal.c );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// skins\\n\\n\\t\\t\\t\\tif ( hasSkinIndices ) {\\n\\n\\t\\t\\t\\t\\tthis.skinIndices.push( skinIndices[ face.a ], skinIndices[ face.b ], skinIndices[ face.c ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( hasSkinWeights ) {\\n\\n\\t\\t\\t\\t\\tthis.skinWeights.push( skinWeights[ face.a ], skinWeights[ face.b ], skinWeights[ face.c ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.computeGroups( geometry );\\n\\n\\t\\t\\tthis.verticesNeedUpdate = geometry.verticesNeedUpdate;\\n\\t\\t\\tthis.normalsNeedUpdate = geometry.normalsNeedUpdate;\\n\\t\\t\\tthis.colorsNeedUpdate = geometry.colorsNeedUpdate;\\n\\t\\t\\tthis.uvsNeedUpdate = geometry.uvsNeedUpdate;\\n\\t\\t\\tthis.groupsNeedUpdate = geometry.groupsNeedUpdate;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction arrayMax( array ) {\\n\\n\\t\\tif ( array.length === 0 ) return - Infinity;\\n\\n\\t\\tvar max = array[ 0 ];\\n\\n\\t\\tfor ( var i = 1, l = array.length; i < l; ++ i ) {\\n\\n\\t\\t\\tif ( array[ i ] > max ) max = array[ i ];\\n\\n\\t\\t}\\n\\n\\t\\treturn max;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tvar bufferGeometryId = 1; // BufferGeometry uses odd numbers as Id\\n\\n\\tfunction BufferGeometry() {\\n\\n\\t\\tObject.defineProperty( this, 'id', { value: bufferGeometryId += 2 } );\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.name = '';\\n\\t\\tthis.type = 'BufferGeometry';\\n\\n\\t\\tthis.index = null;\\n\\t\\tthis.attributes = {};\\n\\n\\t\\tthis.morphAttributes = {};\\n\\n\\t\\tthis.groups = [];\\n\\n\\t\\tthis.boundingBox = null;\\n\\t\\tthis.boundingSphere = null;\\n\\n\\t\\tthis.drawRange = { start: 0, count: Infinity };\\n\\n\\t}\\n\\n\\tBufferGeometry.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {\\n\\n\\t\\tconstructor: BufferGeometry,\\n\\n\\t\\tisBufferGeometry: true,\\n\\n\\t\\tgetIndex: function () {\\n\\n\\t\\t\\treturn this.index;\\n\\n\\t\\t},\\n\\n\\t\\tsetIndex: function ( index ) {\\n\\n\\t\\t\\tif ( Array.isArray( index ) ) {\\n\\n\\t\\t\\t\\tthis.index = new ( arrayMax( index ) > 65535 ? Uint32BufferAttribute : Uint16BufferAttribute )( index, 1 );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.index = index;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\taddAttribute: function ( name, attribute ) {\\n\\n\\t\\t\\tif ( ! ( attribute && attribute.isBufferAttribute ) && ! ( attribute && attribute.isInterleavedBufferAttribute ) ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.BufferGeometry: .addAttribute() now expects ( name, attribute ).' );\\n\\n\\t\\t\\t\\tthis.addAttribute( name, new BufferAttribute( arguments[ 1 ], arguments[ 2 ] ) );\\n\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( name === 'index' ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute.' );\\n\\t\\t\\t\\tthis.setIndex( attribute );\\n\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.attributes[ name ] = attribute;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetAttribute: function ( name ) {\\n\\n\\t\\t\\treturn this.attributes[ name ];\\n\\n\\t\\t},\\n\\n\\t\\tremoveAttribute: function ( name ) {\\n\\n\\t\\t\\tdelete this.attributes[ name ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddGroup: function ( start, count, materialIndex ) {\\n\\n\\t\\t\\tthis.groups.push( {\\n\\n\\t\\t\\t\\tstart: start,\\n\\t\\t\\t\\tcount: count,\\n\\t\\t\\t\\tmaterialIndex: materialIndex !== undefined ? materialIndex : 0\\n\\n\\t\\t\\t} );\\n\\n\\t\\t},\\n\\n\\t\\tclearGroups: function () {\\n\\n\\t\\t\\tthis.groups = [];\\n\\n\\t\\t},\\n\\n\\t\\tsetDrawRange: function ( start, count ) {\\n\\n\\t\\t\\tthis.drawRange.start = start;\\n\\t\\t\\tthis.drawRange.count = count;\\n\\n\\t\\t},\\n\\n\\t\\tapplyMatrix: function ( matrix ) {\\n\\n\\t\\t\\tvar position = this.attributes.position;\\n\\n\\t\\t\\tif ( position !== undefined ) {\\n\\n\\t\\t\\t\\tmatrix.applyToBufferAttribute( position );\\n\\t\\t\\t\\tposition.needsUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar normal = this.attributes.normal;\\n\\n\\t\\t\\tif ( normal !== undefined ) {\\n\\n\\t\\t\\t\\tvar normalMatrix = new Matrix3().getNormalMatrix( matrix );\\n\\n\\t\\t\\t\\tnormalMatrix.applyToBufferAttribute( normal );\\n\\t\\t\\t\\tnormal.needsUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.boundingBox !== null ) {\\n\\n\\t\\t\\t\\tthis.computeBoundingBox();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.boundingSphere !== null ) {\\n\\n\\t\\t\\t\\tthis.computeBoundingSphere();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\trotateX: function () {\\n\\n\\t\\t\\t// rotate geometry around world x-axis\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function rotateX( angle ) {\\n\\n\\t\\t\\t\\tm1.makeRotationX( angle );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\trotateY: function () {\\n\\n\\t\\t\\t// rotate geometry around world y-axis\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function rotateY( angle ) {\\n\\n\\t\\t\\t\\tm1.makeRotationY( angle );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\trotateZ: function () {\\n\\n\\t\\t\\t// rotate geometry around world z-axis\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function rotateZ( angle ) {\\n\\n\\t\\t\\t\\tm1.makeRotationZ( angle );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttranslate: function () {\\n\\n\\t\\t\\t// translate geometry\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function translate( x, y, z ) {\\n\\n\\t\\t\\t\\tm1.makeTranslation( x, y, z );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tscale: function () {\\n\\n\\t\\t\\t// scale geometry\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function scale( x, y, z ) {\\n\\n\\t\\t\\t\\tm1.makeScale( x, y, z );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tlookAt: function () {\\n\\n\\t\\t\\tvar obj = new Object3D();\\n\\n\\t\\t\\treturn function lookAt( vector ) {\\n\\n\\t\\t\\t\\tobj.lookAt( vector );\\n\\n\\t\\t\\t\\tobj.updateMatrix();\\n\\n\\t\\t\\t\\tthis.applyMatrix( obj.matrix );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tcenter: function () {\\n\\n\\t\\t\\tthis.computeBoundingBox();\\n\\n\\t\\t\\tvar offset = this.boundingBox.getCenter().negate();\\n\\n\\t\\t\\tthis.translate( offset.x, offset.y, offset.z );\\n\\n\\t\\t\\treturn offset;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromObject: function ( object ) {\\n\\n\\t\\t\\t// console.log( 'THREE.BufferGeometry.setFromObject(). Converting', object, this );\\n\\n\\t\\t\\tvar geometry = object.geometry;\\n\\n\\t\\t\\tif ( object.isPoints || object.isLine ) {\\n\\n\\t\\t\\t\\tvar positions = new Float32BufferAttribute( geometry.vertices.length * 3, 3 );\\n\\t\\t\\t\\tvar colors = new Float32BufferAttribute( geometry.colors.length * 3, 3 );\\n\\n\\t\\t\\t\\tthis.addAttribute( 'position', positions.copyVector3sArray( geometry.vertices ) );\\n\\t\\t\\t\\tthis.addAttribute( 'color', colors.copyColorsArray( geometry.colors ) );\\n\\n\\t\\t\\t\\tif ( geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length ) {\\n\\n\\t\\t\\t\\t\\tvar lineDistances = new Float32BufferAttribute( geometry.lineDistances.length, 1 );\\n\\n\\t\\t\\t\\t\\tthis.addAttribute( 'lineDistance', lineDistances.copyArray( geometry.lineDistances ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( geometry.boundingSphere !== null ) {\\n\\n\\t\\t\\t\\t\\tthis.boundingSphere = geometry.boundingSphere.clone();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( geometry.boundingBox !== null ) {\\n\\n\\t\\t\\t\\t\\tthis.boundingBox = geometry.boundingBox.clone();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( object.isMesh ) {\\n\\n\\t\\t\\t\\tif ( geometry && geometry.isGeometry ) {\\n\\n\\t\\t\\t\\t\\tthis.fromGeometry( geometry );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromPoints: function ( points ) {\\n\\n\\t\\t\\tvar position = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = points.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar point = points[ i ];\\n\\t\\t\\t\\tposition.push( point.x, point.y, point.z || 0 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( position, 3 ) );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tupdateFromObject: function ( object ) {\\n\\n\\t\\t\\tvar geometry = object.geometry;\\n\\n\\t\\t\\tif ( object.isMesh ) {\\n\\n\\t\\t\\t\\tvar direct = geometry.__directGeometry;\\n\\n\\t\\t\\t\\tif ( geometry.elementsNeedUpdate === true ) {\\n\\n\\t\\t\\t\\t\\tdirect = undefined;\\n\\t\\t\\t\\t\\tgeometry.elementsNeedUpdate = false;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( direct === undefined ) {\\n\\n\\t\\t\\t\\t\\treturn this.fromGeometry( geometry );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tdirect.verticesNeedUpdate = geometry.verticesNeedUpdate;\\n\\t\\t\\t\\tdirect.normalsNeedUpdate = geometry.normalsNeedUpdate;\\n\\t\\t\\t\\tdirect.colorsNeedUpdate = geometry.colorsNeedUpdate;\\n\\t\\t\\t\\tdirect.uvsNeedUpdate = geometry.uvsNeedUpdate;\\n\\t\\t\\t\\tdirect.groupsNeedUpdate = geometry.groupsNeedUpdate;\\n\\n\\t\\t\\t\\tgeometry.verticesNeedUpdate = false;\\n\\t\\t\\t\\tgeometry.normalsNeedUpdate = false;\\n\\t\\t\\t\\tgeometry.colorsNeedUpdate = false;\\n\\t\\t\\t\\tgeometry.uvsNeedUpdate = false;\\n\\t\\t\\t\\tgeometry.groupsNeedUpdate = false;\\n\\n\\t\\t\\t\\tgeometry = direct;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar attribute;\\n\\n\\t\\t\\tif ( geometry.verticesNeedUpdate === true ) {\\n\\n\\t\\t\\t\\tattribute = this.attributes.position;\\n\\n\\t\\t\\t\\tif ( attribute !== undefined ) {\\n\\n\\t\\t\\t\\t\\tattribute.copyVector3sArray( geometry.vertices );\\n\\t\\t\\t\\t\\tattribute.needsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometry.verticesNeedUpdate = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.normalsNeedUpdate === true ) {\\n\\n\\t\\t\\t\\tattribute = this.attributes.normal;\\n\\n\\t\\t\\t\\tif ( attribute !== undefined ) {\\n\\n\\t\\t\\t\\t\\tattribute.copyVector3sArray( geometry.normals );\\n\\t\\t\\t\\t\\tattribute.needsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometry.normalsNeedUpdate = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.colorsNeedUpdate === true ) {\\n\\n\\t\\t\\t\\tattribute = this.attributes.color;\\n\\n\\t\\t\\t\\tif ( attribute !== undefined ) {\\n\\n\\t\\t\\t\\t\\tattribute.copyColorsArray( geometry.colors );\\n\\t\\t\\t\\t\\tattribute.needsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometry.colorsNeedUpdate = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.uvsNeedUpdate ) {\\n\\n\\t\\t\\t\\tattribute = this.attributes.uv;\\n\\n\\t\\t\\t\\tif ( attribute !== undefined ) {\\n\\n\\t\\t\\t\\t\\tattribute.copyVector2sArray( geometry.uvs );\\n\\t\\t\\t\\t\\tattribute.needsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometry.uvsNeedUpdate = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.lineDistancesNeedUpdate ) {\\n\\n\\t\\t\\t\\tattribute = this.attributes.lineDistance;\\n\\n\\t\\t\\t\\tif ( attribute !== undefined ) {\\n\\n\\t\\t\\t\\t\\tattribute.copyArray( geometry.lineDistances );\\n\\t\\t\\t\\t\\tattribute.needsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometry.lineDistancesNeedUpdate = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.groupsNeedUpdate ) {\\n\\n\\t\\t\\t\\tgeometry.computeGroups( object.geometry );\\n\\t\\t\\t\\tthis.groups = geometry.groups;\\n\\n\\t\\t\\t\\tgeometry.groupsNeedUpdate = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tfromGeometry: function ( geometry ) {\\n\\n\\t\\t\\tgeometry.__directGeometry = new DirectGeometry().fromGeometry( geometry );\\n\\n\\t\\t\\treturn this.fromDirectGeometry( geometry.__directGeometry );\\n\\n\\t\\t},\\n\\n\\t\\tfromDirectGeometry: function ( geometry ) {\\n\\n\\t\\t\\tvar positions = new Float32Array( geometry.vertices.length * 3 );\\n\\t\\t\\tthis.addAttribute( 'position', new BufferAttribute( positions, 3 ).copyVector3sArray( geometry.vertices ) );\\n\\n\\t\\t\\tif ( geometry.normals.length > 0 ) {\\n\\n\\t\\t\\t\\tvar normals = new Float32Array( geometry.normals.length * 3 );\\n\\t\\t\\t\\tthis.addAttribute( 'normal', new BufferAttribute( normals, 3 ).copyVector3sArray( geometry.normals ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.colors.length > 0 ) {\\n\\n\\t\\t\\t\\tvar colors = new Float32Array( geometry.colors.length * 3 );\\n\\t\\t\\t\\tthis.addAttribute( 'color', new BufferAttribute( colors, 3 ).copyColorsArray( geometry.colors ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.uvs.length > 0 ) {\\n\\n\\t\\t\\t\\tvar uvs = new Float32Array( geometry.uvs.length * 2 );\\n\\t\\t\\t\\tthis.addAttribute( 'uv', new BufferAttribute( uvs, 2 ).copyVector2sArray( geometry.uvs ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.uvs2.length > 0 ) {\\n\\n\\t\\t\\t\\tvar uvs2 = new Float32Array( geometry.uvs2.length * 2 );\\n\\t\\t\\t\\tthis.addAttribute( 'uv2', new BufferAttribute( uvs2, 2 ).copyVector2sArray( geometry.uvs2 ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.indices.length > 0 ) {\\n\\n\\t\\t\\t\\tvar TypeArray = arrayMax( geometry.indices ) > 65535 ? Uint32Array : Uint16Array;\\n\\t\\t\\t\\tvar indices = new TypeArray( geometry.indices.length * 3 );\\n\\t\\t\\t\\tthis.setIndex( new BufferAttribute( indices, 1 ).copyIndicesArray( geometry.indices ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// groups\\n\\n\\t\\t\\tthis.groups = geometry.groups;\\n\\n\\t\\t\\t// morphs\\n\\n\\t\\t\\tfor ( var name in geometry.morphTargets ) {\\n\\n\\t\\t\\t\\tvar array = [];\\n\\t\\t\\t\\tvar morphTargets = geometry.morphTargets[ name ];\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = morphTargets.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar morphTarget = morphTargets[ i ];\\n\\n\\t\\t\\t\\t\\tvar attribute = new Float32BufferAttribute( morphTarget.length * 3, 3 );\\n\\n\\t\\t\\t\\t\\tarray.push( attribute.copyVector3sArray( morphTarget ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.morphAttributes[ name ] = array;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// skinning\\n\\n\\t\\t\\tif ( geometry.skinIndices.length > 0 ) {\\n\\n\\t\\t\\t\\tvar skinIndices = new Float32BufferAttribute( geometry.skinIndices.length * 4, 4 );\\n\\t\\t\\t\\tthis.addAttribute( 'skinIndex', skinIndices.copyVector4sArray( geometry.skinIndices ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.skinWeights.length > 0 ) {\\n\\n\\t\\t\\t\\tvar skinWeights = new Float32BufferAttribute( geometry.skinWeights.length * 4, 4 );\\n\\t\\t\\t\\tthis.addAttribute( 'skinWeight', skinWeights.copyVector4sArray( geometry.skinWeights ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tif ( geometry.boundingSphere !== null ) {\\n\\n\\t\\t\\t\\tthis.boundingSphere = geometry.boundingSphere.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.boundingBox !== null ) {\\n\\n\\t\\t\\t\\tthis.boundingBox = geometry.boundingBox.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcomputeBoundingBox: function () {\\n\\n\\t\\t\\tif ( this.boundingBox === null ) {\\n\\n\\t\\t\\t\\tthis.boundingBox = new Box3();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar position = this.attributes.position;\\n\\n\\t\\t\\tif ( position !== undefined ) {\\n\\n\\t\\t\\t\\tthis.boundingBox.setFromBufferAttribute( position );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.boundingBox.makeEmpty();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( isNaN( this.boundingBox.min.x ) || isNaN( this.boundingBox.min.y ) || isNaN( this.boundingBox.min.z ) ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.BufferGeometry.computeBoundingBox: Computed min/max have NaN values. The \\\"position\\\" attribute is likely to have NaN values.', this );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tcomputeBoundingSphere: function () {\\n\\n\\t\\t\\tvar box = new Box3();\\n\\t\\t\\tvar vector = new Vector3();\\n\\n\\t\\t\\treturn function computeBoundingSphere() {\\n\\n\\t\\t\\t\\tif ( this.boundingSphere === null ) {\\n\\n\\t\\t\\t\\t\\tthis.boundingSphere = new Sphere();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar position = this.attributes.position;\\n\\n\\t\\t\\t\\tif ( position ) {\\n\\n\\t\\t\\t\\t\\tvar center = this.boundingSphere.center;\\n\\n\\t\\t\\t\\t\\tbox.setFromBufferAttribute( position );\\n\\t\\t\\t\\t\\tbox.getCenter( center );\\n\\n\\t\\t\\t\\t\\t// hoping to find a boundingSphere with a radius smaller than the\\n\\t\\t\\t\\t\\t// boundingSphere of the boundingBox: sqrt(3) smaller in the best case\\n\\n\\t\\t\\t\\t\\tvar maxRadiusSq = 0;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, il = position.count; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvector.x = position.getX( i );\\n\\t\\t\\t\\t\\t\\tvector.y = position.getY( i );\\n\\t\\t\\t\\t\\t\\tvector.z = position.getZ( i );\\n\\t\\t\\t\\t\\t\\tmaxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( vector ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tthis.boundingSphere.radius = Math.sqrt( maxRadiusSq );\\n\\n\\t\\t\\t\\t\\tif ( isNaN( this.boundingSphere.radius ) ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The \\\"position\\\" attribute is likely to have NaN values.', this );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tcomputeFaceNormals: function () {\\n\\n\\t\\t\\t// backwards compatibility\\n\\n\\t\\t},\\n\\n\\t\\tcomputeVertexNormals: function () {\\n\\n\\t\\t\\tvar index = this.index;\\n\\t\\t\\tvar attributes = this.attributes;\\n\\t\\t\\tvar groups = this.groups;\\n\\n\\t\\t\\tif ( attributes.position ) {\\n\\n\\t\\t\\t\\tvar positions = attributes.position.array;\\n\\n\\t\\t\\t\\tif ( attributes.normal === undefined ) {\\n\\n\\t\\t\\t\\t\\tthis.addAttribute( 'normal', new BufferAttribute( new Float32Array( positions.length ), 3 ) );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// reset existing normals to zero\\n\\n\\t\\t\\t\\t\\tvar array = attributes.normal.array;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, il = array.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tarray[ i ] = 0;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar normals = attributes.normal.array;\\n\\n\\t\\t\\t\\tvar vA, vB, vC;\\n\\t\\t\\t\\tvar pA = new Vector3(), pB = new Vector3(), pC = new Vector3();\\n\\t\\t\\t\\tvar cb = new Vector3(), ab = new Vector3();\\n\\n\\t\\t\\t\\t// indexed elements\\n\\n\\t\\t\\t\\tif ( index ) {\\n\\n\\t\\t\\t\\t\\tvar indices = index.array;\\n\\n\\t\\t\\t\\t\\tif ( groups.length === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tthis.addGroup( 0, indices.length );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tfor ( var j = 0, jl = groups.length; j < jl; ++ j ) {\\n\\n\\t\\t\\t\\t\\t\\tvar group = groups[ j ];\\n\\n\\t\\t\\t\\t\\t\\tvar start = group.start;\\n\\t\\t\\t\\t\\t\\tvar count = group.count;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = start, il = start + count; i < il; i += 3 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvA = indices[ i + 0 ] * 3;\\n\\t\\t\\t\\t\\t\\t\\tvB = indices[ i + 1 ] * 3;\\n\\t\\t\\t\\t\\t\\t\\tvC = indices[ i + 2 ] * 3;\\n\\n\\t\\t\\t\\t\\t\\t\\tpA.fromArray( positions, vA );\\n\\t\\t\\t\\t\\t\\t\\tpB.fromArray( positions, vB );\\n\\t\\t\\t\\t\\t\\t\\tpC.fromArray( positions, vC );\\n\\n\\t\\t\\t\\t\\t\\t\\tcb.subVectors( pC, pB );\\n\\t\\t\\t\\t\\t\\t\\tab.subVectors( pA, pB );\\n\\t\\t\\t\\t\\t\\t\\tcb.cross( ab );\\n\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vA ] += cb.x;\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vA + 1 ] += cb.y;\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vA + 2 ] += cb.z;\\n\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vB ] += cb.x;\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vB + 1 ] += cb.y;\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vB + 2 ] += cb.z;\\n\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vC ] += cb.x;\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vC + 1 ] += cb.y;\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vC + 2 ] += cb.z;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// non-indexed elements (unconnected triangle soup)\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, il = positions.length; i < il; i += 9 ) {\\n\\n\\t\\t\\t\\t\\t\\tpA.fromArray( positions, i );\\n\\t\\t\\t\\t\\t\\tpB.fromArray( positions, i + 3 );\\n\\t\\t\\t\\t\\t\\tpC.fromArray( positions, i + 6 );\\n\\n\\t\\t\\t\\t\\t\\tcb.subVectors( pC, pB );\\n\\t\\t\\t\\t\\t\\tab.subVectors( pA, pB );\\n\\t\\t\\t\\t\\t\\tcb.cross( ab );\\n\\n\\t\\t\\t\\t\\t\\tnormals[ i ] = cb.x;\\n\\t\\t\\t\\t\\t\\tnormals[ i + 1 ] = cb.y;\\n\\t\\t\\t\\t\\t\\tnormals[ i + 2 ] = cb.z;\\n\\n\\t\\t\\t\\t\\t\\tnormals[ i + 3 ] = cb.x;\\n\\t\\t\\t\\t\\t\\tnormals[ i + 4 ] = cb.y;\\n\\t\\t\\t\\t\\t\\tnormals[ i + 5 ] = cb.z;\\n\\n\\t\\t\\t\\t\\t\\tnormals[ i + 6 ] = cb.x;\\n\\t\\t\\t\\t\\t\\tnormals[ i + 7 ] = cb.y;\\n\\t\\t\\t\\t\\t\\tnormals[ i + 8 ] = cb.z;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.normalizeNormals();\\n\\n\\t\\t\\t\\tattributes.normal.needsUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tmerge: function ( geometry, offset ) {\\n\\n\\t\\t\\tif ( ! ( geometry && geometry.isBufferGeometry ) ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.', geometry );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tvar attributes = this.attributes;\\n\\n\\t\\t\\tfor ( var key in attributes ) {\\n\\n\\t\\t\\t\\tif ( geometry.attributes[ key ] === undefined ) continue;\\n\\n\\t\\t\\t\\tvar attribute1 = attributes[ key ];\\n\\t\\t\\t\\tvar attributeArray1 = attribute1.array;\\n\\n\\t\\t\\t\\tvar attribute2 = geometry.attributes[ key ];\\n\\t\\t\\t\\tvar attributeArray2 = attribute2.array;\\n\\n\\t\\t\\t\\tvar attributeSize = attribute2.itemSize;\\n\\n\\t\\t\\t\\tfor ( var i = 0, j = attributeSize * offset; i < attributeArray2.length; i ++, j ++ ) {\\n\\n\\t\\t\\t\\t\\tattributeArray1[ j ] = attributeArray2[ i ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tnormalizeNormals: function () {\\n\\n\\t\\t\\tvar vector = new Vector3();\\n\\n\\t\\t\\treturn function normalizeNormals() {\\n\\n\\t\\t\\t\\tvar normals = this.attributes.normal;\\n\\n\\t\\t\\t\\tfor ( var i = 0, il = normals.count; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvector.x = normals.getX( i );\\n\\t\\t\\t\\t\\tvector.y = normals.getY( i );\\n\\t\\t\\t\\t\\tvector.z = normals.getZ( i );\\n\\n\\t\\t\\t\\t\\tvector.normalize();\\n\\n\\t\\t\\t\\t\\tnormals.setXYZ( i, vector.x, vector.y, vector.z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttoNonIndexed: function () {\\n\\n\\t\\t\\tif ( this.index === null ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.BufferGeometry.toNonIndexed(): Geometry is already non-indexed.' );\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar geometry2 = new BufferGeometry();\\n\\n\\t\\t\\tvar indices = this.index.array;\\n\\t\\t\\tvar attributes = this.attributes;\\n\\n\\t\\t\\tfor ( var name in attributes ) {\\n\\n\\t\\t\\t\\tvar attribute = attributes[ name ];\\n\\n\\t\\t\\t\\tvar array = attribute.array;\\n\\t\\t\\t\\tvar itemSize = attribute.itemSize;\\n\\n\\t\\t\\t\\tvar array2 = new array.constructor( indices.length * itemSize );\\n\\n\\t\\t\\t\\tvar index = 0, index2 = 0;\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = indices.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tindex = indices[ i ] * itemSize;\\n\\n\\t\\t\\t\\t\\tfor ( var j = 0; j < itemSize; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tarray2[ index2 ++ ] = array[ index ++ ];\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometry2.addAttribute( name, new BufferAttribute( array2, itemSize ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn geometry2;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function () {\\n\\n\\t\\t\\tvar data = {\\n\\t\\t\\t\\tmetadata: {\\n\\t\\t\\t\\t\\tversion: 4.5,\\n\\t\\t\\t\\t\\ttype: 'BufferGeometry',\\n\\t\\t\\t\\t\\tgenerator: 'BufferGeometry.toJSON'\\n\\t\\t\\t\\t}\\n\\t\\t\\t};\\n\\n\\t\\t\\t// standard BufferGeometry serialization\\n\\n\\t\\t\\tdata.uuid = this.uuid;\\n\\t\\t\\tdata.type = this.type;\\n\\t\\t\\tif ( this.name !== '' ) data.name = this.name;\\n\\n\\t\\t\\tif ( this.parameters !== undefined ) {\\n\\n\\t\\t\\t\\tvar parameters = this.parameters;\\n\\n\\t\\t\\t\\tfor ( var key in parameters ) {\\n\\n\\t\\t\\t\\t\\tif ( parameters[ key ] !== undefined ) data[ key ] = parameters[ key ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn data;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tdata.data = { attributes: {} };\\n\\n\\t\\t\\tvar index = this.index;\\n\\n\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\tvar array = Array.prototype.slice.call( index.array );\\n\\n\\t\\t\\t\\tdata.data.index = {\\n\\t\\t\\t\\t\\ttype: index.array.constructor.name,\\n\\t\\t\\t\\t\\tarray: array\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar attributes = this.attributes;\\n\\n\\t\\t\\tfor ( var key in attributes ) {\\n\\n\\t\\t\\t\\tvar attribute = attributes[ key ];\\n\\n\\t\\t\\t\\tvar array = Array.prototype.slice.call( attribute.array );\\n\\n\\t\\t\\t\\tdata.data.attributes[ key ] = {\\n\\t\\t\\t\\t\\titemSize: attribute.itemSize,\\n\\t\\t\\t\\t\\ttype: attribute.array.constructor.name,\\n\\t\\t\\t\\t\\tarray: array,\\n\\t\\t\\t\\t\\tnormalized: attribute.normalized\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar groups = this.groups;\\n\\n\\t\\t\\tif ( groups.length > 0 ) {\\n\\n\\t\\t\\t\\tdata.data.groups = JSON.parse( JSON.stringify( groups ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar boundingSphere = this.boundingSphere;\\n\\n\\t\\t\\tif ( boundingSphere !== null ) {\\n\\n\\t\\t\\t\\tdata.data.boundingSphere = {\\n\\t\\t\\t\\t\\tcenter: boundingSphere.center.toArray(),\\n\\t\\t\\t\\t\\tradius: boundingSphere.radius\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\t/*\\n\\t\\t\\t // Handle primitives\\n\\n\\t\\t\\t var parameters = this.parameters;\\n\\n\\t\\t\\t if ( parameters !== undefined ) {\\n\\n\\t\\t\\t var values = [];\\n\\n\\t\\t\\t for ( var key in parameters ) {\\n\\n\\t\\t\\t values.push( parameters[ key ] );\\n\\n\\t\\t\\t }\\n\\n\\t\\t\\t var geometry = Object.create( this.constructor.prototype );\\n\\t\\t\\t this.constructor.apply( geometry, values );\\n\\t\\t\\t return geometry;\\n\\n\\t\\t\\t }\\n\\n\\t\\t\\t return new this.constructor().copy( this );\\n\\t\\t\\t */\\n\\n\\t\\t\\treturn new BufferGeometry().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tvar name, i, l;\\n\\n\\t\\t\\t// reset\\n\\n\\t\\t\\tthis.index = null;\\n\\t\\t\\tthis.attributes = {};\\n\\t\\t\\tthis.morphAttributes = {};\\n\\t\\t\\tthis.groups = [];\\n\\t\\t\\tthis.boundingBox = null;\\n\\t\\t\\tthis.boundingSphere = null;\\n\\n\\t\\t\\t// name\\n\\n\\t\\t\\tthis.name = source.name;\\n\\n\\t\\t\\t// index\\n\\n\\t\\t\\tvar index = source.index;\\n\\n\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\tthis.setIndex( index.clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// attributes\\n\\n\\t\\t\\tvar attributes = source.attributes;\\n\\n\\t\\t\\tfor ( name in attributes ) {\\n\\n\\t\\t\\t\\tvar attribute = attributes[ name ];\\n\\t\\t\\t\\tthis.addAttribute( name, attribute.clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// morph attributes\\n\\n\\t\\t\\tvar morphAttributes = source.morphAttributes;\\n\\n\\t\\t\\tfor ( name in morphAttributes ) {\\n\\n\\t\\t\\t\\tvar array = [];\\n\\t\\t\\t\\tvar morphAttribute = morphAttributes[ name ]; // morphAttribute: array of Float32BufferAttributes\\n\\n\\t\\t\\t\\tfor ( i = 0, l = morphAttribute.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tarray.push( morphAttribute[ i ].clone() );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.morphAttributes[ name ] = array;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// groups\\n\\n\\t\\t\\tvar groups = source.groups;\\n\\n\\t\\t\\tfor ( i = 0, l = groups.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar group = groups[ i ];\\n\\t\\t\\t\\tthis.addGroup( group.start, group.count, group.materialIndex );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// bounding box\\n\\n\\t\\t\\tvar boundingBox = source.boundingBox;\\n\\n\\t\\t\\tif ( boundingBox !== null ) {\\n\\n\\t\\t\\t\\tthis.boundingBox = boundingBox.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// bounding sphere\\n\\n\\t\\t\\tvar boundingSphere = source.boundingSphere;\\n\\n\\t\\t\\tif ( boundingSphere !== null ) {\\n\\n\\t\\t\\t\\tthis.boundingSphere = boundingSphere.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// draw range\\n\\n\\t\\t\\tthis.drawRange.start = source.drawRange.start;\\n\\t\\t\\tthis.drawRange.count = source.drawRange.count;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdispose: function () {\\n\\n\\t\\t\\tthis.dispatchEvent( { type: 'dispose' } );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// BoxGeometry\\n\\n\\tfunction BoxGeometry( width, height, depth, widthSegments, heightSegments, depthSegments ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'BoxGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\twidth: width,\\n\\t\\t\\theight: height,\\n\\t\\t\\tdepth: depth,\\n\\t\\t\\twidthSegments: widthSegments,\\n\\t\\t\\theightSegments: heightSegments,\\n\\t\\t\\tdepthSegments: depthSegments\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new BoxBufferGeometry( width, height, depth, widthSegments, heightSegments, depthSegments ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tBoxGeometry.prototype = Object.create( Geometry.prototype );\\n\\tBoxGeometry.prototype.constructor = BoxGeometry;\\n\\n\\t// BoxBufferGeometry\\n\\n\\tfunction BoxBufferGeometry( width, height, depth, widthSegments, heightSegments, depthSegments ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'BoxBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\twidth: width,\\n\\t\\t\\theight: height,\\n\\t\\t\\tdepth: depth,\\n\\t\\t\\twidthSegments: widthSegments,\\n\\t\\t\\theightSegments: heightSegments,\\n\\t\\t\\tdepthSegments: depthSegments\\n\\t\\t};\\n\\n\\t\\tvar scope = this;\\n\\n\\t\\twidth = width || 1;\\n\\t\\theight = height || 1;\\n\\t\\tdepth = depth || 1;\\n\\n\\t\\t// segments\\n\\n\\t\\twidthSegments = Math.floor( widthSegments ) || 1;\\n\\t\\theightSegments = Math.floor( heightSegments ) || 1;\\n\\t\\tdepthSegments = Math.floor( depthSegments ) || 1;\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar numberOfVertices = 0;\\n\\t\\tvar groupStart = 0;\\n\\n\\t\\t// build each side of the box geometry\\n\\n\\t\\tbuildPlane( 'z', 'y', 'x', - 1, - 1, depth, height, width, depthSegments, heightSegments, 0 ); // px\\n\\t\\tbuildPlane( 'z', 'y', 'x', 1, - 1, depth, height, - width, depthSegments, heightSegments, 1 ); // nx\\n\\t\\tbuildPlane( 'x', 'z', 'y', 1, 1, width, depth, height, widthSegments, depthSegments, 2 ); // py\\n\\t\\tbuildPlane( 'x', 'z', 'y', 1, - 1, width, depth, - height, widthSegments, depthSegments, 3 ); // ny\\n\\t\\tbuildPlane( 'x', 'y', 'z', 1, - 1, width, height, depth, widthSegments, heightSegments, 4 ); // pz\\n\\t\\tbuildPlane( 'x', 'y', 'z', - 1, - 1, width, height, - depth, widthSegments, heightSegments, 5 ); // nz\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t\\tfunction buildPlane( u, v, w, udir, vdir, width, height, depth, gridX, gridY, materialIndex ) {\\n\\n\\t\\t\\tvar segmentWidth = width / gridX;\\n\\t\\t\\tvar segmentHeight = height / gridY;\\n\\n\\t\\t\\tvar widthHalf = width / 2;\\n\\t\\t\\tvar heightHalf = height / 2;\\n\\t\\t\\tvar depthHalf = depth / 2;\\n\\n\\t\\t\\tvar gridX1 = gridX + 1;\\n\\t\\t\\tvar gridY1 = gridY + 1;\\n\\n\\t\\t\\tvar vertexCounter = 0;\\n\\t\\t\\tvar groupCount = 0;\\n\\n\\t\\t\\tvar ix, iy;\\n\\n\\t\\t\\tvar vector = new Vector3();\\n\\n\\t\\t\\t// generate vertices, normals and uvs\\n\\n\\t\\t\\tfor ( iy = 0; iy < gridY1; iy ++ ) {\\n\\n\\t\\t\\t\\tvar y = iy * segmentHeight - heightHalf;\\n\\n\\t\\t\\t\\tfor ( ix = 0; ix < gridX1; ix ++ ) {\\n\\n\\t\\t\\t\\t\\tvar x = ix * segmentWidth - widthHalf;\\n\\n\\t\\t\\t\\t\\t// set values to correct vector component\\n\\n\\t\\t\\t\\t\\tvector[ u ] = x * udir;\\n\\t\\t\\t\\t\\tvector[ v ] = y * vdir;\\n\\t\\t\\t\\t\\tvector[ w ] = depthHalf;\\n\\n\\t\\t\\t\\t\\t// now apply vector to vertex buffer\\n\\n\\t\\t\\t\\t\\tvertices.push( vector.x, vector.y, vector.z );\\n\\n\\t\\t\\t\\t\\t// set values to correct vector component\\n\\n\\t\\t\\t\\t\\tvector[ u ] = 0;\\n\\t\\t\\t\\t\\tvector[ v ] = 0;\\n\\t\\t\\t\\t\\tvector[ w ] = depth > 0 ? 1 : - 1;\\n\\n\\t\\t\\t\\t\\t// now apply vector to normal buffer\\n\\n\\t\\t\\t\\t\\tnormals.push( vector.x, vector.y, vector.z );\\n\\n\\t\\t\\t\\t\\t// uvs\\n\\n\\t\\t\\t\\t\\tuvs.push( ix / gridX );\\n\\t\\t\\t\\t\\tuvs.push( 1 - ( iy / gridY ) );\\n\\n\\t\\t\\t\\t\\t// counters\\n\\n\\t\\t\\t\\t\\tvertexCounter += 1;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// indices\\n\\n\\t\\t\\t// 1. you need three indices to draw a single face\\n\\t\\t\\t// 2. a single segment consists of two faces\\n\\t\\t\\t// 3. so we need to generate six (2*3) indices per segment\\n\\n\\t\\t\\tfor ( iy = 0; iy < gridY; iy ++ ) {\\n\\n\\t\\t\\t\\tfor ( ix = 0; ix < gridX; ix ++ ) {\\n\\n\\t\\t\\t\\t\\tvar a = numberOfVertices + ix + gridX1 * iy;\\n\\t\\t\\t\\t\\tvar b = numberOfVertices + ix + gridX1 * ( iy + 1 );\\n\\t\\t\\t\\t\\tvar c = numberOfVertices + ( ix + 1 ) + gridX1 * ( iy + 1 );\\n\\t\\t\\t\\t\\tvar d = numberOfVertices + ( ix + 1 ) + gridX1 * iy;\\n\\n\\t\\t\\t\\t\\t// faces\\n\\n\\t\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t\\t\\t// increase counter\\n\\n\\t\\t\\t\\t\\tgroupCount += 6;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// add a group to the geometry. this will ensure multi material support\\n\\n\\t\\t\\tscope.addGroup( groupStart, groupCount, materialIndex );\\n\\n\\t\\t\\t// calculate new start value for groups\\n\\n\\t\\t\\tgroupStart += groupCount;\\n\\n\\t\\t\\t// update total number of vertices\\n\\n\\t\\t\\tnumberOfVertices += vertexCounter;\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tBoxBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tBoxBufferGeometry.prototype.constructor = BoxBufferGeometry;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// PlaneGeometry\\n\\n\\tfunction PlaneGeometry( width, height, widthSegments, heightSegments ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'PlaneGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\twidth: width,\\n\\t\\t\\theight: height,\\n\\t\\t\\twidthSegments: widthSegments,\\n\\t\\t\\theightSegments: heightSegments\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new PlaneBufferGeometry( width, height, widthSegments, heightSegments ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tPlaneGeometry.prototype = Object.create( Geometry.prototype );\\n\\tPlaneGeometry.prototype.constructor = PlaneGeometry;\\n\\n\\t// PlaneBufferGeometry\\n\\n\\tfunction PlaneBufferGeometry( width, height, widthSegments, heightSegments ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'PlaneBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\twidth: width,\\n\\t\\t\\theight: height,\\n\\t\\t\\twidthSegments: widthSegments,\\n\\t\\t\\theightSegments: heightSegments\\n\\t\\t};\\n\\n\\t\\twidth = width || 1;\\n\\t\\theight = height || 1;\\n\\n\\t\\tvar width_half = width / 2;\\n\\t\\tvar height_half = height / 2;\\n\\n\\t\\tvar gridX = Math.floor( widthSegments ) || 1;\\n\\t\\tvar gridY = Math.floor( heightSegments ) || 1;\\n\\n\\t\\tvar gridX1 = gridX + 1;\\n\\t\\tvar gridY1 = gridY + 1;\\n\\n\\t\\tvar segment_width = width / gridX;\\n\\t\\tvar segment_height = height / gridY;\\n\\n\\t\\tvar ix, iy;\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// generate vertices, normals and uvs\\n\\n\\t\\tfor ( iy = 0; iy < gridY1; iy ++ ) {\\n\\n\\t\\t\\tvar y = iy * segment_height - height_half;\\n\\n\\t\\t\\tfor ( ix = 0; ix < gridX1; ix ++ ) {\\n\\n\\t\\t\\t\\tvar x = ix * segment_width - width_half;\\n\\n\\t\\t\\t\\tvertices.push( x, - y, 0 );\\n\\n\\t\\t\\t\\tnormals.push( 0, 0, 1 );\\n\\n\\t\\t\\t\\tuvs.push( ix / gridX );\\n\\t\\t\\t\\tuvs.push( 1 - ( iy / gridY ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// indices\\n\\n\\t\\tfor ( iy = 0; iy < gridY; iy ++ ) {\\n\\n\\t\\t\\tfor ( ix = 0; ix < gridX; ix ++ ) {\\n\\n\\t\\t\\t\\tvar a = ix + gridX1 * iy;\\n\\t\\t\\t\\tvar b = ix + gridX1 * ( iy + 1 );\\n\\t\\t\\t\\tvar c = ( ix + 1 ) + gridX1 * ( iy + 1 );\\n\\t\\t\\t\\tvar d = ( ix + 1 ) + gridX1 * iy;\\n\\n\\t\\t\\t\\t// faces\\n\\n\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t}\\n\\n\\tPlaneBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tPlaneBufferGeometry.prototype.constructor = PlaneBufferGeometry;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * parameters = {\\n\\t * color: ,\\n\\t * opacity: ,\\n\\t * map: new THREE.Texture( ),\\n\\t *\\n\\t * lightMap: new THREE.Texture( ),\\n\\t * lightMapIntensity: \\n\\t *\\n\\t * aoMap: new THREE.Texture( ),\\n\\t * aoMapIntensity: \\n\\t *\\n\\t * specularMap: new THREE.Texture( ),\\n\\t *\\n\\t * alphaMap: new THREE.Texture( ),\\n\\t *\\n\\t * envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ),\\n\\t * combine: THREE.Multiply,\\n\\t * reflectivity: ,\\n\\t * refractionRatio: ,\\n\\t *\\n\\t * depthTest: ,\\n\\t * depthWrite: ,\\n\\t *\\n\\t * wireframe: ,\\n\\t * wireframeLinewidth: ,\\n\\t *\\n\\t * skinning: ,\\n\\t * morphTargets: \\n\\t * }\\n\\t */\\n\\n\\tfunction MeshBasicMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'MeshBasicMaterial';\\n\\n\\t\\tthis.color = new Color( 0xffffff ); // emissive\\n\\n\\t\\tthis.map = null;\\n\\n\\t\\tthis.lightMap = null;\\n\\t\\tthis.lightMapIntensity = 1.0;\\n\\n\\t\\tthis.aoMap = null;\\n\\t\\tthis.aoMapIntensity = 1.0;\\n\\n\\t\\tthis.specularMap = null;\\n\\n\\t\\tthis.alphaMap = null;\\n\\n\\t\\tthis.envMap = null;\\n\\t\\tthis.combine = MultiplyOperation;\\n\\t\\tthis.reflectivity = 1;\\n\\t\\tthis.refractionRatio = 0.98;\\n\\n\\t\\tthis.wireframe = false;\\n\\t\\tthis.wireframeLinewidth = 1;\\n\\t\\tthis.wireframeLinecap = 'round';\\n\\t\\tthis.wireframeLinejoin = 'round';\\n\\n\\t\\tthis.skinning = false;\\n\\t\\tthis.morphTargets = false;\\n\\n\\t\\tthis.lights = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshBasicMaterial.prototype = Object.create( Material.prototype );\\n\\tMeshBasicMaterial.prototype.constructor = MeshBasicMaterial;\\n\\n\\tMeshBasicMaterial.prototype.isMeshBasicMaterial = true;\\n\\n\\tMeshBasicMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.color.copy( source.color );\\n\\n\\t\\tthis.map = source.map;\\n\\n\\t\\tthis.lightMap = source.lightMap;\\n\\t\\tthis.lightMapIntensity = source.lightMapIntensity;\\n\\n\\t\\tthis.aoMap = source.aoMap;\\n\\t\\tthis.aoMapIntensity = source.aoMapIntensity;\\n\\n\\t\\tthis.specularMap = source.specularMap;\\n\\n\\t\\tthis.alphaMap = source.alphaMap;\\n\\n\\t\\tthis.envMap = source.envMap;\\n\\t\\tthis.combine = source.combine;\\n\\t\\tthis.reflectivity = source.reflectivity;\\n\\t\\tthis.refractionRatio = source.refractionRatio;\\n\\n\\t\\tthis.wireframe = source.wireframe;\\n\\t\\tthis.wireframeLinewidth = source.wireframeLinewidth;\\n\\t\\tthis.wireframeLinecap = source.wireframeLinecap;\\n\\t\\tthis.wireframeLinejoin = source.wireframeLinejoin;\\n\\n\\t\\tthis.skinning = source.skinning;\\n\\t\\tthis.morphTargets = source.morphTargets;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * parameters = {\\n\\t * defines: { \\\"label\\\" : \\\"value\\\" },\\n\\t * uniforms: { \\\"parameter1\\\": { value: 1.0 }, \\\"parameter2\\\": { value2: 2 } },\\n\\t *\\n\\t * fragmentShader: ,\\n\\t * vertexShader: ,\\n\\t *\\n\\t * wireframe: ,\\n\\t * wireframeLinewidth: ,\\n\\t *\\n\\t * lights: ,\\n\\t *\\n\\t * skinning: ,\\n\\t * morphTargets: ,\\n\\t * morphNormals: \\n\\t * }\\n\\t */\\n\\n\\tfunction ShaderMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'ShaderMaterial';\\n\\n\\t\\tthis.defines = {};\\n\\t\\tthis.uniforms = {};\\n\\n\\t\\tthis.vertexShader = 'void main() {\\\\n\\\\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\\\\n}';\\n\\t\\tthis.fragmentShader = 'void main() {\\\\n\\\\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\\\\n}';\\n\\n\\t\\tthis.linewidth = 1;\\n\\n\\t\\tthis.wireframe = false;\\n\\t\\tthis.wireframeLinewidth = 1;\\n\\n\\t\\tthis.fog = false; // set to use scene fog\\n\\t\\tthis.lights = false; // set to use scene lights\\n\\t\\tthis.clipping = false; // set to use user-defined clipping planes\\n\\n\\t\\tthis.skinning = false; // set to use skinning attribute streams\\n\\t\\tthis.morphTargets = false; // set to use morph targets\\n\\t\\tthis.morphNormals = false; // set to use morph normals\\n\\n\\t\\tthis.extensions = {\\n\\t\\t\\tderivatives: false, // set to use derivatives\\n\\t\\t\\tfragDepth: false, // set to use fragment depth values\\n\\t\\t\\tdrawBuffers: false, // set to use draw buffers\\n\\t\\t\\tshaderTextureLOD: false // set to use shader texture LOD\\n\\t\\t};\\n\\n\\t\\t// When rendered geometry doesn't include these attributes but the material does,\\n\\t\\t// use these default values in WebGL. This avoids errors when buffer data is missing.\\n\\t\\tthis.defaultAttributeValues = {\\n\\t\\t\\t'color': [ 1, 1, 1 ],\\n\\t\\t\\t'uv': [ 0, 0 ],\\n\\t\\t\\t'uv2': [ 0, 0 ]\\n\\t\\t};\\n\\n\\t\\tthis.index0AttributeName = undefined;\\n\\n\\t\\tif ( parameters !== undefined ) {\\n\\n\\t\\t\\tif ( parameters.attributes !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead.' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.setValues( parameters );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tShaderMaterial.prototype = Object.create( Material.prototype );\\n\\tShaderMaterial.prototype.constructor = ShaderMaterial;\\n\\n\\tShaderMaterial.prototype.isShaderMaterial = true;\\n\\n\\tShaderMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.fragmentShader = source.fragmentShader;\\n\\t\\tthis.vertexShader = source.vertexShader;\\n\\n\\t\\tthis.uniforms = UniformsUtils.clone( source.uniforms );\\n\\n\\t\\tthis.defines = source.defines;\\n\\n\\t\\tthis.wireframe = source.wireframe;\\n\\t\\tthis.wireframeLinewidth = source.wireframeLinewidth;\\n\\n\\t\\tthis.lights = source.lights;\\n\\t\\tthis.clipping = source.clipping;\\n\\n\\t\\tthis.skinning = source.skinning;\\n\\n\\t\\tthis.morphTargets = source.morphTargets;\\n\\t\\tthis.morphNormals = source.morphNormals;\\n\\n\\t\\tthis.extensions = source.extensions;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tShaderMaterial.prototype.toJSON = function ( meta ) {\\n\\n\\t\\tvar data = Material.prototype.toJSON.call( this, meta );\\n\\n\\t\\tdata.uniforms = this.uniforms;\\n\\t\\tdata.vertexShader = this.vertexShader;\\n\\t\\tdata.fragmentShader = this.fragmentShader;\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author bhouston / http://clara.io\\n\\t */\\n\\n\\tfunction Ray( origin, direction ) {\\n\\n\\t\\tthis.origin = ( origin !== undefined ) ? origin : new Vector3();\\n\\t\\tthis.direction = ( direction !== undefined ) ? direction : new Vector3();\\n\\n\\t}\\n\\n\\tObject.assign( Ray.prototype, {\\n\\n\\t\\tset: function ( origin, direction ) {\\n\\n\\t\\t\\tthis.origin.copy( origin );\\n\\t\\t\\tthis.direction.copy( direction );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( ray ) {\\n\\n\\t\\t\\tthis.origin.copy( ray.origin );\\n\\t\\t\\tthis.direction.copy( ray.direction );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tat: function ( t, optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\treturn result.copy( this.direction ).multiplyScalar( t ).add( this.origin );\\n\\n\\t\\t},\\n\\n\\t\\tlookAt: function ( v ) {\\n\\n\\t\\t\\tthis.direction.copy( v ).sub( this.origin ).normalize();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\trecast: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function recast( t ) {\\n\\n\\t\\t\\t\\tthis.origin.copy( this.at( t, v1 ) );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tclosestPointToPoint: function ( point, optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\t\\t\\tresult.subVectors( point, this.origin );\\n\\t\\t\\tvar directionDistance = result.dot( this.direction );\\n\\n\\t\\t\\tif ( directionDistance < 0 ) {\\n\\n\\t\\t\\t\\treturn result.copy( this.origin );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn result.copy( this.direction ).multiplyScalar( directionDistance ).add( this.origin );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToPoint: function ( point ) {\\n\\n\\t\\t\\treturn Math.sqrt( this.distanceSqToPoint( point ) );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceSqToPoint: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function distanceSqToPoint( point ) {\\n\\n\\t\\t\\t\\tvar directionDistance = v1.subVectors( point, this.origin ).dot( this.direction );\\n\\n\\t\\t\\t\\t// point behind the ray\\n\\n\\t\\t\\t\\tif ( directionDistance < 0 ) {\\n\\n\\t\\t\\t\\t\\treturn this.origin.distanceToSquared( point );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tv1.copy( this.direction ).multiplyScalar( directionDistance ).add( this.origin );\\n\\n\\t\\t\\t\\treturn v1.distanceToSquared( point );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tdistanceSqToSegment: function () {\\n\\n\\t\\t\\tvar segCenter = new Vector3();\\n\\t\\t\\tvar segDir = new Vector3();\\n\\t\\t\\tvar diff = new Vector3();\\n\\n\\t\\t\\treturn function distanceSqToSegment( v0, v1, optionalPointOnRay, optionalPointOnSegment ) {\\n\\n\\t\\t\\t\\t// from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteDistRaySegment.h\\n\\t\\t\\t\\t// It returns the min distance between the ray and the segment\\n\\t\\t\\t\\t// defined by v0 and v1\\n\\t\\t\\t\\t// It can also set two optional targets :\\n\\t\\t\\t\\t// - The closest point on the ray\\n\\t\\t\\t\\t// - The closest point on the segment\\n\\n\\t\\t\\t\\tsegCenter.copy( v0 ).add( v1 ).multiplyScalar( 0.5 );\\n\\t\\t\\t\\tsegDir.copy( v1 ).sub( v0 ).normalize();\\n\\t\\t\\t\\tdiff.copy( this.origin ).sub( segCenter );\\n\\n\\t\\t\\t\\tvar segExtent = v0.distanceTo( v1 ) * 0.5;\\n\\t\\t\\t\\tvar a01 = - this.direction.dot( segDir );\\n\\t\\t\\t\\tvar b0 = diff.dot( this.direction );\\n\\t\\t\\t\\tvar b1 = - diff.dot( segDir );\\n\\t\\t\\t\\tvar c = diff.lengthSq();\\n\\t\\t\\t\\tvar det = Math.abs( 1 - a01 * a01 );\\n\\t\\t\\t\\tvar s0, s1, sqrDist, extDet;\\n\\n\\t\\t\\t\\tif ( det > 0 ) {\\n\\n\\t\\t\\t\\t\\t// The ray and segment are not parallel.\\n\\n\\t\\t\\t\\t\\ts0 = a01 * b1 - b0;\\n\\t\\t\\t\\t\\ts1 = a01 * b0 - b1;\\n\\t\\t\\t\\t\\textDet = segExtent * det;\\n\\n\\t\\t\\t\\t\\tif ( s0 >= 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( s1 >= - extDet ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( s1 <= extDet ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t// region 0\\n\\t\\t\\t\\t\\t\\t\\t\\t// Minimum at interior points of ray and segment.\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tvar invDet = 1 / det;\\n\\t\\t\\t\\t\\t\\t\\t\\ts0 *= invDet;\\n\\t\\t\\t\\t\\t\\t\\t\\ts1 *= invDet;\\n\\t\\t\\t\\t\\t\\t\\t\\tsqrDist = s0 * ( s0 + a01 * s1 + 2 * b0 ) + s1 * ( a01 * s0 + s1 + 2 * b1 ) + c;\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t// region 1\\n\\n\\t\\t\\t\\t\\t\\t\\t\\ts1 = segExtent;\\n\\t\\t\\t\\t\\t\\t\\t\\ts0 = Math.max( 0, - ( a01 * s1 + b0 ) );\\n\\t\\t\\t\\t\\t\\t\\t\\tsqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t// region 5\\n\\n\\t\\t\\t\\t\\t\\t\\ts1 = - segExtent;\\n\\t\\t\\t\\t\\t\\t\\ts0 = Math.max( 0, - ( a01 * s1 + b0 ) );\\n\\t\\t\\t\\t\\t\\t\\tsqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tif ( s1 <= - extDet ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// region 4\\n\\n\\t\\t\\t\\t\\t\\t\\ts0 = Math.max( 0, - ( - a01 * segExtent + b0 ) );\\n\\t\\t\\t\\t\\t\\t\\ts1 = ( s0 > 0 ) ? - segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent );\\n\\t\\t\\t\\t\\t\\t\\tsqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;\\n\\n\\t\\t\\t\\t\\t\\t} else if ( s1 <= extDet ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// region 3\\n\\n\\t\\t\\t\\t\\t\\t\\ts0 = 0;\\n\\t\\t\\t\\t\\t\\t\\ts1 = Math.min( Math.max( - segExtent, - b1 ), segExtent );\\n\\t\\t\\t\\t\\t\\t\\tsqrDist = s1 * ( s1 + 2 * b1 ) + c;\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t// region 2\\n\\n\\t\\t\\t\\t\\t\\t\\ts0 = Math.max( 0, - ( a01 * segExtent + b0 ) );\\n\\t\\t\\t\\t\\t\\t\\ts1 = ( s0 > 0 ) ? segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent );\\n\\t\\t\\t\\t\\t\\t\\tsqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// Ray and segment are parallel.\\n\\n\\t\\t\\t\\t\\ts1 = ( a01 > 0 ) ? - segExtent : segExtent;\\n\\t\\t\\t\\t\\ts0 = Math.max( 0, - ( a01 * s1 + b0 ) );\\n\\t\\t\\t\\t\\tsqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( optionalPointOnRay ) {\\n\\n\\t\\t\\t\\t\\toptionalPointOnRay.copy( this.direction ).multiplyScalar( s0 ).add( this.origin );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( optionalPointOnSegment ) {\\n\\n\\t\\t\\t\\t\\toptionalPointOnSegment.copy( segDir ).multiplyScalar( s1 ).add( segCenter );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn sqrDist;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tintersectSphere: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function intersectSphere( sphere, optionalTarget ) {\\n\\n\\t\\t\\t\\tv1.subVectors( sphere.center, this.origin );\\n\\t\\t\\t\\tvar tca = v1.dot( this.direction );\\n\\t\\t\\t\\tvar d2 = v1.dot( v1 ) - tca * tca;\\n\\t\\t\\t\\tvar radius2 = sphere.radius * sphere.radius;\\n\\n\\t\\t\\t\\tif ( d2 > radius2 ) return null;\\n\\n\\t\\t\\t\\tvar thc = Math.sqrt( radius2 - d2 );\\n\\n\\t\\t\\t\\t// t0 = first intersect point - entrance on front of sphere\\n\\t\\t\\t\\tvar t0 = tca - thc;\\n\\n\\t\\t\\t\\t// t1 = second intersect point - exit point on back of sphere\\n\\t\\t\\t\\tvar t1 = tca + thc;\\n\\n\\t\\t\\t\\t// test to see if both t0 and t1 are behind the ray - if so, return null\\n\\t\\t\\t\\tif ( t0 < 0 && t1 < 0 ) return null;\\n\\n\\t\\t\\t\\t// test to see if t0 is behind the ray:\\n\\t\\t\\t\\t// if it is, the ray is inside the sphere, so return the second exit point scaled by t1,\\n\\t\\t\\t\\t// in order to always return an intersect point that is in front of the ray.\\n\\t\\t\\t\\tif ( t0 < 0 ) return this.at( t1, optionalTarget );\\n\\n\\t\\t\\t\\t// else t0 is in front of the ray, so return the first collision point scaled by t0\\n\\t\\t\\t\\treturn this.at( t0, optionalTarget );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tintersectsSphere: function ( sphere ) {\\n\\n\\t\\t\\treturn this.distanceToPoint( sphere.center ) <= sphere.radius;\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToPlane: function ( plane ) {\\n\\n\\t\\t\\tvar denominator = plane.normal.dot( this.direction );\\n\\n\\t\\t\\tif ( denominator === 0 ) {\\n\\n\\t\\t\\t\\t// line is coplanar, return origin\\n\\t\\t\\t\\tif ( plane.distanceToPoint( this.origin ) === 0 ) {\\n\\n\\t\\t\\t\\t\\treturn 0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// Null is preferable to undefined since undefined means.... it is undefined\\n\\n\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar t = - ( this.origin.dot( plane.normal ) + plane.constant ) / denominator;\\n\\n\\t\\t\\t// Return if the ray never intersects the plane\\n\\n\\t\\t\\treturn t >= 0 ? t : null;\\n\\n\\t\\t},\\n\\n\\t\\tintersectPlane: function ( plane, optionalTarget ) {\\n\\n\\t\\t\\tvar t = this.distanceToPlane( plane );\\n\\n\\t\\t\\tif ( t === null ) {\\n\\n\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this.at( t, optionalTarget );\\n\\n\\t\\t},\\n\\n\\t\\tintersectsPlane: function ( plane ) {\\n\\n\\t\\t\\t// check if the ray lies on the plane first\\n\\n\\t\\t\\tvar distToPoint = plane.distanceToPoint( this.origin );\\n\\n\\t\\t\\tif ( distToPoint === 0 ) {\\n\\n\\t\\t\\t\\treturn true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar denominator = plane.normal.dot( this.direction );\\n\\n\\t\\t\\tif ( denominator * distToPoint < 0 ) {\\n\\n\\t\\t\\t\\treturn true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// ray origin is behind the plane (and is pointing behind it)\\n\\n\\t\\t\\treturn false;\\n\\n\\t\\t},\\n\\n\\t\\tintersectBox: function ( box, optionalTarget ) {\\n\\n\\t\\t\\tvar tmin, tmax, tymin, tymax, tzmin, tzmax;\\n\\n\\t\\t\\tvar invdirx = 1 / this.direction.x,\\n\\t\\t\\t\\tinvdiry = 1 / this.direction.y,\\n\\t\\t\\t\\tinvdirz = 1 / this.direction.z;\\n\\n\\t\\t\\tvar origin = this.origin;\\n\\n\\t\\t\\tif ( invdirx >= 0 ) {\\n\\n\\t\\t\\t\\ttmin = ( box.min.x - origin.x ) * invdirx;\\n\\t\\t\\t\\ttmax = ( box.max.x - origin.x ) * invdirx;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\ttmin = ( box.max.x - origin.x ) * invdirx;\\n\\t\\t\\t\\ttmax = ( box.min.x - origin.x ) * invdirx;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( invdiry >= 0 ) {\\n\\n\\t\\t\\t\\ttymin = ( box.min.y - origin.y ) * invdiry;\\n\\t\\t\\t\\ttymax = ( box.max.y - origin.y ) * invdiry;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\ttymin = ( box.max.y - origin.y ) * invdiry;\\n\\t\\t\\t\\ttymax = ( box.min.y - origin.y ) * invdiry;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( ( tmin > tymax ) || ( tymin > tmax ) ) return null;\\n\\n\\t\\t\\t// These lines also handle the case where tmin or tmax is NaN\\n\\t\\t\\t// (result of 0 * Infinity). x !== x returns true if x is NaN\\n\\n\\t\\t\\tif ( tymin > tmin || tmin !== tmin ) tmin = tymin;\\n\\n\\t\\t\\tif ( tymax < tmax || tmax !== tmax ) tmax = tymax;\\n\\n\\t\\t\\tif ( invdirz >= 0 ) {\\n\\n\\t\\t\\t\\ttzmin = ( box.min.z - origin.z ) * invdirz;\\n\\t\\t\\t\\ttzmax = ( box.max.z - origin.z ) * invdirz;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\ttzmin = ( box.max.z - origin.z ) * invdirz;\\n\\t\\t\\t\\ttzmax = ( box.min.z - origin.z ) * invdirz;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( ( tmin > tzmax ) || ( tzmin > tmax ) ) return null;\\n\\n\\t\\t\\tif ( tzmin > tmin || tmin !== tmin ) tmin = tzmin;\\n\\n\\t\\t\\tif ( tzmax < tmax || tmax !== tmax ) tmax = tzmax;\\n\\n\\t\\t\\t//return point closest to the ray (positive side)\\n\\n\\t\\t\\tif ( tmax < 0 ) return null;\\n\\n\\t\\t\\treturn this.at( tmin >= 0 ? tmin : tmax, optionalTarget );\\n\\n\\t\\t},\\n\\n\\t\\tintersectsBox: ( function () {\\n\\n\\t\\t\\tvar v = new Vector3();\\n\\n\\t\\t\\treturn function intersectsBox( box ) {\\n\\n\\t\\t\\t\\treturn this.intersectBox( box, v ) !== null;\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )(),\\n\\n\\t\\tintersectTriangle: function () {\\n\\n\\t\\t\\t// Compute the offset origin, edges, and normal.\\n\\t\\t\\tvar diff = new Vector3();\\n\\t\\t\\tvar edge1 = new Vector3();\\n\\t\\t\\tvar edge2 = new Vector3();\\n\\t\\t\\tvar normal = new Vector3();\\n\\n\\t\\t\\treturn function intersectTriangle( a, b, c, backfaceCulling, optionalTarget ) {\\n\\n\\t\\t\\t\\t// from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h\\n\\n\\t\\t\\t\\tedge1.subVectors( b, a );\\n\\t\\t\\t\\tedge2.subVectors( c, a );\\n\\t\\t\\t\\tnormal.crossVectors( edge1, edge2 );\\n\\n\\t\\t\\t\\t// Solve Q + t*D = b1*E1 + b2*E2 (Q = kDiff, D = ray direction,\\n\\t\\t\\t\\t// E1 = kEdge1, E2 = kEdge2, N = Cross(E1,E2)) by\\n\\t\\t\\t\\t// |Dot(D,N)|*b1 = sign(Dot(D,N))*Dot(D,Cross(Q,E2))\\n\\t\\t\\t\\t// |Dot(D,N)|*b2 = sign(Dot(D,N))*Dot(D,Cross(E1,Q))\\n\\t\\t\\t\\t// |Dot(D,N)|*t = -sign(Dot(D,N))*Dot(Q,N)\\n\\t\\t\\t\\tvar DdN = this.direction.dot( normal );\\n\\t\\t\\t\\tvar sign;\\n\\n\\t\\t\\t\\tif ( DdN > 0 ) {\\n\\n\\t\\t\\t\\t\\tif ( backfaceCulling ) return null;\\n\\t\\t\\t\\t\\tsign = 1;\\n\\n\\t\\t\\t\\t} else if ( DdN < 0 ) {\\n\\n\\t\\t\\t\\t\\tsign = - 1;\\n\\t\\t\\t\\t\\tDdN = - DdN;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tdiff.subVectors( this.origin, a );\\n\\t\\t\\t\\tvar DdQxE2 = sign * this.direction.dot( edge2.crossVectors( diff, edge2 ) );\\n\\n\\t\\t\\t\\t// b1 < 0, no intersection\\n\\t\\t\\t\\tif ( DdQxE2 < 0 ) {\\n\\n\\t\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar DdE1xQ = sign * this.direction.dot( edge1.cross( diff ) );\\n\\n\\t\\t\\t\\t// b2 < 0, no intersection\\n\\t\\t\\t\\tif ( DdE1xQ < 0 ) {\\n\\n\\t\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// b1+b2 > 1, no intersection\\n\\t\\t\\t\\tif ( DdQxE2 + DdE1xQ > DdN ) {\\n\\n\\t\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// Line intersects triangle, check if ray does.\\n\\t\\t\\t\\tvar QdN = - sign * diff.dot( normal );\\n\\n\\t\\t\\t\\t// t < 0, no intersection\\n\\t\\t\\t\\tif ( QdN < 0 ) {\\n\\n\\t\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// Ray intersects triangle.\\n\\t\\t\\t\\treturn this.at( QdN / DdN, optionalTarget );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tapplyMatrix4: function ( matrix4 ) {\\n\\n\\t\\t\\tthis.origin.applyMatrix4( matrix4 );\\n\\t\\t\\tthis.direction.transformDirection( matrix4 );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( ray ) {\\n\\n\\t\\t\\treturn ray.origin.equals( this.origin ) && ray.direction.equals( this.direction );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author bhouston / http://clara.io\\n\\t */\\n\\n\\tfunction Line3( start, end ) {\\n\\n\\t\\tthis.start = ( start !== undefined ) ? start : new Vector3();\\n\\t\\tthis.end = ( end !== undefined ) ? end : new Vector3();\\n\\n\\t}\\n\\n\\tObject.assign( Line3.prototype, {\\n\\n\\t\\tset: function ( start, end ) {\\n\\n\\t\\t\\tthis.start.copy( start );\\n\\t\\t\\tthis.end.copy( end );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( line ) {\\n\\n\\t\\t\\tthis.start.copy( line.start );\\n\\t\\t\\tthis.end.copy( line.end );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetCenter: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\t\\t\\treturn result.addVectors( this.start, this.end ).multiplyScalar( 0.5 );\\n\\n\\t\\t},\\n\\n\\t\\tdelta: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\t\\t\\treturn result.subVectors( this.end, this.start );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceSq: function () {\\n\\n\\t\\t\\treturn this.start.distanceToSquared( this.end );\\n\\n\\t\\t},\\n\\n\\t\\tdistance: function () {\\n\\n\\t\\t\\treturn this.start.distanceTo( this.end );\\n\\n\\t\\t},\\n\\n\\t\\tat: function ( t, optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\treturn this.delta( result ).multiplyScalar( t ).add( this.start );\\n\\n\\t\\t},\\n\\n\\t\\tclosestPointToPointParameter: function () {\\n\\n\\t\\t\\tvar startP = new Vector3();\\n\\t\\t\\tvar startEnd = new Vector3();\\n\\n\\t\\t\\treturn function closestPointToPointParameter( point, clampToLine ) {\\n\\n\\t\\t\\t\\tstartP.subVectors( point, this.start );\\n\\t\\t\\t\\tstartEnd.subVectors( this.end, this.start );\\n\\n\\t\\t\\t\\tvar startEnd2 = startEnd.dot( startEnd );\\n\\t\\t\\t\\tvar startEnd_startP = startEnd.dot( startP );\\n\\n\\t\\t\\t\\tvar t = startEnd_startP / startEnd2;\\n\\n\\t\\t\\t\\tif ( clampToLine ) {\\n\\n\\t\\t\\t\\t\\tt = _Math.clamp( t, 0, 1 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn t;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tclosestPointToPoint: function ( point, clampToLine, optionalTarget ) {\\n\\n\\t\\t\\tvar t = this.closestPointToPointParameter( point, clampToLine );\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\treturn this.delta( result ).multiplyScalar( t ).add( this.start );\\n\\n\\t\\t},\\n\\n\\t\\tapplyMatrix4: function ( matrix ) {\\n\\n\\t\\t\\tthis.start.applyMatrix4( matrix );\\n\\t\\t\\tthis.end.applyMatrix4( matrix );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( line ) {\\n\\n\\t\\t\\treturn line.start.equals( this.start ) && line.end.equals( this.end );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author bhouston / http://clara.io\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Triangle( a, b, c ) {\\n\\n\\t\\tthis.a = ( a !== undefined ) ? a : new Vector3();\\n\\t\\tthis.b = ( b !== undefined ) ? b : new Vector3();\\n\\t\\tthis.c = ( c !== undefined ) ? c : new Vector3();\\n\\n\\t}\\n\\n\\tObject.assign( Triangle, {\\n\\n\\t\\tnormal: function () {\\n\\n\\t\\t\\tvar v0 = new Vector3();\\n\\n\\t\\t\\treturn function normal( a, b, c, optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\t\\tresult.subVectors( c, b );\\n\\t\\t\\t\\tv0.subVectors( a, b );\\n\\t\\t\\t\\tresult.cross( v0 );\\n\\n\\t\\t\\t\\tvar resultLengthSq = result.lengthSq();\\n\\t\\t\\t\\tif ( resultLengthSq > 0 ) {\\n\\n\\t\\t\\t\\t\\treturn result.multiplyScalar( 1 / Math.sqrt( resultLengthSq ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn result.set( 0, 0, 0 );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\t// static/instance method to calculate barycentric coordinates\\n\\t\\t// based on: http://www.blackpawn.com/texts/pointinpoly/default.html\\n\\t\\tbarycoordFromPoint: function () {\\n\\n\\t\\t\\tvar v0 = new Vector3();\\n\\t\\t\\tvar v1 = new Vector3();\\n\\t\\t\\tvar v2 = new Vector3();\\n\\n\\t\\t\\treturn function barycoordFromPoint( point, a, b, c, optionalTarget ) {\\n\\n\\t\\t\\t\\tv0.subVectors( c, a );\\n\\t\\t\\t\\tv1.subVectors( b, a );\\n\\t\\t\\t\\tv2.subVectors( point, a );\\n\\n\\t\\t\\t\\tvar dot00 = v0.dot( v0 );\\n\\t\\t\\t\\tvar dot01 = v0.dot( v1 );\\n\\t\\t\\t\\tvar dot02 = v0.dot( v2 );\\n\\t\\t\\t\\tvar dot11 = v1.dot( v1 );\\n\\t\\t\\t\\tvar dot12 = v1.dot( v2 );\\n\\n\\t\\t\\t\\tvar denom = ( dot00 * dot11 - dot01 * dot01 );\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\t\\t// collinear or singular triangle\\n\\t\\t\\t\\tif ( denom === 0 ) {\\n\\n\\t\\t\\t\\t\\t// arbitrary location outside of triangle?\\n\\t\\t\\t\\t\\t// not sure if this is the best idea, maybe should be returning undefined\\n\\t\\t\\t\\t\\treturn result.set( - 2, - 1, - 1 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar invDenom = 1 / denom;\\n\\t\\t\\t\\tvar u = ( dot11 * dot02 - dot01 * dot12 ) * invDenom;\\n\\t\\t\\t\\tvar v = ( dot00 * dot12 - dot01 * dot02 ) * invDenom;\\n\\n\\t\\t\\t\\t// barycentric coordinates must always sum to 1\\n\\t\\t\\t\\treturn result.set( 1 - u - v, v, u );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tcontainsPoint: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function containsPoint( point, a, b, c ) {\\n\\n\\t\\t\\t\\tvar result = Triangle.barycoordFromPoint( point, a, b, c, v1 );\\n\\n\\t\\t\\t\\treturn ( result.x >= 0 ) && ( result.y >= 0 ) && ( ( result.x + result.y ) <= 1 );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}()\\n\\n\\t} );\\n\\n\\tObject.assign( Triangle.prototype, {\\n\\n\\t\\tset: function ( a, b, c ) {\\n\\n\\t\\t\\tthis.a.copy( a );\\n\\t\\t\\tthis.b.copy( b );\\n\\t\\t\\tthis.c.copy( c );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromPointsAndIndices: function ( points, i0, i1, i2 ) {\\n\\n\\t\\t\\tthis.a.copy( points[ i0 ] );\\n\\t\\t\\tthis.b.copy( points[ i1 ] );\\n\\t\\t\\tthis.c.copy( points[ i2 ] );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( triangle ) {\\n\\n\\t\\t\\tthis.a.copy( triangle.a );\\n\\t\\t\\tthis.b.copy( triangle.b );\\n\\t\\t\\tthis.c.copy( triangle.c );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tarea: function () {\\n\\n\\t\\t\\tvar v0 = new Vector3();\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function area() {\\n\\n\\t\\t\\t\\tv0.subVectors( this.c, this.b );\\n\\t\\t\\t\\tv1.subVectors( this.a, this.b );\\n\\n\\t\\t\\t\\treturn v0.cross( v1 ).length() * 0.5;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tmidpoint: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\t\\t\\treturn result.addVectors( this.a, this.b ).add( this.c ).multiplyScalar( 1 / 3 );\\n\\n\\t\\t},\\n\\n\\t\\tnormal: function ( optionalTarget ) {\\n\\n\\t\\t\\treturn Triangle.normal( this.a, this.b, this.c, optionalTarget );\\n\\n\\t\\t},\\n\\n\\t\\tplane: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Plane();\\n\\n\\t\\t\\treturn result.setFromCoplanarPoints( this.a, this.b, this.c );\\n\\n\\t\\t},\\n\\n\\t\\tbarycoordFromPoint: function ( point, optionalTarget ) {\\n\\n\\t\\t\\treturn Triangle.barycoordFromPoint( point, this.a, this.b, this.c, optionalTarget );\\n\\n\\t\\t},\\n\\n\\t\\tcontainsPoint: function ( point ) {\\n\\n\\t\\t\\treturn Triangle.containsPoint( point, this.a, this.b, this.c );\\n\\n\\t\\t},\\n\\n\\t\\tclosestPointToPoint: function () {\\n\\n\\t\\t\\tvar plane = new Plane();\\n\\t\\t\\tvar edgeList = [ new Line3(), new Line3(), new Line3() ];\\n\\t\\t\\tvar projectedPoint = new Vector3();\\n\\t\\t\\tvar closestPoint = new Vector3();\\n\\n\\t\\t\\treturn function closestPointToPoint( point, optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\t\\t\\t\\tvar minDistance = Infinity;\\n\\n\\t\\t\\t\\t// project the point onto the plane of the triangle\\n\\n\\t\\t\\t\\tplane.setFromCoplanarPoints( this.a, this.b, this.c );\\n\\t\\t\\t\\tplane.projectPoint( point, projectedPoint );\\n\\n\\t\\t\\t\\t// check if the projection lies within the triangle\\n\\n\\t\\t\\t\\tif ( this.containsPoint( projectedPoint ) === true ) {\\n\\n\\t\\t\\t\\t\\t// if so, this is the closest point\\n\\n\\t\\t\\t\\t\\tresult.copy( projectedPoint );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// if not, the point falls outside the triangle. the result is the closest point to the triangle's edges or vertices\\n\\n\\t\\t\\t\\t\\tedgeList[ 0 ].set( this.a, this.b );\\n\\t\\t\\t\\t\\tedgeList[ 1 ].set( this.b, this.c );\\n\\t\\t\\t\\t\\tedgeList[ 2 ].set( this.c, this.a );\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < edgeList.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tedgeList[ i ].closestPointToPoint( projectedPoint, true, closestPoint );\\n\\n\\t\\t\\t\\t\\t\\tvar distance = projectedPoint.distanceToSquared( closestPoint );\\n\\n\\t\\t\\t\\t\\t\\tif ( distance < minDistance ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tminDistance = distance;\\n\\n\\t\\t\\t\\t\\t\\t\\tresult.copy( closestPoint );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn result;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tequals: function ( triangle ) {\\n\\n\\t\\t\\treturn triangle.a.equals( this.a ) && triangle.b.equals( this.b ) && triangle.c.equals( this.c );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author jonobr1 / http://jonobr1.com/\\n\\t */\\n\\n\\tfunction Mesh( geometry, material ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Mesh';\\n\\n\\t\\tthis.geometry = geometry !== undefined ? geometry : new BufferGeometry();\\n\\t\\tthis.material = material !== undefined ? material : new MeshBasicMaterial( { color: Math.random() * 0xffffff } );\\n\\n\\t\\tthis.drawMode = TrianglesDrawMode;\\n\\n\\t\\tthis.updateMorphTargets();\\n\\n\\t}\\n\\n\\tMesh.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Mesh,\\n\\n\\t\\tisMesh: true,\\n\\n\\t\\tsetDrawMode: function ( value ) {\\n\\n\\t\\t\\tthis.drawMode = value;\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tObject3D.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.drawMode = source.drawMode;\\n\\n\\t\\t\\tif ( source.morphTargetInfluences !== undefined ) {\\n\\n\\t\\t\\t\\tthis.morphTargetInfluences = source.morphTargetInfluences.slice();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( source.morphTargetDictionary !== undefined ) {\\n\\n\\t\\t\\t\\tthis.morphTargetDictionary = Object.assign( {}, source.morphTargetDictionary );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tupdateMorphTargets: function () {\\n\\n\\t\\t\\tvar geometry = this.geometry;\\n\\t\\t\\tvar m, ml, name;\\n\\n\\t\\t\\tif ( geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\tvar morphAttributes = geometry.morphAttributes;\\n\\t\\t\\t\\tvar keys = Object.keys( morphAttributes );\\n\\n\\t\\t\\t\\tif ( keys.length > 0 ) {\\n\\n\\t\\t\\t\\t\\tvar morphAttribute = morphAttributes[ keys[ 0 ] ];\\n\\n\\t\\t\\t\\t\\tif ( morphAttribute !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tthis.morphTargetInfluences = [];\\n\\t\\t\\t\\t\\t\\tthis.morphTargetDictionary = {};\\n\\n\\t\\t\\t\\t\\t\\tfor ( m = 0, ml = morphAttribute.length; m < ml; m ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tname = morphAttribute[ m ].name || String( m );\\n\\n\\t\\t\\t\\t\\t\\t\\tthis.morphTargetInfluences.push( 0 );\\n\\t\\t\\t\\t\\t\\t\\tthis.morphTargetDictionary[ name ] = m;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tvar morphTargets = geometry.morphTargets;\\n\\n\\t\\t\\t\\tif ( morphTargets !== undefined && morphTargets.length > 0 ) {\\n\\n\\t\\t\\t\\t\\tthis.morphTargetInfluences = [];\\n\\t\\t\\t\\t\\tthis.morphTargetDictionary = {};\\n\\n\\t\\t\\t\\t\\tfor ( m = 0, ml = morphTargets.length; m < ml; m ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tname = morphTargets[ m ].name || String( m );\\n\\n\\t\\t\\t\\t\\t\\tthis.morphTargetInfluences.push( 0 );\\n\\t\\t\\t\\t\\t\\tthis.morphTargetDictionary[ name ] = m;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\traycast: ( function () {\\n\\n\\t\\t\\tvar inverseMatrix = new Matrix4();\\n\\t\\t\\tvar ray = new Ray();\\n\\t\\t\\tvar sphere = new Sphere();\\n\\n\\t\\t\\tvar vA = new Vector3();\\n\\t\\t\\tvar vB = new Vector3();\\n\\t\\t\\tvar vC = new Vector3();\\n\\n\\t\\t\\tvar tempA = new Vector3();\\n\\t\\t\\tvar tempB = new Vector3();\\n\\t\\t\\tvar tempC = new Vector3();\\n\\n\\t\\t\\tvar uvA = new Vector2();\\n\\t\\t\\tvar uvB = new Vector2();\\n\\t\\t\\tvar uvC = new Vector2();\\n\\n\\t\\t\\tvar barycoord = new Vector3();\\n\\n\\t\\t\\tvar intersectionPoint = new Vector3();\\n\\t\\t\\tvar intersectionPointWorld = new Vector3();\\n\\n\\t\\t\\tfunction uvIntersection( point, p1, p2, p3, uv1, uv2, uv3 ) {\\n\\n\\t\\t\\t\\tTriangle.barycoordFromPoint( point, p1, p2, p3, barycoord );\\n\\n\\t\\t\\t\\tuv1.multiplyScalar( barycoord.x );\\n\\t\\t\\t\\tuv2.multiplyScalar( barycoord.y );\\n\\t\\t\\t\\tuv3.multiplyScalar( barycoord.z );\\n\\n\\t\\t\\t\\tuv1.add( uv2 ).add( uv3 );\\n\\n\\t\\t\\t\\treturn uv1.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction checkIntersection( object, material, raycaster, ray, pA, pB, pC, point ) {\\n\\n\\t\\t\\t\\tvar intersect;\\n\\n\\t\\t\\t\\tif ( material.side === BackSide ) {\\n\\n\\t\\t\\t\\t\\tintersect = ray.intersectTriangle( pC, pB, pA, true, point );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tintersect = ray.intersectTriangle( pA, pB, pC, material.side !== DoubleSide, point );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( intersect === null ) return null;\\n\\n\\t\\t\\t\\tintersectionPointWorld.copy( point );\\n\\t\\t\\t\\tintersectionPointWorld.applyMatrix4( object.matrixWorld );\\n\\n\\t\\t\\t\\tvar distance = raycaster.ray.origin.distanceTo( intersectionPointWorld );\\n\\n\\t\\t\\t\\tif ( distance < raycaster.near || distance > raycaster.far ) return null;\\n\\n\\t\\t\\t\\treturn {\\n\\t\\t\\t\\t\\tdistance: distance,\\n\\t\\t\\t\\t\\tpoint: intersectionPointWorld.clone(),\\n\\t\\t\\t\\t\\tobject: object\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction checkBufferGeometryIntersection( object, raycaster, ray, position, uv, a, b, c ) {\\n\\n\\t\\t\\t\\tvA.fromBufferAttribute( position, a );\\n\\t\\t\\t\\tvB.fromBufferAttribute( position, b );\\n\\t\\t\\t\\tvC.fromBufferAttribute( position, c );\\n\\n\\t\\t\\t\\tvar intersection = checkIntersection( object, object.material, raycaster, ray, vA, vB, vC, intersectionPoint );\\n\\n\\t\\t\\t\\tif ( intersection ) {\\n\\n\\t\\t\\t\\t\\tif ( uv ) {\\n\\n\\t\\t\\t\\t\\t\\tuvA.fromBufferAttribute( uv, a );\\n\\t\\t\\t\\t\\t\\tuvB.fromBufferAttribute( uv, b );\\n\\t\\t\\t\\t\\t\\tuvC.fromBufferAttribute( uv, c );\\n\\n\\t\\t\\t\\t\\t\\tintersection.uv = uvIntersection( intersectionPoint, vA, vB, vC, uvA, uvB, uvC );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tintersection.face = new Face3( a, b, c, Triangle.normal( vA, vB, vC ) );\\n\\t\\t\\t\\t\\tintersection.faceIndex = a;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn intersection;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn function raycast( raycaster, intersects ) {\\n\\n\\t\\t\\t\\tvar geometry = this.geometry;\\n\\t\\t\\t\\tvar material = this.material;\\n\\t\\t\\t\\tvar matrixWorld = this.matrixWorld;\\n\\n\\t\\t\\t\\tif ( material === undefined ) return;\\n\\n\\t\\t\\t\\t// Checking boundingSphere distance to ray\\n\\n\\t\\t\\t\\tif ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();\\n\\n\\t\\t\\t\\tsphere.copy( geometry.boundingSphere );\\n\\t\\t\\t\\tsphere.applyMatrix4( matrixWorld );\\n\\n\\t\\t\\t\\tif ( raycaster.ray.intersectsSphere( sphere ) === false ) return;\\n\\n\\t\\t\\t\\t//\\n\\n\\t\\t\\t\\tinverseMatrix.getInverse( matrixWorld );\\n\\t\\t\\t\\tray.copy( raycaster.ray ).applyMatrix4( inverseMatrix );\\n\\n\\t\\t\\t\\t// Check boundingBox before continuing\\n\\n\\t\\t\\t\\tif ( geometry.boundingBox !== null ) {\\n\\n\\t\\t\\t\\t\\tif ( ray.intersectsBox( geometry.boundingBox ) === false ) return;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar intersection;\\n\\n\\t\\t\\t\\tif ( geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\t\\tvar a, b, c;\\n\\t\\t\\t\\t\\tvar index = geometry.index;\\n\\t\\t\\t\\t\\tvar position = geometry.attributes.position;\\n\\t\\t\\t\\t\\tvar uv = geometry.attributes.uv;\\n\\t\\t\\t\\t\\tvar i, l;\\n\\n\\t\\t\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\t\\t\\t// indexed buffer geometry\\n\\n\\t\\t\\t\\t\\t\\tfor ( i = 0, l = index.count; i < l; i += 3 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\ta = index.getX( i );\\n\\t\\t\\t\\t\\t\\t\\tb = index.getX( i + 1 );\\n\\t\\t\\t\\t\\t\\t\\tc = index.getX( i + 2 );\\n\\n\\t\\t\\t\\t\\t\\t\\tintersection = checkBufferGeometryIntersection( this, raycaster, ray, position, uv, a, b, c );\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( intersection ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tintersection.faceIndex = Math.floor( i / 3 ); // triangle number in indices buffer semantics\\n\\t\\t\\t\\t\\t\\t\\t\\tintersects.push( intersection );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else if ( position !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t// non-indexed buffer geometry\\n\\n\\t\\t\\t\\t\\t\\tfor ( i = 0, l = position.count; i < l; i += 3 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\ta = i;\\n\\t\\t\\t\\t\\t\\t\\tb = i + 1;\\n\\t\\t\\t\\t\\t\\t\\tc = i + 2;\\n\\n\\t\\t\\t\\t\\t\\t\\tintersection = checkBufferGeometryIntersection( this, raycaster, ray, position, uv, a, b, c );\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( intersection ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tintersection.index = a; // triangle number in positions buffer semantics\\n\\t\\t\\t\\t\\t\\t\\t\\tintersects.push( intersection );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( geometry.isGeometry ) {\\n\\n\\t\\t\\t\\t\\tvar fvA, fvB, fvC;\\n\\t\\t\\t\\t\\tvar isMultiMaterial = Array.isArray( material );\\n\\n\\t\\t\\t\\t\\tvar vertices = geometry.vertices;\\n\\t\\t\\t\\t\\tvar faces = geometry.faces;\\n\\t\\t\\t\\t\\tvar uvs;\\n\\n\\t\\t\\t\\t\\tvar faceVertexUvs = geometry.faceVertexUvs[ 0 ];\\n\\t\\t\\t\\t\\tif ( faceVertexUvs.length > 0 ) uvs = faceVertexUvs;\\n\\n\\t\\t\\t\\t\\tfor ( var f = 0, fl = faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar face = faces[ f ];\\n\\t\\t\\t\\t\\t\\tvar faceMaterial = isMultiMaterial ? material[ face.materialIndex ] : material;\\n\\n\\t\\t\\t\\t\\t\\tif ( faceMaterial === undefined ) continue;\\n\\n\\t\\t\\t\\t\\t\\tfvA = vertices[ face.a ];\\n\\t\\t\\t\\t\\t\\tfvB = vertices[ face.b ];\\n\\t\\t\\t\\t\\t\\tfvC = vertices[ face.c ];\\n\\n\\t\\t\\t\\t\\t\\tif ( faceMaterial.morphTargets === true ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar morphTargets = geometry.morphTargets;\\n\\t\\t\\t\\t\\t\\t\\tvar morphInfluences = this.morphTargetInfluences;\\n\\n\\t\\t\\t\\t\\t\\t\\tvA.set( 0, 0, 0 );\\n\\t\\t\\t\\t\\t\\t\\tvB.set( 0, 0, 0 );\\n\\t\\t\\t\\t\\t\\t\\tvC.set( 0, 0, 0 );\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var t = 0, tl = morphTargets.length; t < tl; t ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tvar influence = morphInfluences[ t ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( influence === 0 ) continue;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tvar targets = morphTargets[ t ].vertices;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tvA.addScaledVector( tempA.subVectors( targets[ face.a ], fvA ), influence );\\n\\t\\t\\t\\t\\t\\t\\t\\tvB.addScaledVector( tempB.subVectors( targets[ face.b ], fvB ), influence );\\n\\t\\t\\t\\t\\t\\t\\t\\tvC.addScaledVector( tempC.subVectors( targets[ face.c ], fvC ), influence );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\tvA.add( fvA );\\n\\t\\t\\t\\t\\t\\t\\tvB.add( fvB );\\n\\t\\t\\t\\t\\t\\t\\tvC.add( fvC );\\n\\n\\t\\t\\t\\t\\t\\t\\tfvA = vA;\\n\\t\\t\\t\\t\\t\\t\\tfvB = vB;\\n\\t\\t\\t\\t\\t\\t\\tfvC = vC;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tintersection = checkIntersection( this, faceMaterial, raycaster, ray, fvA, fvB, fvC, intersectionPoint );\\n\\n\\t\\t\\t\\t\\t\\tif ( intersection ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( uvs && uvs[ f ] ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tvar uvs_f = uvs[ f ];\\n\\t\\t\\t\\t\\t\\t\\t\\tuvA.copy( uvs_f[ 0 ] );\\n\\t\\t\\t\\t\\t\\t\\t\\tuvB.copy( uvs_f[ 1 ] );\\n\\t\\t\\t\\t\\t\\t\\t\\tuvC.copy( uvs_f[ 2 ] );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tintersection.uv = uvIntersection( intersectionPoint, fvA, fvB, fvC, uvA, uvB, uvC );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\tintersection.face = face;\\n\\t\\t\\t\\t\\t\\t\\tintersection.faceIndex = f;\\n\\t\\t\\t\\t\\t\\t\\tintersects.push( intersection );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}() ),\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.geometry, this.material ).copy( this );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLBackground( renderer, state, geometries, premultipliedAlpha ) {\\n\\n\\t\\tvar clearColor = new Color( 0x000000 );\\n\\t\\tvar clearAlpha = 0;\\n\\n\\t\\tvar planeCamera, planeMesh;\\n\\t\\tvar boxMesh;\\n\\n\\t\\tfunction render( renderList, scene, camera, forceClear ) {\\n\\n\\t\\t\\tvar background = scene.background;\\n\\n\\t\\t\\tif ( background === null ) {\\n\\n\\t\\t\\t\\tsetClear( clearColor, clearAlpha );\\n\\n\\t\\t\\t} else if ( background && background.isColor ) {\\n\\n\\t\\t\\t\\tsetClear( background, 1 );\\n\\t\\t\\t\\tforceClear = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( renderer.autoClear || forceClear ) {\\n\\n\\t\\t\\t\\trenderer.clear( renderer.autoClearColor, renderer.autoClearDepth, renderer.autoClearStencil );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( background && background.isCubeTexture ) {\\n\\n\\t\\t\\t\\tif ( boxMesh === undefined ) {\\n\\n\\t\\t\\t\\t\\tboxMesh = new Mesh(\\n\\t\\t\\t\\t\\t\\tnew BoxBufferGeometry( 1, 1, 1 ),\\n\\t\\t\\t\\t\\t\\tnew ShaderMaterial( {\\n\\t\\t\\t\\t\\t\\t\\tuniforms: ShaderLib.cube.uniforms,\\n\\t\\t\\t\\t\\t\\t\\tvertexShader: ShaderLib.cube.vertexShader,\\n\\t\\t\\t\\t\\t\\t\\tfragmentShader: ShaderLib.cube.fragmentShader,\\n\\t\\t\\t\\t\\t\\t\\tside: BackSide,\\n\\t\\t\\t\\t\\t\\t\\tdepthTest: true,\\n\\t\\t\\t\\t\\t\\t\\tdepthWrite: false,\\n\\t\\t\\t\\t\\t\\t\\tfog: false\\n\\t\\t\\t\\t\\t\\t} )\\n\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\tboxMesh.geometry.removeAttribute( 'normal' );\\n\\t\\t\\t\\t\\tboxMesh.geometry.removeAttribute( 'uv' );\\n\\n\\t\\t\\t\\t\\tboxMesh.onBeforeRender = function ( renderer, scene, camera ) {\\n\\n\\t\\t\\t\\t\\t\\tthis.matrixWorld.copyPosition( camera.matrixWorld );\\n\\n\\t\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\t\\tgeometries.update( boxMesh.geometry );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tboxMesh.material.uniforms.tCube.value = background;\\n\\n\\t\\t\\t\\trenderList.push( boxMesh, boxMesh.geometry, boxMesh.material, 0, null );\\n\\n\\t\\t\\t} else if ( background && background.isTexture ) {\\n\\n\\t\\t\\t\\tif ( planeCamera === undefined ) {\\n\\n\\t\\t\\t\\t\\tplaneCamera = new OrthographicCamera( - 1, 1, 1, - 1, 0, 1 );\\n\\n\\t\\t\\t\\t\\tplaneMesh = new Mesh(\\n\\t\\t\\t\\t\\t\\tnew PlaneBufferGeometry( 2, 2 ),\\n\\t\\t\\t\\t\\t\\tnew MeshBasicMaterial( { depthTest: false, depthWrite: false, fog: false } )\\n\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\tgeometries.update( planeMesh.geometry );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tplaneMesh.material.map = background;\\n\\n\\t\\t\\t\\t// TODO Push this to renderList\\n\\n\\t\\t\\t\\trenderer.renderBufferDirect( planeCamera, null, planeMesh.geometry, planeMesh.material, planeMesh, null );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction setClear( color, alpha ) {\\n\\n\\t\\t\\tstate.buffers.color.setClear( color.r, color.g, color.b, alpha, premultipliedAlpha );\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tgetClearColor: function () {\\n\\n\\t\\t\\t\\treturn clearColor;\\n\\n\\t\\t\\t},\\n\\t\\t\\tsetClearColor: function ( color, alpha ) {\\n\\n\\t\\t\\t\\tclearColor.set( color );\\n\\t\\t\\t\\tclearAlpha = alpha !== undefined ? alpha : 1;\\n\\t\\t\\t\\tsetClear( clearColor, clearAlpha );\\n\\n\\t\\t\\t},\\n\\t\\t\\tgetClearAlpha: function () {\\n\\n\\t\\t\\t\\treturn clearAlpha;\\n\\n\\t\\t\\t},\\n\\t\\t\\tsetClearAlpha: function ( alpha ) {\\n\\n\\t\\t\\t\\tclearAlpha = alpha;\\n\\t\\t\\t\\tsetClear( clearColor, clearAlpha );\\n\\n\\t\\t\\t},\\n\\t\\t\\trender: render\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction painterSortStable( a, b ) {\\n\\n\\t\\tif ( a.renderOrder !== b.renderOrder ) {\\n\\n\\t\\t\\treturn a.renderOrder - b.renderOrder;\\n\\n\\t\\t} else if ( a.program && b.program && a.program !== b.program ) {\\n\\n\\t\\t\\treturn a.program.id - b.program.id;\\n\\n\\t\\t} else if ( a.material.id !== b.material.id ) {\\n\\n\\t\\t\\treturn a.material.id - b.material.id;\\n\\n\\t\\t} else if ( a.z !== b.z ) {\\n\\n\\t\\t\\treturn a.z - b.z;\\n\\n\\t\\t} else {\\n\\n\\t\\t\\treturn a.id - b.id;\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tfunction reversePainterSortStable( a, b ) {\\n\\n\\t\\tif ( a.renderOrder !== b.renderOrder ) {\\n\\n\\t\\t\\treturn a.renderOrder - b.renderOrder;\\n\\n\\t\\t} if ( a.z !== b.z ) {\\n\\n\\t\\t\\treturn b.z - a.z;\\n\\n\\t\\t} else {\\n\\n\\t\\t\\treturn a.id - b.id;\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tfunction WebGLRenderList() {\\n\\n\\t\\tvar renderItems = [];\\n\\t\\tvar renderItemsIndex = 0;\\n\\n\\t\\tvar opaque = [];\\n\\t\\tvar transparent = [];\\n\\n\\t\\tfunction init() {\\n\\n\\t\\t\\trenderItemsIndex = 0;\\n\\n\\t\\t\\topaque.length = 0;\\n\\t\\t\\ttransparent.length = 0;\\n\\n\\t\\t}\\n\\n\\t\\tfunction push( object, geometry, material, z, group ) {\\n\\n\\t\\t\\tvar renderItem = renderItems[ renderItemsIndex ];\\n\\n\\t\\t\\tif ( renderItem === undefined ) {\\n\\n\\t\\t\\t\\trenderItem = {\\n\\t\\t\\t\\t\\tid: object.id,\\n\\t\\t\\t\\t\\tobject: object,\\n\\t\\t\\t\\t\\tgeometry: geometry,\\n\\t\\t\\t\\t\\tmaterial: material,\\n\\t\\t\\t\\t\\tprogram: material.program,\\n\\t\\t\\t\\t\\trenderOrder: object.renderOrder,\\n\\t\\t\\t\\t\\tz: z,\\n\\t\\t\\t\\t\\tgroup: group\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\trenderItems[ renderItemsIndex ] = renderItem;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\trenderItem.id = object.id;\\n\\t\\t\\t\\trenderItem.object = object;\\n\\t\\t\\t\\trenderItem.geometry = geometry;\\n\\t\\t\\t\\trenderItem.material = material;\\n\\t\\t\\t\\trenderItem.program = material.program;\\n\\t\\t\\t\\trenderItem.renderOrder = object.renderOrder;\\n\\t\\t\\t\\trenderItem.z = z;\\n\\t\\t\\t\\trenderItem.group = group;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t( material.transparent === true ? transparent : opaque ).push( renderItem );\\n\\n\\t\\t\\trenderItemsIndex ++;\\n\\n\\t\\t}\\n\\n\\t\\tfunction sort() {\\n\\n\\t\\t\\tif ( opaque.length > 1 ) opaque.sort( painterSortStable );\\n\\t\\t\\tif ( transparent.length > 1 ) transparent.sort( reversePainterSortStable );\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\t\\t\\topaque: opaque,\\n\\t\\t\\ttransparent: transparent,\\n\\n\\t\\t\\tinit: init,\\n\\t\\t\\tpush: push,\\n\\n\\t\\t\\tsort: sort\\n\\t\\t};\\n\\n\\t}\\n\\n\\tfunction WebGLRenderLists() {\\n\\n\\t\\tvar lists = {};\\n\\n\\t\\tfunction get( scene, camera ) {\\n\\n\\t\\t\\tvar hash = scene.id + ',' + camera.id;\\n\\t\\t\\tvar list = lists[ hash ];\\n\\n\\t\\t\\tif ( list === undefined ) {\\n\\n\\t\\t\\t\\t// console.log( 'THREE.WebGLRenderLists:', hash );\\n\\n\\t\\t\\t\\tlist = new WebGLRenderList();\\n\\t\\t\\t\\tlists[ hash ] = list;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn list;\\n\\n\\t\\t}\\n\\n\\t\\tfunction dispose() {\\n\\n\\t\\t\\tlists = {};\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\t\\t\\tget: get,\\n\\t\\t\\tdispose: dispose\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction absNumericalSort( a, b ) {\\n\\n\\t\\treturn Math.abs( b[ 1 ] ) - Math.abs( a[ 1 ] );\\n\\n\\t}\\n\\n\\tfunction WebGLMorphtargets( gl ) {\\n\\n\\t\\tvar influencesList = {};\\n\\t\\tvar morphInfluences = new Float32Array( 8 );\\n\\n\\t\\tfunction update( object, geometry, material, program ) {\\n\\n\\t\\t\\tvar objectInfluences = object.morphTargetInfluences;\\n\\n\\t\\t\\tvar length = objectInfluences.length;\\n\\n\\t\\t\\tvar influences = influencesList[ geometry.id ];\\n\\n\\t\\t\\tif ( influences === undefined ) {\\n\\n\\t\\t\\t\\t// initialise list\\n\\n\\t\\t\\t\\tinfluences = [];\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tinfluences[ i ] = [ i, 0 ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tinfluencesList[ geometry.id ] = influences;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar morphTargets = material.morphTargets && geometry.morphAttributes.position;\\n\\t\\t\\tvar morphNormals = material.morphNormals && geometry.morphAttributes.normal;\\n\\n\\t\\t\\t// Remove current morphAttributes\\n\\n\\t\\t\\tfor ( var i = 0; i < length; i ++ ) {\\n\\n\\t\\t\\t\\tvar influence = influences[ i ];\\n\\n\\t\\t\\t\\tif ( influence[ 1 ] !== 0 ) {\\n\\n\\t\\t\\t\\t\\tif ( morphTargets ) geometry.removeAttribute( 'morphTarget' + i );\\n\\t\\t\\t\\t\\tif ( morphNormals ) geometry.removeAttribute( 'morphNormal' + i );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Collect influences\\n\\n\\t\\t\\tfor ( var i = 0; i < length; i ++ ) {\\n\\n\\t\\t\\t\\tvar influence = influences[ i ];\\n\\n\\t\\t\\t\\tinfluence[ 0 ] = i;\\n\\t\\t\\t\\tinfluence[ 1 ] = objectInfluences[ i ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tinfluences.sort( absNumericalSort );\\n\\n\\t\\t\\t// Add morphAttributes\\n\\n\\t\\t\\tfor ( var i = 0; i < 8; i ++ ) {\\n\\n\\t\\t\\t\\tvar influence = influences[ i ];\\n\\n\\t\\t\\t\\tif ( influence ) {\\n\\n\\t\\t\\t\\t\\tvar index = influence[ 0 ];\\n\\t\\t\\t\\t\\tvar value = influence[ 1 ];\\n\\n\\t\\t\\t\\t\\tif ( value ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( morphTargets ) geometry.addAttribute( 'morphTarget' + i, morphTargets[ index ] );\\n\\t\\t\\t\\t\\t\\tif ( morphNormals ) geometry.addAttribute( 'morphNormal' + i, morphNormals[ index ] );\\n\\n\\t\\t\\t\\t\\t\\tmorphInfluences[ i ] = value;\\n\\t\\t\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tmorphInfluences[ i ] = 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tprogram.getUniforms().setValue( gl, 'morphTargetInfluences', morphInfluences );\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tupdate: update\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLIndexedBufferRenderer( gl, extensions, infoRender ) {\\n\\n\\t\\tvar mode;\\n\\n\\t\\tfunction setMode( value ) {\\n\\n\\t\\t\\tmode = value;\\n\\n\\t\\t}\\n\\n\\t\\tvar type, bytesPerElement;\\n\\n\\t\\tfunction setIndex( value ) {\\n\\n\\t\\t\\ttype = value.type;\\n\\t\\t\\tbytesPerElement = value.bytesPerElement;\\n\\n\\t\\t}\\n\\n\\t\\tfunction render( start, count ) {\\n\\n\\t\\t\\tgl.drawElements( mode, count, type, start * bytesPerElement );\\n\\n\\t\\t\\tinfoRender.calls ++;\\n\\t\\t\\tinfoRender.vertices += count;\\n\\n\\t\\t\\tif ( mode === gl.TRIANGLES ) infoRender.faces += count / 3;\\n\\t\\t\\telse if ( mode === gl.POINTS ) infoRender.points += count;\\n\\n\\t\\t}\\n\\n\\t\\tfunction renderInstances( geometry, start, count ) {\\n\\n\\t\\t\\tvar extension = extensions.get( 'ANGLE_instanced_arrays' );\\n\\n\\t\\t\\tif ( extension === null ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\textension.drawElementsInstancedANGLE( mode, count, type, start * bytesPerElement, geometry.maxInstancedCount );\\n\\n\\t\\t\\tinfoRender.calls ++;\\n\\t\\t\\tinfoRender.vertices += count * geometry.maxInstancedCount;\\n\\n\\t\\t\\tif ( mode === gl.TRIANGLES ) infoRender.faces += geometry.maxInstancedCount * count / 3;\\n\\t\\t\\telse if ( mode === gl.POINTS ) infoRender.points += geometry.maxInstancedCount * count;\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tthis.setMode = setMode;\\n\\t\\tthis.setIndex = setIndex;\\n\\t\\tthis.render = render;\\n\\t\\tthis.renderInstances = renderInstances;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLBufferRenderer( gl, extensions, infoRender ) {\\n\\n\\t\\tvar mode;\\n\\n\\t\\tfunction setMode( value ) {\\n\\n\\t\\t\\tmode = value;\\n\\n\\t\\t}\\n\\n\\t\\tfunction render( start, count ) {\\n\\n\\t\\t\\tgl.drawArrays( mode, start, count );\\n\\n\\t\\t\\tinfoRender.calls ++;\\n\\t\\t\\tinfoRender.vertices += count;\\n\\n\\t\\t\\tif ( mode === gl.TRIANGLES ) infoRender.faces += count / 3;\\n\\t\\t\\telse if ( mode === gl.POINTS ) infoRender.points += count;\\n\\n\\t\\t}\\n\\n\\t\\tfunction renderInstances( geometry, start, count ) {\\n\\n\\t\\t\\tvar extension = extensions.get( 'ANGLE_instanced_arrays' );\\n\\n\\t\\t\\tif ( extension === null ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar position = geometry.attributes.position;\\n\\n\\t\\t\\tif ( position.isInterleavedBufferAttribute ) {\\n\\n\\t\\t\\t\\tcount = position.data.count;\\n\\n\\t\\t\\t\\textension.drawArraysInstancedANGLE( mode, 0, count, geometry.maxInstancedCount );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\textension.drawArraysInstancedANGLE( mode, start, count, geometry.maxInstancedCount );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tinfoRender.calls ++;\\n\\t\\t\\tinfoRender.vertices += count * geometry.maxInstancedCount;\\n\\n\\t\\t\\tif ( mode === gl.TRIANGLES ) infoRender.faces += geometry.maxInstancedCount * count / 3;\\n\\t\\t\\telse if ( mode === gl.POINTS ) infoRender.points += geometry.maxInstancedCount * count;\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tthis.setMode = setMode;\\n\\t\\tthis.render = render;\\n\\t\\tthis.renderInstances = renderInstances;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLGeometries( gl, attributes, infoMemory ) {\\n\\n\\t\\tvar geometries = {};\\n\\t\\tvar wireframeAttributes = {};\\n\\n\\t\\tfunction onGeometryDispose( event ) {\\n\\n\\t\\t\\tvar geometry = event.target;\\n\\t\\t\\tvar buffergeometry = geometries[ geometry.id ];\\n\\n\\t\\t\\tif ( buffergeometry.index !== null ) {\\n\\n\\t\\t\\t\\tattributes.remove( buffergeometry.index );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var name in buffergeometry.attributes ) {\\n\\n\\t\\t\\t\\tattributes.remove( buffergeometry.attributes[ name ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tgeometry.removeEventListener( 'dispose', onGeometryDispose );\\n\\n\\t\\t\\tdelete geometries[ geometry.id ];\\n\\n\\t\\t\\t// TODO Remove duplicate code\\n\\n\\t\\t\\tvar attribute = wireframeAttributes[ geometry.id ];\\n\\n\\t\\t\\tif ( attribute ) {\\n\\n\\t\\t\\t\\tattributes.remove( attribute );\\n\\t\\t\\t\\tdelete wireframeAttributes[ geometry.id ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tattribute = wireframeAttributes[ buffergeometry.id ];\\n\\n\\t\\t\\tif ( attribute ) {\\n\\n\\t\\t\\t\\tattributes.remove( attribute );\\n\\t\\t\\t\\tdelete wireframeAttributes[ buffergeometry.id ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tinfoMemory.geometries --;\\n\\n\\t\\t}\\n\\n\\t\\tfunction get( object, geometry ) {\\n\\n\\t\\t\\tvar buffergeometry = geometries[ geometry.id ];\\n\\n\\t\\t\\tif ( buffergeometry ) return buffergeometry;\\n\\n\\t\\t\\tgeometry.addEventListener( 'dispose', onGeometryDispose );\\n\\n\\t\\t\\tif ( geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\tbuffergeometry = geometry;\\n\\n\\t\\t\\t} else if ( geometry.isGeometry ) {\\n\\n\\t\\t\\t\\tif ( geometry._bufferGeometry === undefined ) {\\n\\n\\t\\t\\t\\t\\tgeometry._bufferGeometry = new BufferGeometry().setFromObject( object );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tbuffergeometry = geometry._bufferGeometry;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tgeometries[ geometry.id ] = buffergeometry;\\n\\n\\t\\t\\tinfoMemory.geometries ++;\\n\\n\\t\\t\\treturn buffergeometry;\\n\\n\\t\\t}\\n\\n\\t\\tfunction update( geometry ) {\\n\\n\\t\\t\\tvar index = geometry.index;\\n\\t\\t\\tvar geometryAttributes = geometry.attributes;\\n\\n\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\tattributes.update( index, gl.ELEMENT_ARRAY_BUFFER );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var name in geometryAttributes ) {\\n\\n\\t\\t\\t\\tattributes.update( geometryAttributes[ name ], gl.ARRAY_BUFFER );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// morph targets\\n\\n\\t\\t\\tvar morphAttributes = geometry.morphAttributes;\\n\\n\\t\\t\\tfor ( var name in morphAttributes ) {\\n\\n\\t\\t\\t\\tvar array = morphAttributes[ name ];\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = array.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tattributes.update( array[ i ], gl.ARRAY_BUFFER );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction getWireframeAttribute( geometry ) {\\n\\n\\t\\t\\tvar attribute = wireframeAttributes[ geometry.id ];\\n\\n\\t\\t\\tif ( attribute ) return attribute;\\n\\n\\t\\t\\tvar indices = [];\\n\\n\\t\\t\\tvar geometryIndex = geometry.index;\\n\\t\\t\\tvar geometryAttributes = geometry.attributes;\\n\\n\\t\\t\\t// console.time( 'wireframe' );\\n\\n\\t\\t\\tif ( geometryIndex !== null ) {\\n\\n\\t\\t\\t\\tvar array = geometryIndex.array;\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = array.length; i < l; i += 3 ) {\\n\\n\\t\\t\\t\\t\\tvar a = array[ i + 0 ];\\n\\t\\t\\t\\t\\tvar b = array[ i + 1 ];\\n\\t\\t\\t\\t\\tvar c = array[ i + 2 ];\\n\\n\\t\\t\\t\\t\\tindices.push( a, b, b, c, c, a );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tvar array = geometryAttributes.position.array;\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = ( array.length / 3 ) - 1; i < l; i += 3 ) {\\n\\n\\t\\t\\t\\t\\tvar a = i + 0;\\n\\t\\t\\t\\t\\tvar b = i + 1;\\n\\t\\t\\t\\t\\tvar c = i + 2;\\n\\n\\t\\t\\t\\t\\tindices.push( a, b, b, c, c, a );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// console.timeEnd( 'wireframe' );\\n\\n\\t\\t\\tattribute = new ( arrayMax( indices ) > 65535 ? Uint32BufferAttribute : Uint16BufferAttribute )( indices, 1 );\\n\\n\\t\\t\\tattributes.update( attribute, gl.ELEMENT_ARRAY_BUFFER );\\n\\n\\t\\t\\twireframeAttributes[ geometry.id ] = attribute;\\n\\n\\t\\t\\treturn attribute;\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tget: get,\\n\\t\\t\\tupdate: update,\\n\\n\\t\\t\\tgetWireframeAttribute: getWireframeAttribute\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction UniformsCache() {\\n\\n\\t\\tvar lights = {};\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tget: function ( light ) {\\n\\n\\t\\t\\t\\tif ( lights[ light.id ] !== undefined ) {\\n\\n\\t\\t\\t\\t\\treturn lights[ light.id ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar uniforms;\\n\\n\\t\\t\\t\\tswitch ( light.type ) {\\n\\n\\t\\t\\t\\t\\tcase 'DirectionalLight':\\n\\t\\t\\t\\t\\t\\tuniforms = {\\n\\t\\t\\t\\t\\t\\t\\tdirection: new Vector3(),\\n\\t\\t\\t\\t\\t\\t\\tcolor: new Color(),\\n\\n\\t\\t\\t\\t\\t\\t\\tshadow: false,\\n\\t\\t\\t\\t\\t\\t\\tshadowBias: 0,\\n\\t\\t\\t\\t\\t\\t\\tshadowRadius: 1,\\n\\t\\t\\t\\t\\t\\t\\tshadowMapSize: new Vector2()\\n\\t\\t\\t\\t\\t\\t};\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'SpotLight':\\n\\t\\t\\t\\t\\t\\tuniforms = {\\n\\t\\t\\t\\t\\t\\t\\tposition: new Vector3(),\\n\\t\\t\\t\\t\\t\\t\\tdirection: new Vector3(),\\n\\t\\t\\t\\t\\t\\t\\tcolor: new Color(),\\n\\t\\t\\t\\t\\t\\t\\tdistance: 0,\\n\\t\\t\\t\\t\\t\\t\\tconeCos: 0,\\n\\t\\t\\t\\t\\t\\t\\tpenumbraCos: 0,\\n\\t\\t\\t\\t\\t\\t\\tdecay: 0,\\n\\n\\t\\t\\t\\t\\t\\t\\tshadow: false,\\n\\t\\t\\t\\t\\t\\t\\tshadowBias: 0,\\n\\t\\t\\t\\t\\t\\t\\tshadowRadius: 1,\\n\\t\\t\\t\\t\\t\\t\\tshadowMapSize: new Vector2()\\n\\t\\t\\t\\t\\t\\t};\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'PointLight':\\n\\t\\t\\t\\t\\t\\tuniforms = {\\n\\t\\t\\t\\t\\t\\t\\tposition: new Vector3(),\\n\\t\\t\\t\\t\\t\\t\\tcolor: new Color(),\\n\\t\\t\\t\\t\\t\\t\\tdistance: 0,\\n\\t\\t\\t\\t\\t\\t\\tdecay: 0,\\n\\n\\t\\t\\t\\t\\t\\t\\tshadow: false,\\n\\t\\t\\t\\t\\t\\t\\tshadowBias: 0,\\n\\t\\t\\t\\t\\t\\t\\tshadowRadius: 1,\\n\\t\\t\\t\\t\\t\\t\\tshadowMapSize: new Vector2(),\\n\\t\\t\\t\\t\\t\\t\\tshadowCameraNear: 1,\\n\\t\\t\\t\\t\\t\\t\\tshadowCameraFar: 1000\\n\\t\\t\\t\\t\\t\\t};\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'HemisphereLight':\\n\\t\\t\\t\\t\\t\\tuniforms = {\\n\\t\\t\\t\\t\\t\\t\\tdirection: new Vector3(),\\n\\t\\t\\t\\t\\t\\t\\tskyColor: new Color(),\\n\\t\\t\\t\\t\\t\\t\\tgroundColor: new Color()\\n\\t\\t\\t\\t\\t\\t};\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'RectAreaLight':\\n\\t\\t\\t\\t\\t\\tuniforms = {\\n\\t\\t\\t\\t\\t\\t\\tcolor: new Color(),\\n\\t\\t\\t\\t\\t\\t\\tposition: new Vector3(),\\n\\t\\t\\t\\t\\t\\t\\thalfWidth: new Vector3(),\\n\\t\\t\\t\\t\\t\\t\\thalfHeight: new Vector3()\\n\\t\\t\\t\\t\\t\\t\\t// TODO (abelnation): set RectAreaLight shadow uniforms\\n\\t\\t\\t\\t\\t\\t};\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tlights[ light.id ] = uniforms;\\n\\n\\t\\t\\t\\treturn uniforms;\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\tfunction WebGLLights() {\\n\\n\\t\\tvar cache = new UniformsCache();\\n\\n\\t\\tvar state = {\\n\\n\\t\\t\\thash: '',\\n\\n\\t\\t\\tambient: [ 0, 0, 0 ],\\n\\t\\t\\tdirectional: [],\\n\\t\\t\\tdirectionalShadowMap: [],\\n\\t\\t\\tdirectionalShadowMatrix: [],\\n\\t\\t\\tspot: [],\\n\\t\\t\\tspotShadowMap: [],\\n\\t\\t\\tspotShadowMatrix: [],\\n\\t\\t\\trectArea: [],\\n\\t\\t\\tpoint: [],\\n\\t\\t\\tpointShadowMap: [],\\n\\t\\t\\tpointShadowMatrix: [],\\n\\t\\t\\themi: []\\n\\n\\t\\t};\\n\\n\\t\\tvar vector3 = new Vector3();\\n\\t\\tvar matrix4 = new Matrix4();\\n\\t\\tvar matrix42 = new Matrix4();\\n\\n\\t\\tfunction setup( lights, shadows, camera ) {\\n\\n\\t\\t\\tvar r = 0, g = 0, b = 0;\\n\\n\\t\\t\\tvar directionalLength = 0;\\n\\t\\t\\tvar pointLength = 0;\\n\\t\\t\\tvar spotLength = 0;\\n\\t\\t\\tvar rectAreaLength = 0;\\n\\t\\t\\tvar hemiLength = 0;\\n\\n\\t\\t\\tvar viewMatrix = camera.matrixWorldInverse;\\n\\n\\t\\t\\tfor ( var i = 0, l = lights.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar light = lights[ i ];\\n\\n\\t\\t\\t\\tvar color = light.color;\\n\\t\\t\\t\\tvar intensity = light.intensity;\\n\\t\\t\\t\\tvar distance = light.distance;\\n\\n\\t\\t\\t\\tvar shadowMap = ( light.shadow && light.shadow.map ) ? light.shadow.map.texture : null;\\n\\n\\t\\t\\t\\tif ( light.isAmbientLight ) {\\n\\n\\t\\t\\t\\t\\tr += color.r * intensity;\\n\\t\\t\\t\\t\\tg += color.g * intensity;\\n\\t\\t\\t\\t\\tb += color.b * intensity;\\n\\n\\t\\t\\t\\t} else if ( light.isDirectionalLight ) {\\n\\n\\t\\t\\t\\t\\tvar uniforms = cache.get( light );\\n\\n\\t\\t\\t\\t\\tuniforms.color.copy( light.color ).multiplyScalar( light.intensity );\\n\\t\\t\\t\\t\\tuniforms.direction.setFromMatrixPosition( light.matrixWorld );\\n\\t\\t\\t\\t\\tvector3.setFromMatrixPosition( light.target.matrixWorld );\\n\\t\\t\\t\\t\\tuniforms.direction.sub( vector3 );\\n\\t\\t\\t\\t\\tuniforms.direction.transformDirection( viewMatrix );\\n\\n\\t\\t\\t\\t\\tuniforms.shadow = light.castShadow;\\n\\n\\t\\t\\t\\t\\tif ( light.castShadow ) {\\n\\n\\t\\t\\t\\t\\t\\tvar shadow = light.shadow;\\n\\n\\t\\t\\t\\t\\t\\tuniforms.shadowBias = shadow.bias;\\n\\t\\t\\t\\t\\t\\tuniforms.shadowRadius = shadow.radius;\\n\\t\\t\\t\\t\\t\\tuniforms.shadowMapSize = shadow.mapSize;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tstate.directionalShadowMap[ directionalLength ] = shadowMap;\\n\\t\\t\\t\\t\\tstate.directionalShadowMatrix[ directionalLength ] = light.shadow.matrix;\\n\\t\\t\\t\\t\\tstate.directional[ directionalLength ] = uniforms;\\n\\n\\t\\t\\t\\t\\tdirectionalLength ++;\\n\\n\\t\\t\\t\\t} else if ( light.isSpotLight ) {\\n\\n\\t\\t\\t\\t\\tvar uniforms = cache.get( light );\\n\\n\\t\\t\\t\\t\\tuniforms.position.setFromMatrixPosition( light.matrixWorld );\\n\\t\\t\\t\\t\\tuniforms.position.applyMatrix4( viewMatrix );\\n\\n\\t\\t\\t\\t\\tuniforms.color.copy( color ).multiplyScalar( intensity );\\n\\t\\t\\t\\t\\tuniforms.distance = distance;\\n\\n\\t\\t\\t\\t\\tuniforms.direction.setFromMatrixPosition( light.matrixWorld );\\n\\t\\t\\t\\t\\tvector3.setFromMatrixPosition( light.target.matrixWorld );\\n\\t\\t\\t\\t\\tuniforms.direction.sub( vector3 );\\n\\t\\t\\t\\t\\tuniforms.direction.transformDirection( viewMatrix );\\n\\n\\t\\t\\t\\t\\tuniforms.coneCos = Math.cos( light.angle );\\n\\t\\t\\t\\t\\tuniforms.penumbraCos = Math.cos( light.angle * ( 1 - light.penumbra ) );\\n\\t\\t\\t\\t\\tuniforms.decay = ( light.distance === 0 ) ? 0.0 : light.decay;\\n\\n\\t\\t\\t\\t\\tuniforms.shadow = light.castShadow;\\n\\n\\t\\t\\t\\t\\tif ( light.castShadow ) {\\n\\n\\t\\t\\t\\t\\t\\tvar shadow = light.shadow;\\n\\n\\t\\t\\t\\t\\t\\tuniforms.shadowBias = shadow.bias;\\n\\t\\t\\t\\t\\t\\tuniforms.shadowRadius = shadow.radius;\\n\\t\\t\\t\\t\\t\\tuniforms.shadowMapSize = shadow.mapSize;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tstate.spotShadowMap[ spotLength ] = shadowMap;\\n\\t\\t\\t\\t\\tstate.spotShadowMatrix[ spotLength ] = light.shadow.matrix;\\n\\t\\t\\t\\t\\tstate.spot[ spotLength ] = uniforms;\\n\\n\\t\\t\\t\\t\\tspotLength ++;\\n\\n\\t\\t\\t\\t} else if ( light.isRectAreaLight ) {\\n\\n\\t\\t\\t\\t\\tvar uniforms = cache.get( light );\\n\\n\\t\\t\\t\\t\\t// (a) intensity controls irradiance of entire light\\n\\t\\t\\t\\t\\tuniforms.color\\n\\t\\t\\t\\t\\t\\t.copy( color )\\n\\t\\t\\t\\t\\t\\t.multiplyScalar( intensity / ( light.width * light.height ) );\\n\\n\\t\\t\\t\\t\\t// (b) intensity controls the radiance per light area\\n\\t\\t\\t\\t\\t// uniforms.color.copy( color ).multiplyScalar( intensity );\\n\\n\\t\\t\\t\\t\\tuniforms.position.setFromMatrixPosition( light.matrixWorld );\\n\\t\\t\\t\\t\\tuniforms.position.applyMatrix4( viewMatrix );\\n\\n\\t\\t\\t\\t\\t// extract local rotation of light to derive width/height half vectors\\n\\t\\t\\t\\t\\tmatrix42.identity();\\n\\t\\t\\t\\t\\tmatrix4.copy( light.matrixWorld );\\n\\t\\t\\t\\t\\tmatrix4.premultiply( viewMatrix );\\n\\t\\t\\t\\t\\tmatrix42.extractRotation( matrix4 );\\n\\n\\t\\t\\t\\t\\tuniforms.halfWidth.set( light.width * 0.5, 0.0, 0.0 );\\n\\t\\t\\t\\t\\tuniforms.halfHeight.set( 0.0, light.height * 0.5, 0.0 );\\n\\n\\t\\t\\t\\t\\tuniforms.halfWidth.applyMatrix4( matrix42 );\\n\\t\\t\\t\\t\\tuniforms.halfHeight.applyMatrix4( matrix42 );\\n\\n\\t\\t\\t\\t\\t// TODO (abelnation): RectAreaLight distance?\\n\\t\\t\\t\\t\\t// uniforms.distance = distance;\\n\\n\\t\\t\\t\\t\\tstate.rectArea[ rectAreaLength ] = uniforms;\\n\\n\\t\\t\\t\\t\\trectAreaLength ++;\\n\\n\\t\\t\\t\\t} else if ( light.isPointLight ) {\\n\\n\\t\\t\\t\\t\\tvar uniforms = cache.get( light );\\n\\n\\t\\t\\t\\t\\tuniforms.position.setFromMatrixPosition( light.matrixWorld );\\n\\t\\t\\t\\t\\tuniforms.position.applyMatrix4( viewMatrix );\\n\\n\\t\\t\\t\\t\\tuniforms.color.copy( light.color ).multiplyScalar( light.intensity );\\n\\t\\t\\t\\t\\tuniforms.distance = light.distance;\\n\\t\\t\\t\\t\\tuniforms.decay = ( light.distance === 0 ) ? 0.0 : light.decay;\\n\\n\\t\\t\\t\\t\\tuniforms.shadow = light.castShadow;\\n\\n\\t\\t\\t\\t\\tif ( light.castShadow ) {\\n\\n\\t\\t\\t\\t\\t\\tvar shadow = light.shadow;\\n\\n\\t\\t\\t\\t\\t\\tuniforms.shadowBias = shadow.bias;\\n\\t\\t\\t\\t\\t\\tuniforms.shadowRadius = shadow.radius;\\n\\t\\t\\t\\t\\t\\tuniforms.shadowMapSize = shadow.mapSize;\\n\\t\\t\\t\\t\\t\\tuniforms.shadowCameraNear = shadow.camera.near;\\n\\t\\t\\t\\t\\t\\tuniforms.shadowCameraFar = shadow.camera.far;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tstate.pointShadowMap[ pointLength ] = shadowMap;\\n\\t\\t\\t\\t\\tstate.pointShadowMatrix[ pointLength ] = light.shadow.matrix;\\n\\t\\t\\t\\t\\tstate.point[ pointLength ] = uniforms;\\n\\n\\t\\t\\t\\t\\tpointLength ++;\\n\\n\\t\\t\\t\\t} else if ( light.isHemisphereLight ) {\\n\\n\\t\\t\\t\\t\\tvar uniforms = cache.get( light );\\n\\n\\t\\t\\t\\t\\tuniforms.direction.setFromMatrixPosition( light.matrixWorld );\\n\\t\\t\\t\\t\\tuniforms.direction.transformDirection( viewMatrix );\\n\\t\\t\\t\\t\\tuniforms.direction.normalize();\\n\\n\\t\\t\\t\\t\\tuniforms.skyColor.copy( light.color ).multiplyScalar( intensity );\\n\\t\\t\\t\\t\\tuniforms.groundColor.copy( light.groundColor ).multiplyScalar( intensity );\\n\\n\\t\\t\\t\\t\\tstate.hemi[ hemiLength ] = uniforms;\\n\\n\\t\\t\\t\\t\\themiLength ++;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tstate.ambient[ 0 ] = r;\\n\\t\\t\\tstate.ambient[ 1 ] = g;\\n\\t\\t\\tstate.ambient[ 2 ] = b;\\n\\n\\t\\t\\tstate.directional.length = directionalLength;\\n\\t\\t\\tstate.spot.length = spotLength;\\n\\t\\t\\tstate.rectArea.length = rectAreaLength;\\n\\t\\t\\tstate.point.length = pointLength;\\n\\t\\t\\tstate.hemi.length = hemiLength;\\n\\n\\t\\t\\t// TODO (sam-g-steel) why aren't we using join\\n\\t\\t\\tstate.hash = directionalLength + ',' + pointLength + ',' + spotLength + ',' + rectAreaLength + ',' + hemiLength + ',' + shadows.length;\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\t\\t\\tsetup: setup,\\n\\t\\t\\tstate: state\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLObjects( geometries, infoRender ) {\\n\\n\\t\\tvar updateList = {};\\n\\n\\t\\tfunction update( object ) {\\n\\n\\t\\t\\tvar frame = infoRender.frame;\\n\\n\\t\\t\\tvar geometry = object.geometry;\\n\\t\\t\\tvar buffergeometry = geometries.get( object, geometry );\\n\\n\\t\\t\\t// Update once per frame\\n\\n\\t\\t\\tif ( updateList[ buffergeometry.id ] !== frame ) {\\n\\n\\t\\t\\t\\tif ( geometry.isGeometry ) {\\n\\n\\t\\t\\t\\t\\tbuffergeometry.updateFromObject( object );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometries.update( buffergeometry );\\n\\n\\t\\t\\t\\tupdateList[ buffergeometry.id ] = frame;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn buffergeometry;\\n\\n\\t\\t}\\n\\n\\t\\tfunction clear() {\\n\\n\\t\\t\\tupdateList = {};\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tupdate: update,\\n\\t\\t\\tclear: clear\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction addLineNumbers( string ) {\\n\\n\\t\\tvar lines = string.split( '\\\\n' );\\n\\n\\t\\tfor ( var i = 0; i < lines.length; i ++ ) {\\n\\n\\t\\t\\tlines[ i ] = ( i + 1 ) + ': ' + lines[ i ];\\n\\n\\t\\t}\\n\\n\\t\\treturn lines.join( '\\\\n' );\\n\\n\\t}\\n\\n\\tfunction WebGLShader( gl, type, string ) {\\n\\n\\t\\tvar shader = gl.createShader( type );\\n\\n\\t\\tgl.shaderSource( shader, string );\\n\\t\\tgl.compileShader( shader );\\n\\n\\t\\tif ( gl.getShaderParameter( shader, gl.COMPILE_STATUS ) === false ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.WebGLShader: Shader couldn\\\\'t compile.' );\\n\\n\\t\\t}\\n\\n\\t\\tif ( gl.getShaderInfoLog( shader ) !== '' ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLShader: gl.getShaderInfoLog()', type === gl.VERTEX_SHADER ? 'vertex' : 'fragment', gl.getShaderInfoLog( shader ), addLineNumbers( string ) );\\n\\n\\t\\t}\\n\\n\\t\\t// --enable-privileged-webgl-extension\\n\\t\\t// console.log( type, gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( shader ) );\\n\\n\\t\\treturn shader;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tvar programIdCount = 0;\\n\\n\\tfunction getEncodingComponents( encoding ) {\\n\\n\\t\\tswitch ( encoding ) {\\n\\n\\t\\t\\tcase LinearEncoding:\\n\\t\\t\\t\\treturn [ 'Linear', '( value )' ];\\n\\t\\t\\tcase sRGBEncoding:\\n\\t\\t\\t\\treturn [ 'sRGB', '( value )' ];\\n\\t\\t\\tcase RGBEEncoding:\\n\\t\\t\\t\\treturn [ 'RGBE', '( value )' ];\\n\\t\\t\\tcase RGBM7Encoding:\\n\\t\\t\\t\\treturn [ 'RGBM', '( value, 7.0 )' ];\\n\\t\\t\\tcase RGBM16Encoding:\\n\\t\\t\\t\\treturn [ 'RGBM', '( value, 16.0 )' ];\\n\\t\\t\\tcase RGBDEncoding:\\n\\t\\t\\t\\treturn [ 'RGBD', '( value, 256.0 )' ];\\n\\t\\t\\tcase GammaEncoding:\\n\\t\\t\\t\\treturn [ 'Gamma', '( value, float( GAMMA_FACTOR ) )' ];\\n\\t\\t\\tdefault:\\n\\t\\t\\t\\tthrow new Error( 'unsupported encoding: ' + encoding );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tfunction getTexelDecodingFunction( functionName, encoding ) {\\n\\n\\t\\tvar components = getEncodingComponents( encoding );\\n\\t\\treturn 'vec4 ' + functionName + '( vec4 value ) { return ' + components[ 0 ] + 'ToLinear' + components[ 1 ] + '; }';\\n\\n\\t}\\n\\n\\tfunction getTexelEncodingFunction( functionName, encoding ) {\\n\\n\\t\\tvar components = getEncodingComponents( encoding );\\n\\t\\treturn 'vec4 ' + functionName + '( vec4 value ) { return LinearTo' + components[ 0 ] + components[ 1 ] + '; }';\\n\\n\\t}\\n\\n\\tfunction getToneMappingFunction( functionName, toneMapping ) {\\n\\n\\t\\tvar toneMappingName;\\n\\n\\t\\tswitch ( toneMapping ) {\\n\\n\\t\\t\\tcase LinearToneMapping:\\n\\t\\t\\t\\ttoneMappingName = 'Linear';\\n\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\tcase ReinhardToneMapping:\\n\\t\\t\\t\\ttoneMappingName = 'Reinhard';\\n\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\tcase Uncharted2ToneMapping:\\n\\t\\t\\t\\ttoneMappingName = 'Uncharted2';\\n\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\tcase CineonToneMapping:\\n\\t\\t\\t\\ttoneMappingName = 'OptimizedCineon';\\n\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\tdefault:\\n\\t\\t\\t\\tthrow new Error( 'unsupported toneMapping: ' + toneMapping );\\n\\n\\t\\t}\\n\\n\\t\\treturn 'vec3 ' + functionName + '( vec3 color ) { return ' + toneMappingName + 'ToneMapping( color ); }';\\n\\n\\t}\\n\\n\\tfunction generateExtensions( extensions, parameters, rendererExtensions ) {\\n\\n\\t\\textensions = extensions || {};\\n\\n\\t\\tvar chunks = [\\n\\t\\t\\t( extensions.derivatives || parameters.envMapCubeUV || parameters.bumpMap || parameters.normalMap || parameters.flatShading ) ? '#extension GL_OES_standard_derivatives : enable' : '',\\n\\t\\t\\t( extensions.fragDepth || parameters.logarithmicDepthBuffer ) && rendererExtensions.get( 'EXT_frag_depth' ) ? '#extension GL_EXT_frag_depth : enable' : '',\\n\\t\\t\\t( extensions.drawBuffers ) && rendererExtensions.get( 'WEBGL_draw_buffers' ) ? '#extension GL_EXT_draw_buffers : require' : '',\\n\\t\\t\\t( extensions.shaderTextureLOD || parameters.envMap ) && rendererExtensions.get( 'EXT_shader_texture_lod' ) ? '#extension GL_EXT_shader_texture_lod : enable' : ''\\n\\t\\t];\\n\\n\\t\\treturn chunks.filter( filterEmptyLine ).join( '\\\\n' );\\n\\n\\t}\\n\\n\\tfunction generateDefines( defines ) {\\n\\n\\t\\tvar chunks = [];\\n\\n\\t\\tfor ( var name in defines ) {\\n\\n\\t\\t\\tvar value = defines[ name ];\\n\\n\\t\\t\\tif ( value === false ) continue;\\n\\n\\t\\t\\tchunks.push( '#define ' + name + ' ' + value );\\n\\n\\t\\t}\\n\\n\\t\\treturn chunks.join( '\\\\n' );\\n\\n\\t}\\n\\n\\tfunction fetchAttributeLocations( gl, program ) {\\n\\n\\t\\tvar attributes = {};\\n\\n\\t\\tvar n = gl.getProgramParameter( program, gl.ACTIVE_ATTRIBUTES );\\n\\n\\t\\tfor ( var i = 0; i < n; i ++ ) {\\n\\n\\t\\t\\tvar info = gl.getActiveAttrib( program, i );\\n\\t\\t\\tvar name = info.name;\\n\\n\\t\\t\\t// console.log( 'THREE.WebGLProgram: ACTIVE VERTEX ATTRIBUTE:', name, i );\\n\\n\\t\\t\\tattributes[ name ] = gl.getAttribLocation( program, name );\\n\\n\\t\\t}\\n\\n\\t\\treturn attributes;\\n\\n\\t}\\n\\n\\tfunction filterEmptyLine( string ) {\\n\\n\\t\\treturn string !== '';\\n\\n\\t}\\n\\n\\tfunction replaceLightNums( string, parameters ) {\\n\\n\\t\\treturn string\\n\\t\\t\\t.replace( /NUM_DIR_LIGHTS/g, parameters.numDirLights )\\n\\t\\t\\t.replace( /NUM_SPOT_LIGHTS/g, parameters.numSpotLights )\\n\\t\\t\\t.replace( /NUM_RECT_AREA_LIGHTS/g, parameters.numRectAreaLights )\\n\\t\\t\\t.replace( /NUM_POINT_LIGHTS/g, parameters.numPointLights )\\n\\t\\t\\t.replace( /NUM_HEMI_LIGHTS/g, parameters.numHemiLights );\\n\\n\\t}\\n\\n\\tfunction parseIncludes( string ) {\\n\\n\\t\\tvar pattern = /^[ \\\\t]*#include +<([\\\\w\\\\d.]+)>/gm;\\n\\n\\t\\tfunction replace( match, include ) {\\n\\n\\t\\t\\tvar replace = ShaderChunk[ include ];\\n\\n\\t\\t\\tif ( replace === undefined ) {\\n\\n\\t\\t\\t\\tthrow new Error( 'Can not resolve #include <' + include + '>' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn parseIncludes( replace );\\n\\n\\t\\t}\\n\\n\\t\\treturn string.replace( pattern, replace );\\n\\n\\t}\\n\\n\\tfunction unrollLoops( string ) {\\n\\n\\t\\tvar pattern = /for \\\\( int i \\\\= (\\\\d+)\\\\; i < (\\\\d+)\\\\; i \\\\+\\\\+ \\\\) \\\\{([\\\\s\\\\S]+?)(?=\\\\})\\\\}/g;\\n\\n\\t\\tfunction replace( match, start, end, snippet ) {\\n\\n\\t\\t\\tvar unroll = '';\\n\\n\\t\\t\\tfor ( var i = parseInt( start ); i < parseInt( end ); i ++ ) {\\n\\n\\t\\t\\t\\tunroll += snippet.replace( /\\\\[ i \\\\]/g, '[ ' + i + ' ]' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn unroll;\\n\\n\\t\\t}\\n\\n\\t\\treturn string.replace( pattern, replace );\\n\\n\\t}\\n\\n\\tfunction WebGLProgram( renderer, extensions, code, material, shader, parameters ) {\\n\\n\\t\\tvar gl = renderer.context;\\n\\n\\t\\tvar defines = material.defines;\\n\\n\\t\\tvar vertexShader = shader.vertexShader;\\n\\t\\tvar fragmentShader = shader.fragmentShader;\\n\\n\\t\\tvar shadowMapTypeDefine = 'SHADOWMAP_TYPE_BASIC';\\n\\n\\t\\tif ( parameters.shadowMapType === PCFShadowMap ) {\\n\\n\\t\\t\\tshadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF';\\n\\n\\t\\t} else if ( parameters.shadowMapType === PCFSoftShadowMap ) {\\n\\n\\t\\t\\tshadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF_SOFT';\\n\\n\\t\\t}\\n\\n\\t\\tvar envMapTypeDefine = 'ENVMAP_TYPE_CUBE';\\n\\t\\tvar envMapModeDefine = 'ENVMAP_MODE_REFLECTION';\\n\\t\\tvar envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY';\\n\\n\\t\\tif ( parameters.envMap ) {\\n\\n\\t\\t\\tswitch ( material.envMap.mapping ) {\\n\\n\\t\\t\\t\\tcase CubeReflectionMapping:\\n\\t\\t\\t\\tcase CubeRefractionMapping:\\n\\t\\t\\t\\t\\tenvMapTypeDefine = 'ENVMAP_TYPE_CUBE';\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\tcase CubeUVReflectionMapping:\\n\\t\\t\\t\\tcase CubeUVRefractionMapping:\\n\\t\\t\\t\\t\\tenvMapTypeDefine = 'ENVMAP_TYPE_CUBE_UV';\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\tcase EquirectangularReflectionMapping:\\n\\t\\t\\t\\tcase EquirectangularRefractionMapping:\\n\\t\\t\\t\\t\\tenvMapTypeDefine = 'ENVMAP_TYPE_EQUIREC';\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\tcase SphericalReflectionMapping:\\n\\t\\t\\t\\t\\tenvMapTypeDefine = 'ENVMAP_TYPE_SPHERE';\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tswitch ( material.envMap.mapping ) {\\n\\n\\t\\t\\t\\tcase CubeRefractionMapping:\\n\\t\\t\\t\\tcase EquirectangularRefractionMapping:\\n\\t\\t\\t\\t\\tenvMapModeDefine = 'ENVMAP_MODE_REFRACTION';\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tswitch ( material.combine ) {\\n\\n\\t\\t\\t\\tcase MultiplyOperation:\\n\\t\\t\\t\\t\\tenvMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY';\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\tcase MixOperation:\\n\\t\\t\\t\\t\\tenvMapBlendingDefine = 'ENVMAP_BLENDING_MIX';\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\tcase AddOperation:\\n\\t\\t\\t\\t\\tenvMapBlendingDefine = 'ENVMAP_BLENDING_ADD';\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tvar gammaFactorDefine = ( renderer.gammaFactor > 0 ) ? renderer.gammaFactor : 1.0;\\n\\n\\t\\t// console.log( 'building new program ' );\\n\\n\\t\\t//\\n\\n\\t\\tvar customExtensions = generateExtensions( material.extensions, parameters, extensions );\\n\\n\\t\\tvar customDefines = generateDefines( defines );\\n\\n\\t\\t//\\n\\n\\t\\tvar program = gl.createProgram();\\n\\n\\t\\tvar prefixVertex, prefixFragment;\\n\\n\\t\\tif ( material.isRawShaderMaterial ) {\\n\\n\\t\\t\\tprefixVertex = [\\n\\n\\t\\t\\t\\tcustomDefines\\n\\n\\t\\t\\t].filter( filterEmptyLine ).join( '\\\\n' );\\n\\n\\t\\t\\tif ( prefixVertex.length > 0 ) {\\n\\n\\t\\t\\t\\tprefixVertex += '\\\\n';\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tprefixFragment = [\\n\\n\\t\\t\\t\\tcustomExtensions,\\n\\t\\t\\t\\tcustomDefines\\n\\n\\t\\t\\t].filter( filterEmptyLine ).join( '\\\\n' );\\n\\n\\t\\t\\tif ( prefixFragment.length > 0 ) {\\n\\n\\t\\t\\t\\tprefixFragment += '\\\\n';\\n\\n\\t\\t\\t}\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tprefixVertex = [\\n\\n\\t\\t\\t\\t'precision ' + parameters.precision + ' float;',\\n\\t\\t\\t\\t'precision ' + parameters.precision + ' int;',\\n\\n\\t\\t\\t\\t'#define SHADER_NAME ' + shader.name,\\n\\n\\t\\t\\t\\tcustomDefines,\\n\\n\\t\\t\\t\\tparameters.supportsVertexTextures ? '#define VERTEX_TEXTURES' : '',\\n\\n\\t\\t\\t\\t'#define GAMMA_FACTOR ' + gammaFactorDefine,\\n\\n\\t\\t\\t\\t'#define MAX_BONES ' + parameters.maxBones,\\n\\t\\t\\t\\t( parameters.useFog && parameters.fog ) ? '#define USE_FOG' : '',\\n\\t\\t\\t\\t( parameters.useFog && parameters.fogExp ) ? '#define FOG_EXP2' : '',\\n\\n\\t\\t\\t\\tparameters.map ? '#define USE_MAP' : '',\\n\\t\\t\\t\\tparameters.envMap ? '#define USE_ENVMAP' : '',\\n\\t\\t\\t\\tparameters.envMap ? '#define ' + envMapModeDefine : '',\\n\\t\\t\\t\\tparameters.lightMap ? '#define USE_LIGHTMAP' : '',\\n\\t\\t\\t\\tparameters.aoMap ? '#define USE_AOMAP' : '',\\n\\t\\t\\t\\tparameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',\\n\\t\\t\\t\\tparameters.bumpMap ? '#define USE_BUMPMAP' : '',\\n\\t\\t\\t\\tparameters.normalMap ? '#define USE_NORMALMAP' : '',\\n\\t\\t\\t\\tparameters.displacementMap && parameters.supportsVertexTextures ? '#define USE_DISPLACEMENTMAP' : '',\\n\\t\\t\\t\\tparameters.specularMap ? '#define USE_SPECULARMAP' : '',\\n\\t\\t\\t\\tparameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',\\n\\t\\t\\t\\tparameters.metalnessMap ? '#define USE_METALNESSMAP' : '',\\n\\t\\t\\t\\tparameters.alphaMap ? '#define USE_ALPHAMAP' : '',\\n\\t\\t\\t\\tparameters.vertexColors ? '#define USE_COLOR' : '',\\n\\n\\t\\t\\t\\tparameters.flatShading ? '#define FLAT_SHADED' : '',\\n\\n\\t\\t\\t\\tparameters.skinning ? '#define USE_SKINNING' : '',\\n\\t\\t\\t\\tparameters.useVertexTexture ? '#define BONE_TEXTURE' : '',\\n\\n\\t\\t\\t\\tparameters.morphTargets ? '#define USE_MORPHTARGETS' : '',\\n\\t\\t\\t\\tparameters.morphNormals && parameters.flatShading === false ? '#define USE_MORPHNORMALS' : '',\\n\\t\\t\\t\\tparameters.doubleSided ? '#define DOUBLE_SIDED' : '',\\n\\t\\t\\t\\tparameters.flipSided ? '#define FLIP_SIDED' : '',\\n\\n\\t\\t\\t\\t'#define NUM_CLIPPING_PLANES ' + parameters.numClippingPlanes,\\n\\n\\t\\t\\t\\tparameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',\\n\\t\\t\\t\\tparameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',\\n\\n\\t\\t\\t\\tparameters.sizeAttenuation ? '#define USE_SIZEATTENUATION' : '',\\n\\n\\t\\t\\t\\tparameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',\\n\\t\\t\\t\\tparameters.logarithmicDepthBuffer && extensions.get( 'EXT_frag_depth' ) ? '#define USE_LOGDEPTHBUF_EXT' : '',\\n\\n\\t\\t\\t\\t'uniform mat4 modelMatrix;',\\n\\t\\t\\t\\t'uniform mat4 modelViewMatrix;',\\n\\t\\t\\t\\t'uniform mat4 projectionMatrix;',\\n\\t\\t\\t\\t'uniform mat4 viewMatrix;',\\n\\t\\t\\t\\t'uniform mat3 normalMatrix;',\\n\\t\\t\\t\\t'uniform vec3 cameraPosition;',\\n\\n\\t\\t\\t\\t'attribute vec3 position;',\\n\\t\\t\\t\\t'attribute vec3 normal;',\\n\\t\\t\\t\\t'attribute vec2 uv;',\\n\\n\\t\\t\\t\\t'#ifdef USE_COLOR',\\n\\n\\t\\t\\t\\t'\\tattribute vec3 color;',\\n\\n\\t\\t\\t\\t'#endif',\\n\\n\\t\\t\\t\\t'#ifdef USE_MORPHTARGETS',\\n\\n\\t\\t\\t\\t'\\tattribute vec3 morphTarget0;',\\n\\t\\t\\t\\t'\\tattribute vec3 morphTarget1;',\\n\\t\\t\\t\\t'\\tattribute vec3 morphTarget2;',\\n\\t\\t\\t\\t'\\tattribute vec3 morphTarget3;',\\n\\n\\t\\t\\t\\t'\\t#ifdef USE_MORPHNORMALS',\\n\\n\\t\\t\\t\\t'\\t\\tattribute vec3 morphNormal0;',\\n\\t\\t\\t\\t'\\t\\tattribute vec3 morphNormal1;',\\n\\t\\t\\t\\t'\\t\\tattribute vec3 morphNormal2;',\\n\\t\\t\\t\\t'\\t\\tattribute vec3 morphNormal3;',\\n\\n\\t\\t\\t\\t'\\t#else',\\n\\n\\t\\t\\t\\t'\\t\\tattribute vec3 morphTarget4;',\\n\\t\\t\\t\\t'\\t\\tattribute vec3 morphTarget5;',\\n\\t\\t\\t\\t'\\t\\tattribute vec3 morphTarget6;',\\n\\t\\t\\t\\t'\\t\\tattribute vec3 morphTarget7;',\\n\\n\\t\\t\\t\\t'\\t#endif',\\n\\n\\t\\t\\t\\t'#endif',\\n\\n\\t\\t\\t\\t'#ifdef USE_SKINNING',\\n\\n\\t\\t\\t\\t'\\tattribute vec4 skinIndex;',\\n\\t\\t\\t\\t'\\tattribute vec4 skinWeight;',\\n\\n\\t\\t\\t\\t'#endif',\\n\\n\\t\\t\\t\\t'\\\\n'\\n\\n\\t\\t\\t].filter( filterEmptyLine ).join( '\\\\n' );\\n\\n\\t\\t\\tprefixFragment = [\\n\\n\\t\\t\\t\\tcustomExtensions,\\n\\n\\t\\t\\t\\t'precision ' + parameters.precision + ' float;',\\n\\t\\t\\t\\t'precision ' + parameters.precision + ' int;',\\n\\n\\t\\t\\t\\t'#define SHADER_NAME ' + shader.name,\\n\\n\\t\\t\\t\\tcustomDefines,\\n\\n\\t\\t\\t\\tparameters.alphaTest ? '#define ALPHATEST ' + parameters.alphaTest : '',\\n\\n\\t\\t\\t\\t'#define GAMMA_FACTOR ' + gammaFactorDefine,\\n\\n\\t\\t\\t\\t( parameters.useFog && parameters.fog ) ? '#define USE_FOG' : '',\\n\\t\\t\\t\\t( parameters.useFog && parameters.fogExp ) ? '#define FOG_EXP2' : '',\\n\\n\\t\\t\\t\\tparameters.map ? '#define USE_MAP' : '',\\n\\t\\t\\t\\tparameters.envMap ? '#define USE_ENVMAP' : '',\\n\\t\\t\\t\\tparameters.envMap ? '#define ' + envMapTypeDefine : '',\\n\\t\\t\\t\\tparameters.envMap ? '#define ' + envMapModeDefine : '',\\n\\t\\t\\t\\tparameters.envMap ? '#define ' + envMapBlendingDefine : '',\\n\\t\\t\\t\\tparameters.lightMap ? '#define USE_LIGHTMAP' : '',\\n\\t\\t\\t\\tparameters.aoMap ? '#define USE_AOMAP' : '',\\n\\t\\t\\t\\tparameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',\\n\\t\\t\\t\\tparameters.bumpMap ? '#define USE_BUMPMAP' : '',\\n\\t\\t\\t\\tparameters.normalMap ? '#define USE_NORMALMAP' : '',\\n\\t\\t\\t\\tparameters.specularMap ? '#define USE_SPECULARMAP' : '',\\n\\t\\t\\t\\tparameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',\\n\\t\\t\\t\\tparameters.metalnessMap ? '#define USE_METALNESSMAP' : '',\\n\\t\\t\\t\\tparameters.alphaMap ? '#define USE_ALPHAMAP' : '',\\n\\t\\t\\t\\tparameters.vertexColors ? '#define USE_COLOR' : '',\\n\\n\\t\\t\\t\\tparameters.gradientMap ? '#define USE_GRADIENTMAP' : '',\\n\\n\\t\\t\\t\\tparameters.flatShading ? '#define FLAT_SHADED' : '',\\n\\n\\t\\t\\t\\tparameters.doubleSided ? '#define DOUBLE_SIDED' : '',\\n\\t\\t\\t\\tparameters.flipSided ? '#define FLIP_SIDED' : '',\\n\\n\\t\\t\\t\\t'#define NUM_CLIPPING_PLANES ' + parameters.numClippingPlanes,\\n\\t\\t\\t\\t'#define UNION_CLIPPING_PLANES ' + ( parameters.numClippingPlanes - parameters.numClipIntersection ),\\n\\n\\t\\t\\t\\tparameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',\\n\\t\\t\\t\\tparameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',\\n\\n\\t\\t\\t\\tparameters.premultipliedAlpha ? '#define PREMULTIPLIED_ALPHA' : '',\\n\\n\\t\\t\\t\\tparameters.physicallyCorrectLights ? '#define PHYSICALLY_CORRECT_LIGHTS' : '',\\n\\n\\t\\t\\t\\tparameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',\\n\\t\\t\\t\\tparameters.logarithmicDepthBuffer && extensions.get( 'EXT_frag_depth' ) ? '#define USE_LOGDEPTHBUF_EXT' : '',\\n\\n\\t\\t\\t\\tparameters.envMap && extensions.get( 'EXT_shader_texture_lod' ) ? '#define TEXTURE_LOD_EXT' : '',\\n\\n\\t\\t\\t\\t'uniform mat4 viewMatrix;',\\n\\t\\t\\t\\t'uniform vec3 cameraPosition;',\\n\\n\\t\\t\\t\\t( parameters.toneMapping !== NoToneMapping ) ? '#define TONE_MAPPING' : '',\\n\\t\\t\\t\\t( parameters.toneMapping !== NoToneMapping ) ? ShaderChunk[ 'tonemapping_pars_fragment' ] : '', // this code is required here because it is used by the toneMapping() function defined below\\n\\t\\t\\t\\t( parameters.toneMapping !== NoToneMapping ) ? getToneMappingFunction( 'toneMapping', parameters.toneMapping ) : '',\\n\\n\\t\\t\\t\\tparameters.dithering ? '#define DITHERING' : '',\\n\\n\\t\\t\\t\\t( parameters.outputEncoding || parameters.mapEncoding || parameters.envMapEncoding || parameters.emissiveMapEncoding ) ? ShaderChunk[ 'encodings_pars_fragment' ] : '', // this code is required here because it is used by the various encoding/decoding function defined below\\n\\t\\t\\t\\tparameters.mapEncoding ? getTexelDecodingFunction( 'mapTexelToLinear', parameters.mapEncoding ) : '',\\n\\t\\t\\t\\tparameters.envMapEncoding ? getTexelDecodingFunction( 'envMapTexelToLinear', parameters.envMapEncoding ) : '',\\n\\t\\t\\t\\tparameters.emissiveMapEncoding ? getTexelDecodingFunction( 'emissiveMapTexelToLinear', parameters.emissiveMapEncoding ) : '',\\n\\t\\t\\t\\tparameters.outputEncoding ? getTexelEncodingFunction( 'linearToOutputTexel', parameters.outputEncoding ) : '',\\n\\n\\t\\t\\t\\tparameters.depthPacking ? '#define DEPTH_PACKING ' + material.depthPacking : '',\\n\\n\\t\\t\\t\\t'\\\\n'\\n\\n\\t\\t\\t].filter( filterEmptyLine ).join( '\\\\n' );\\n\\n\\t\\t}\\n\\n\\t\\tvertexShader = parseIncludes( vertexShader );\\n\\t\\tvertexShader = replaceLightNums( vertexShader, parameters );\\n\\n\\t\\tfragmentShader = parseIncludes( fragmentShader );\\n\\t\\tfragmentShader = replaceLightNums( fragmentShader, parameters );\\n\\n\\t\\tif ( ! material.isShaderMaterial ) {\\n\\n\\t\\t\\tvertexShader = unrollLoops( vertexShader );\\n\\t\\t\\tfragmentShader = unrollLoops( fragmentShader );\\n\\n\\t\\t}\\n\\n\\t\\tvar vertexGlsl = prefixVertex + vertexShader;\\n\\t\\tvar fragmentGlsl = prefixFragment + fragmentShader;\\n\\n\\t\\t// console.log( '*VERTEX*', vertexGlsl );\\n\\t\\t// console.log( '*FRAGMENT*', fragmentGlsl );\\n\\n\\t\\tvar glVertexShader = WebGLShader( gl, gl.VERTEX_SHADER, vertexGlsl );\\n\\t\\tvar glFragmentShader = WebGLShader( gl, gl.FRAGMENT_SHADER, fragmentGlsl );\\n\\n\\t\\tgl.attachShader( program, glVertexShader );\\n\\t\\tgl.attachShader( program, glFragmentShader );\\n\\n\\t\\t// Force a particular attribute to index 0.\\n\\n\\t\\tif ( material.index0AttributeName !== undefined ) {\\n\\n\\t\\t\\tgl.bindAttribLocation( program, 0, material.index0AttributeName );\\n\\n\\t\\t} else if ( parameters.morphTargets === true ) {\\n\\n\\t\\t\\t// programs with morphTargets displace position out of attribute 0\\n\\t\\t\\tgl.bindAttribLocation( program, 0, 'position' );\\n\\n\\t\\t}\\n\\n\\t\\tgl.linkProgram( program );\\n\\n\\t\\tvar programLog = gl.getProgramInfoLog( program );\\n\\t\\tvar vertexLog = gl.getShaderInfoLog( glVertexShader );\\n\\t\\tvar fragmentLog = gl.getShaderInfoLog( glFragmentShader );\\n\\n\\t\\tvar runnable = true;\\n\\t\\tvar haveDiagnostics = true;\\n\\n\\t\\t// console.log( '**VERTEX**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( glVertexShader ) );\\n\\t\\t// console.log( '**FRAGMENT**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( glFragmentShader ) );\\n\\n\\t\\tif ( gl.getProgramParameter( program, gl.LINK_STATUS ) === false ) {\\n\\n\\t\\t\\trunnable = false;\\n\\n\\t\\t\\tconsole.error( 'THREE.WebGLProgram: shader error: ', gl.getError(), 'gl.VALIDATE_STATUS', gl.getProgramParameter( program, gl.VALIDATE_STATUS ), 'gl.getProgramInfoLog', programLog, vertexLog, fragmentLog );\\n\\n\\t\\t} else if ( programLog !== '' ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLProgram: gl.getProgramInfoLog()', programLog );\\n\\n\\t\\t} else if ( vertexLog === '' || fragmentLog === '' ) {\\n\\n\\t\\t\\thaveDiagnostics = false;\\n\\n\\t\\t}\\n\\n\\t\\tif ( haveDiagnostics ) {\\n\\n\\t\\t\\tthis.diagnostics = {\\n\\n\\t\\t\\t\\trunnable: runnable,\\n\\t\\t\\t\\tmaterial: material,\\n\\n\\t\\t\\t\\tprogramLog: programLog,\\n\\n\\t\\t\\t\\tvertexShader: {\\n\\n\\t\\t\\t\\t\\tlog: vertexLog,\\n\\t\\t\\t\\t\\tprefix: prefixVertex\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfragmentShader: {\\n\\n\\t\\t\\t\\t\\tlog: fragmentLog,\\n\\t\\t\\t\\t\\tprefix: prefixFragment\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}\\n\\n\\t\\t// clean up\\n\\n\\t\\tgl.deleteShader( glVertexShader );\\n\\t\\tgl.deleteShader( glFragmentShader );\\n\\n\\t\\t// set up caching for uniform locations\\n\\n\\t\\tvar cachedUniforms;\\n\\n\\t\\tthis.getUniforms = function () {\\n\\n\\t\\t\\tif ( cachedUniforms === undefined ) {\\n\\n\\t\\t\\t\\tcachedUniforms = new WebGLUniforms( gl, program, renderer );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn cachedUniforms;\\n\\n\\t\\t};\\n\\n\\t\\t// set up caching for attribute locations\\n\\n\\t\\tvar cachedAttributes;\\n\\n\\t\\tthis.getAttributes = function () {\\n\\n\\t\\t\\tif ( cachedAttributes === undefined ) {\\n\\n\\t\\t\\t\\tcachedAttributes = fetchAttributeLocations( gl, program );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn cachedAttributes;\\n\\n\\t\\t};\\n\\n\\t\\t// free resource\\n\\n\\t\\tthis.destroy = function () {\\n\\n\\t\\t\\tgl.deleteProgram( program );\\n\\t\\t\\tthis.program = undefined;\\n\\n\\t\\t};\\n\\n\\t\\t// DEPRECATED\\n\\n\\t\\tObject.defineProperties( this, {\\n\\n\\t\\t\\tuniforms: {\\n\\t\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLProgram: .uniforms is now .getUniforms().' );\\n\\t\\t\\t\\t\\treturn this.getUniforms();\\n\\n\\t\\t\\t\\t}\\n\\t\\t\\t},\\n\\n\\t\\t\\tattributes: {\\n\\t\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLProgram: .attributes is now .getAttributes().' );\\n\\t\\t\\t\\t\\treturn this.getAttributes();\\n\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\n\\t\\t} );\\n\\n\\n\\t\\t//\\n\\n\\t\\tthis.id = programIdCount ++;\\n\\t\\tthis.code = code;\\n\\t\\tthis.usedTimes = 1;\\n\\t\\tthis.program = program;\\n\\t\\tthis.vertexShader = glVertexShader;\\n\\t\\tthis.fragmentShader = glFragmentShader;\\n\\n\\t\\treturn this;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLPrograms( renderer, extensions, capabilities ) {\\n\\n\\t\\tvar programs = [];\\n\\n\\t\\tvar shaderIDs = {\\n\\t\\t\\tMeshDepthMaterial: 'depth',\\n\\t\\t\\tMeshDistanceMaterial: 'distanceRGBA',\\n\\t\\t\\tMeshNormalMaterial: 'normal',\\n\\t\\t\\tMeshBasicMaterial: 'basic',\\n\\t\\t\\tMeshLambertMaterial: 'lambert',\\n\\t\\t\\tMeshPhongMaterial: 'phong',\\n\\t\\t\\tMeshToonMaterial: 'phong',\\n\\t\\t\\tMeshStandardMaterial: 'physical',\\n\\t\\t\\tMeshPhysicalMaterial: 'physical',\\n\\t\\t\\tLineBasicMaterial: 'basic',\\n\\t\\t\\tLineDashedMaterial: 'dashed',\\n\\t\\t\\tPointsMaterial: 'points',\\n\\t\\t\\tShadowMaterial: 'shadow'\\n\\t\\t};\\n\\n\\t\\tvar parameterNames = [\\n\\t\\t\\t\\\"precision\\\", \\\"supportsVertexTextures\\\", \\\"map\\\", \\\"mapEncoding\\\", \\\"envMap\\\", \\\"envMapMode\\\", \\\"envMapEncoding\\\",\\n\\t\\t\\t\\\"lightMap\\\", \\\"aoMap\\\", \\\"emissiveMap\\\", \\\"emissiveMapEncoding\\\", \\\"bumpMap\\\", \\\"normalMap\\\", \\\"displacementMap\\\", \\\"specularMap\\\",\\n\\t\\t\\t\\\"roughnessMap\\\", \\\"metalnessMap\\\", \\\"gradientMap\\\",\\n\\t\\t\\t\\\"alphaMap\\\", \\\"combine\\\", \\\"vertexColors\\\", \\\"fog\\\", \\\"useFog\\\", \\\"fogExp\\\",\\n\\t\\t\\t\\\"flatShading\\\", \\\"sizeAttenuation\\\", \\\"logarithmicDepthBuffer\\\", \\\"skinning\\\",\\n\\t\\t\\t\\\"maxBones\\\", \\\"useVertexTexture\\\", \\\"morphTargets\\\", \\\"morphNormals\\\",\\n\\t\\t\\t\\\"maxMorphTargets\\\", \\\"maxMorphNormals\\\", \\\"premultipliedAlpha\\\",\\n\\t\\t\\t\\\"numDirLights\\\", \\\"numPointLights\\\", \\\"numSpotLights\\\", \\\"numHemiLights\\\", \\\"numRectAreaLights\\\",\\n\\t\\t\\t\\\"shadowMapEnabled\\\", \\\"shadowMapType\\\", \\\"toneMapping\\\", 'physicallyCorrectLights',\\n\\t\\t\\t\\\"alphaTest\\\", \\\"doubleSided\\\", \\\"flipSided\\\", \\\"numClippingPlanes\\\", \\\"numClipIntersection\\\", \\\"depthPacking\\\", \\\"dithering\\\"\\n\\t\\t];\\n\\n\\n\\t\\tfunction allocateBones( object ) {\\n\\n\\t\\t\\tvar skeleton = object.skeleton;\\n\\t\\t\\tvar bones = skeleton.bones;\\n\\n\\t\\t\\tif ( capabilities.floatVertexTextures ) {\\n\\n\\t\\t\\t\\treturn 1024;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// default for when object is not specified\\n\\t\\t\\t\\t// ( for example when prebuilding shader to be used with multiple objects )\\n\\t\\t\\t\\t//\\n\\t\\t\\t\\t// - leave some extra space for other uniforms\\n\\t\\t\\t\\t// - limit here is ANGLE's 254 max uniform vectors\\n\\t\\t\\t\\t// (up to 54 should be safe)\\n\\n\\t\\t\\t\\tvar nVertexUniforms = capabilities.maxVertexUniforms;\\n\\t\\t\\t\\tvar nVertexMatrices = Math.floor( ( nVertexUniforms - 20 ) / 4 );\\n\\n\\t\\t\\t\\tvar maxBones = Math.min( nVertexMatrices, bones.length );\\n\\n\\t\\t\\t\\tif ( maxBones < bones.length ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Skeleton has ' + bones.length + ' bones. This GPU supports ' + maxBones + '.' );\\n\\t\\t\\t\\t\\treturn 0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn maxBones;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction getTextureEncodingFromMap( map, gammaOverrideLinear ) {\\n\\n\\t\\t\\tvar encoding;\\n\\n\\t\\t\\tif ( ! map ) {\\n\\n\\t\\t\\t\\tencoding = LinearEncoding;\\n\\n\\t\\t\\t} else if ( map.isTexture ) {\\n\\n\\t\\t\\t\\tencoding = map.encoding;\\n\\n\\t\\t\\t} else if ( map.isWebGLRenderTarget ) {\\n\\n\\t\\t\\t\\tconsole.warn( \\\"THREE.WebGLPrograms.getTextureEncodingFromMap: don't use render targets as textures. Use their .texture property instead.\\\" );\\n\\t\\t\\t\\tencoding = map.texture.encoding;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// add backwards compatibility for WebGLRenderer.gammaInput/gammaOutput parameter, should probably be removed at some point.\\n\\t\\t\\tif ( encoding === LinearEncoding && gammaOverrideLinear ) {\\n\\n\\t\\t\\t\\tencoding = GammaEncoding;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn encoding;\\n\\n\\t\\t}\\n\\n\\t\\tthis.getParameters = function ( material, lights, shadows, fog, nClipPlanes, nClipIntersection, object ) {\\n\\n\\t\\t\\tvar shaderID = shaderIDs[ material.type ];\\n\\n\\t\\t\\t// heuristics to create shader parameters according to lights in the scene\\n\\t\\t\\t// (not to blow over maxLights budget)\\n\\n\\t\\t\\tvar maxBones = object.isSkinnedMesh ? allocateBones( object ) : 0;\\n\\t\\t\\tvar precision = capabilities.precision;\\n\\n\\t\\t\\tif ( material.precision !== null ) {\\n\\n\\t\\t\\t\\tprecision = capabilities.getMaxPrecision( material.precision );\\n\\n\\t\\t\\t\\tif ( precision !== material.precision ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLProgram.getParameters:', material.precision, 'not supported, using', precision, 'instead.' );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar currentRenderTarget = renderer.getRenderTarget();\\n\\n\\t\\t\\tvar parameters = {\\n\\n\\t\\t\\t\\tshaderID: shaderID,\\n\\n\\t\\t\\t\\tprecision: precision,\\n\\t\\t\\t\\tsupportsVertexTextures: capabilities.vertexTextures,\\n\\t\\t\\t\\toutputEncoding: getTextureEncodingFromMap( ( ! currentRenderTarget ) ? null : currentRenderTarget.texture, renderer.gammaOutput ),\\n\\t\\t\\t\\tmap: !! material.map,\\n\\t\\t\\t\\tmapEncoding: getTextureEncodingFromMap( material.map, renderer.gammaInput ),\\n\\t\\t\\t\\tenvMap: !! material.envMap,\\n\\t\\t\\t\\tenvMapMode: material.envMap && material.envMap.mapping,\\n\\t\\t\\t\\tenvMapEncoding: getTextureEncodingFromMap( material.envMap, renderer.gammaInput ),\\n\\t\\t\\t\\tenvMapCubeUV: ( !! material.envMap ) && ( ( material.envMap.mapping === CubeUVReflectionMapping ) || ( material.envMap.mapping === CubeUVRefractionMapping ) ),\\n\\t\\t\\t\\tlightMap: !! material.lightMap,\\n\\t\\t\\t\\taoMap: !! material.aoMap,\\n\\t\\t\\t\\temissiveMap: !! material.emissiveMap,\\n\\t\\t\\t\\temissiveMapEncoding: getTextureEncodingFromMap( material.emissiveMap, renderer.gammaInput ),\\n\\t\\t\\t\\tbumpMap: !! material.bumpMap,\\n\\t\\t\\t\\tnormalMap: !! material.normalMap,\\n\\t\\t\\t\\tdisplacementMap: !! material.displacementMap,\\n\\t\\t\\t\\troughnessMap: !! material.roughnessMap,\\n\\t\\t\\t\\tmetalnessMap: !! material.metalnessMap,\\n\\t\\t\\t\\tspecularMap: !! material.specularMap,\\n\\t\\t\\t\\talphaMap: !! material.alphaMap,\\n\\n\\t\\t\\t\\tgradientMap: !! material.gradientMap,\\n\\n\\t\\t\\t\\tcombine: material.combine,\\n\\n\\t\\t\\t\\tvertexColors: material.vertexColors,\\n\\n\\t\\t\\t\\tfog: !! fog,\\n\\t\\t\\t\\tuseFog: material.fog,\\n\\t\\t\\t\\tfogExp: ( fog && fog.isFogExp2 ),\\n\\n\\t\\t\\t\\tflatShading: material.flatShading,\\n\\n\\t\\t\\t\\tsizeAttenuation: material.sizeAttenuation,\\n\\t\\t\\t\\tlogarithmicDepthBuffer: capabilities.logarithmicDepthBuffer,\\n\\n\\t\\t\\t\\tskinning: material.skinning && maxBones > 0,\\n\\t\\t\\t\\tmaxBones: maxBones,\\n\\t\\t\\t\\tuseVertexTexture: capabilities.floatVertexTextures,\\n\\n\\t\\t\\t\\tmorphTargets: material.morphTargets,\\n\\t\\t\\t\\tmorphNormals: material.morphNormals,\\n\\t\\t\\t\\tmaxMorphTargets: renderer.maxMorphTargets,\\n\\t\\t\\t\\tmaxMorphNormals: renderer.maxMorphNormals,\\n\\n\\t\\t\\t\\tnumDirLights: lights.directional.length,\\n\\t\\t\\t\\tnumPointLights: lights.point.length,\\n\\t\\t\\t\\tnumSpotLights: lights.spot.length,\\n\\t\\t\\t\\tnumRectAreaLights: lights.rectArea.length,\\n\\t\\t\\t\\tnumHemiLights: lights.hemi.length,\\n\\n\\t\\t\\t\\tnumClippingPlanes: nClipPlanes,\\n\\t\\t\\t\\tnumClipIntersection: nClipIntersection,\\n\\n\\t\\t\\t\\tdithering: material.dithering,\\n\\n\\t\\t\\t\\tshadowMapEnabled: renderer.shadowMap.enabled && object.receiveShadow && shadows.length > 0,\\n\\t\\t\\t\\tshadowMapType: renderer.shadowMap.type,\\n\\n\\t\\t\\t\\ttoneMapping: renderer.toneMapping,\\n\\t\\t\\t\\tphysicallyCorrectLights: renderer.physicallyCorrectLights,\\n\\n\\t\\t\\t\\tpremultipliedAlpha: material.premultipliedAlpha,\\n\\n\\t\\t\\t\\talphaTest: material.alphaTest,\\n\\t\\t\\t\\tdoubleSided: material.side === DoubleSide,\\n\\t\\t\\t\\tflipSided: material.side === BackSide,\\n\\n\\t\\t\\t\\tdepthPacking: ( material.depthPacking !== undefined ) ? material.depthPacking : false\\n\\n\\t\\t\\t};\\n\\n\\t\\t\\treturn parameters;\\n\\n\\t\\t};\\n\\n\\t\\tthis.getProgramCode = function ( material, parameters ) {\\n\\n\\t\\t\\tvar array = [];\\n\\n\\t\\t\\tif ( parameters.shaderID ) {\\n\\n\\t\\t\\t\\tarray.push( parameters.shaderID );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tarray.push( material.fragmentShader );\\n\\t\\t\\t\\tarray.push( material.vertexShader );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.defines !== undefined ) {\\n\\n\\t\\t\\t\\tfor ( var name in material.defines ) {\\n\\n\\t\\t\\t\\t\\tarray.push( name );\\n\\t\\t\\t\\t\\tarray.push( material.defines[ name ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = 0; i < parameterNames.length; i ++ ) {\\n\\n\\t\\t\\t\\tarray.push( parameters[ parameterNames[ i ] ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tarray.push( material.onBeforeCompile.toString() );\\n\\n\\t\\t\\tarray.push( renderer.gammaOutput );\\n\\n\\t\\t\\treturn array.join();\\n\\n\\t\\t};\\n\\n\\t\\tthis.acquireProgram = function ( material, shader, parameters, code ) {\\n\\n\\t\\t\\tvar program;\\n\\n\\t\\t\\t// Check if code has been already compiled\\n\\t\\t\\tfor ( var p = 0, pl = programs.length; p < pl; p ++ ) {\\n\\n\\t\\t\\t\\tvar programInfo = programs[ p ];\\n\\n\\t\\t\\t\\tif ( programInfo.code === code ) {\\n\\n\\t\\t\\t\\t\\tprogram = programInfo;\\n\\t\\t\\t\\t\\t++ program.usedTimes;\\n\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( program === undefined ) {\\n\\n\\t\\t\\t\\tprogram = new WebGLProgram( renderer, extensions, code, material, shader, parameters );\\n\\t\\t\\t\\tprograms.push( program );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn program;\\n\\n\\t\\t};\\n\\n\\t\\tthis.releaseProgram = function ( program ) {\\n\\n\\t\\t\\tif ( -- program.usedTimes === 0 ) {\\n\\n\\t\\t\\t\\t// Remove from unordered set\\n\\t\\t\\t\\tvar i = programs.indexOf( program );\\n\\t\\t\\t\\tprograms[ i ] = programs[ programs.length - 1 ];\\n\\t\\t\\t\\tprograms.pop();\\n\\n\\t\\t\\t\\t// Free WebGL resources\\n\\t\\t\\t\\tprogram.destroy();\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t\\t// Exposed for resource monitoring & error feedback via renderer.info:\\n\\t\\tthis.programs = programs;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLTextures( _gl, extensions, state, properties, capabilities, utils, infoMemory ) {\\n\\n\\t\\tvar _isWebGL2 = ( typeof WebGL2RenderingContext !== 'undefined' && _gl instanceof window.WebGL2RenderingContext );\\n\\t\\tvar _videoTextures = {};\\n\\n\\t\\t//\\n\\n\\t\\tfunction clampToMaxSize( image, maxSize ) {\\n\\n\\t\\t\\tif ( image.width > maxSize || image.height > maxSize ) {\\n\\n\\t\\t\\t\\t// Warning: Scaling through the canvas will only work with images that use\\n\\t\\t\\t\\t// premultiplied alpha.\\n\\n\\t\\t\\t\\tvar scale = maxSize / Math.max( image.width, image.height );\\n\\n\\t\\t\\t\\tvar canvas = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' );\\n\\t\\t\\t\\tcanvas.width = Math.floor( image.width * scale );\\n\\t\\t\\t\\tcanvas.height = Math.floor( image.height * scale );\\n\\n\\t\\t\\t\\tvar context = canvas.getContext( '2d' );\\n\\t\\t\\t\\tcontext.drawImage( image, 0, 0, image.width, image.height, 0, 0, canvas.width, canvas.height );\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: image is too big (' + image.width + 'x' + image.height + '). Resized to ' + canvas.width + 'x' + canvas.height, image );\\n\\n\\t\\t\\t\\treturn canvas;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn image;\\n\\n\\t\\t}\\n\\n\\t\\tfunction isPowerOfTwo( image ) {\\n\\n\\t\\t\\treturn _Math.isPowerOfTwo( image.width ) && _Math.isPowerOfTwo( image.height );\\n\\n\\t\\t}\\n\\n\\t\\tfunction makePowerOfTwo( image ) {\\n\\n\\t\\t\\tif ( image instanceof HTMLImageElement || image instanceof HTMLCanvasElement || image instanceof ImageBitmap ) {\\n\\n\\t\\t\\t\\tvar canvas = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' );\\n\\t\\t\\t\\tcanvas.width = _Math.floorPowerOfTwo( image.width );\\n\\t\\t\\t\\tcanvas.height = _Math.floorPowerOfTwo( image.height );\\n\\n\\t\\t\\t\\tvar context = canvas.getContext( '2d' );\\n\\t\\t\\t\\tcontext.drawImage( image, 0, 0, canvas.width, canvas.height );\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: image is not power of two (' + image.width + 'x' + image.height + '). Resized to ' + canvas.width + 'x' + canvas.height, image );\\n\\n\\t\\t\\t\\treturn canvas;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn image;\\n\\n\\t\\t}\\n\\n\\t\\tfunction textureNeedsPowerOfTwo( texture ) {\\n\\n\\t\\t\\treturn ( texture.wrapS !== ClampToEdgeWrapping || texture.wrapT !== ClampToEdgeWrapping ) ||\\n\\t\\t\\t\\t( texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter );\\n\\n\\t\\t}\\n\\n\\t\\tfunction textureNeedsGenerateMipmaps( texture, isPowerOfTwo ) {\\n\\n\\t\\t\\treturn texture.generateMipmaps && isPowerOfTwo &&\\n\\t\\t\\t\\ttexture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter;\\n\\n\\t\\t}\\n\\n\\t\\t// Fallback filters for non-power-of-2 textures\\n\\n\\t\\tfunction filterFallback( f ) {\\n\\n\\t\\t\\tif ( f === NearestFilter || f === NearestMipMapNearestFilter || f === NearestMipMapLinearFilter ) {\\n\\n\\t\\t\\t\\treturn _gl.NEAREST;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn _gl.LINEAR;\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tfunction onTextureDispose( event ) {\\n\\n\\t\\t\\tvar texture = event.target;\\n\\n\\t\\t\\ttexture.removeEventListener( 'dispose', onTextureDispose );\\n\\n\\t\\t\\tdeallocateTexture( texture );\\n\\n\\t\\t\\tif ( texture.isVideoTexture ) {\\n\\n\\t\\t\\t\\tdelete _videoTextures[ texture.id ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tinfoMemory.textures --;\\n\\n\\t\\t}\\n\\n\\t\\tfunction onRenderTargetDispose( event ) {\\n\\n\\t\\t\\tvar renderTarget = event.target;\\n\\n\\t\\t\\trenderTarget.removeEventListener( 'dispose', onRenderTargetDispose );\\n\\n\\t\\t\\tdeallocateRenderTarget( renderTarget );\\n\\n\\t\\t\\tinfoMemory.textures --;\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tfunction deallocateTexture( texture ) {\\n\\n\\t\\t\\tvar textureProperties = properties.get( texture );\\n\\n\\t\\t\\tif ( texture.image && textureProperties.__image__webglTextureCube ) {\\n\\n\\t\\t\\t\\t// cube texture\\n\\n\\t\\t\\t\\t_gl.deleteTexture( textureProperties.__image__webglTextureCube );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// 2D texture\\n\\n\\t\\t\\t\\tif ( textureProperties.__webglInit === undefined ) return;\\n\\n\\t\\t\\t\\t_gl.deleteTexture( textureProperties.__webglTexture );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// remove all webgl properties\\n\\t\\t\\tproperties.remove( texture );\\n\\n\\t\\t}\\n\\n\\t\\tfunction deallocateRenderTarget( renderTarget ) {\\n\\n\\t\\t\\tvar renderTargetProperties = properties.get( renderTarget );\\n\\t\\t\\tvar textureProperties = properties.get( renderTarget.texture );\\n\\n\\t\\t\\tif ( ! renderTarget ) return;\\n\\n\\t\\t\\tif ( textureProperties.__webglTexture !== undefined ) {\\n\\n\\t\\t\\t\\t_gl.deleteTexture( textureProperties.__webglTexture );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( renderTarget.depthTexture ) {\\n\\n\\t\\t\\t\\trenderTarget.depthTexture.dispose();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( renderTarget.isWebGLRenderTargetCube ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\t\\t_gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer[ i ] );\\n\\t\\t\\t\\t\\tif ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer[ i ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t_gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer );\\n\\t\\t\\t\\tif ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tproperties.remove( renderTarget.texture );\\n\\t\\t\\tproperties.remove( renderTarget );\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\n\\n\\t\\tfunction setTexture2D( texture, slot ) {\\n\\n\\t\\t\\tvar textureProperties = properties.get( texture );\\n\\n\\t\\t\\tif ( texture.version > 0 && textureProperties.__version !== texture.version ) {\\n\\n\\t\\t\\t\\tvar image = texture.image;\\n\\n\\t\\t\\t\\tif ( image === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Texture marked for update but image is undefined', texture );\\n\\n\\t\\t\\t\\t} else if ( image.complete === false ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Texture marked for update but image is incomplete', texture );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tuploadTexture( textureProperties, texture, slot );\\n\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tstate.activeTexture( _gl.TEXTURE0 + slot );\\n\\t\\t\\tstate.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture );\\n\\n\\t\\t}\\n\\n\\t\\tfunction setTextureCube( texture, slot ) {\\n\\n\\t\\t\\tvar textureProperties = properties.get( texture );\\n\\n\\t\\t\\tif ( texture.image.length === 6 ) {\\n\\n\\t\\t\\t\\tif ( texture.version > 0 && textureProperties.__version !== texture.version ) {\\n\\n\\t\\t\\t\\t\\tif ( ! textureProperties.__image__webglTextureCube ) {\\n\\n\\t\\t\\t\\t\\t\\ttexture.addEventListener( 'dispose', onTextureDispose );\\n\\n\\t\\t\\t\\t\\t\\ttextureProperties.__image__webglTextureCube = _gl.createTexture();\\n\\n\\t\\t\\t\\t\\t\\tinfoMemory.textures ++;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tstate.activeTexture( _gl.TEXTURE0 + slot );\\n\\t\\t\\t\\t\\tstate.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__image__webglTextureCube );\\n\\n\\t\\t\\t\\t\\t_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY );\\n\\n\\t\\t\\t\\t\\tvar isCompressed = ( texture && texture.isCompressedTexture );\\n\\t\\t\\t\\t\\tvar isDataTexture = ( texture.image[ 0 ] && texture.image[ 0 ].isDataTexture );\\n\\n\\t\\t\\t\\t\\tvar cubeImage = [];\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( ! isCompressed && ! isDataTexture ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tcubeImage[ i ] = clampToMaxSize( texture.image[ i ], capabilities.maxCubemapSize );\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tcubeImage[ i ] = isDataTexture ? texture.image[ i ].image : texture.image[ i ];\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tvar image = cubeImage[ 0 ],\\n\\t\\t\\t\\t\\t\\tisPowerOfTwoImage = isPowerOfTwo( image ),\\n\\t\\t\\t\\t\\t\\tglFormat = utils.convert( texture.format ),\\n\\t\\t\\t\\t\\t\\tglType = utils.convert( texture.type );\\n\\n\\t\\t\\t\\t\\tsetTextureParameters( _gl.TEXTURE_CUBE_MAP, texture, isPowerOfTwoImage );\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( ! isCompressed ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( isDataTexture ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glFormat, cubeImage[ i ].width, cubeImage[ i ].height, 0, glFormat, glType, cubeImage[ i ].data );\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glFormat, glFormat, glType, cubeImage[ i ] );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar mipmap, mipmaps = cubeImage[ i ].mipmaps;\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var j = 0, jl = mipmaps.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tmipmap = mipmaps[ j ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( texture.format !== RGBAFormat && texture.format !== RGBFormat ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif ( state.getCompressedTextureFormats().indexOf( glFormat ) > - 1 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tstate.compressedTexImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glFormat, mipmap.width, mipmap.height, 0, mipmap.data );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()' );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( textureNeedsGenerateMipmaps( texture, isPowerOfTwoImage ) ) {\\n\\n\\t\\t\\t\\t\\t\\t_gl.generateMipmap( _gl.TEXTURE_CUBE_MAP );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\ttextureProperties.__version = texture.version;\\n\\n\\t\\t\\t\\t\\tif ( texture.onUpdate ) texture.onUpdate( texture );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tstate.activeTexture( _gl.TEXTURE0 + slot );\\n\\t\\t\\t\\t\\tstate.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__image__webglTextureCube );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction setTextureCubeDynamic( texture, slot ) {\\n\\n\\t\\t\\tstate.activeTexture( _gl.TEXTURE0 + slot );\\n\\t\\t\\tstate.bindTexture( _gl.TEXTURE_CUBE_MAP, properties.get( texture ).__webglTexture );\\n\\n\\t\\t}\\n\\n\\t\\tfunction setTextureParameters( textureType, texture, isPowerOfTwoImage ) {\\n\\n\\t\\t\\tvar extension;\\n\\n\\t\\t\\tif ( isPowerOfTwoImage ) {\\n\\n\\t\\t\\t\\t_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_S, utils.convert( texture.wrapS ) );\\n\\t\\t\\t\\t_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_T, utils.convert( texture.wrapT ) );\\n\\n\\t\\t\\t\\t_gl.texParameteri( textureType, _gl.TEXTURE_MAG_FILTER, utils.convert( texture.magFilter ) );\\n\\t\\t\\t\\t_gl.texParameteri( textureType, _gl.TEXTURE_MIN_FILTER, utils.convert( texture.minFilter ) );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_S, _gl.CLAMP_TO_EDGE );\\n\\t\\t\\t\\t_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_T, _gl.CLAMP_TO_EDGE );\\n\\n\\t\\t\\t\\tif ( texture.wrapS !== ClampToEdgeWrapping || texture.wrapT !== ClampToEdgeWrapping ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping.', texture );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t_gl.texParameteri( textureType, _gl.TEXTURE_MAG_FILTER, filterFallback( texture.magFilter ) );\\n\\t\\t\\t\\t_gl.texParameteri( textureType, _gl.TEXTURE_MIN_FILTER, filterFallback( texture.minFilter ) );\\n\\n\\t\\t\\t\\tif ( texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.', texture );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\textension = extensions.get( 'EXT_texture_filter_anisotropic' );\\n\\n\\t\\t\\tif ( extension ) {\\n\\n\\t\\t\\t\\tif ( texture.type === FloatType && extensions.get( 'OES_texture_float_linear' ) === null ) return;\\n\\t\\t\\t\\tif ( texture.type === HalfFloatType && extensions.get( 'OES_texture_half_float_linear' ) === null ) return;\\n\\n\\t\\t\\t\\tif ( texture.anisotropy > 1 || properties.get( texture ).__currentAnisotropy ) {\\n\\n\\t\\t\\t\\t\\t_gl.texParameterf( textureType, extension.TEXTURE_MAX_ANISOTROPY_EXT, Math.min( texture.anisotropy, capabilities.getMaxAnisotropy() ) );\\n\\t\\t\\t\\t\\tproperties.get( texture ).__currentAnisotropy = texture.anisotropy;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction uploadTexture( textureProperties, texture, slot ) {\\n\\n\\t\\t\\tif ( textureProperties.__webglInit === undefined ) {\\n\\n\\t\\t\\t\\ttextureProperties.__webglInit = true;\\n\\n\\t\\t\\t\\ttexture.addEventListener( 'dispose', onTextureDispose );\\n\\n\\t\\t\\t\\ttextureProperties.__webglTexture = _gl.createTexture();\\n\\n\\t\\t\\t\\tif ( texture.isVideoTexture ) {\\n\\n\\t\\t\\t\\t\\t_videoTextures[ texture.id ] = texture;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tinfoMemory.textures ++;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tstate.activeTexture( _gl.TEXTURE0 + slot );\\n\\t\\t\\tstate.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture );\\n\\n\\t\\t\\t_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY );\\n\\t\\t\\t_gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha );\\n\\t\\t\\t_gl.pixelStorei( _gl.UNPACK_ALIGNMENT, texture.unpackAlignment );\\n\\n\\t\\t\\tvar image = clampToMaxSize( texture.image, capabilities.maxTextureSize );\\n\\n\\t\\t\\tif ( textureNeedsPowerOfTwo( texture ) && isPowerOfTwo( image ) === false ) {\\n\\n\\t\\t\\t\\timage = makePowerOfTwo( image );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar isPowerOfTwoImage = isPowerOfTwo( image ),\\n\\t\\t\\t\\tglFormat = utils.convert( texture.format ),\\n\\t\\t\\t\\tglType = utils.convert( texture.type );\\n\\n\\t\\t\\tsetTextureParameters( _gl.TEXTURE_2D, texture, isPowerOfTwoImage );\\n\\n\\t\\t\\tvar mipmap, mipmaps = texture.mipmaps;\\n\\n\\t\\t\\tif ( texture.isDepthTexture ) {\\n\\n\\t\\t\\t\\t// populate depth texture with dummy data\\n\\n\\t\\t\\t\\tvar internalFormat = _gl.DEPTH_COMPONENT;\\n\\n\\t\\t\\t\\tif ( texture.type === FloatType ) {\\n\\n\\t\\t\\t\\t\\tif ( ! _isWebGL2 ) throw new Error( 'Float Depth Texture only supported in WebGL2.0' );\\n\\t\\t\\t\\t\\tinternalFormat = _gl.DEPTH_COMPONENT32F;\\n\\n\\t\\t\\t\\t} else if ( _isWebGL2 ) {\\n\\n\\t\\t\\t\\t\\t// WebGL 2.0 requires signed internalformat for glTexImage2D\\n\\t\\t\\t\\t\\tinternalFormat = _gl.DEPTH_COMPONENT16;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( texture.format === DepthFormat && internalFormat === _gl.DEPTH_COMPONENT ) {\\n\\n\\t\\t\\t\\t\\t// The error INVALID_OPERATION is generated by texImage2D if format and internalformat are\\n\\t\\t\\t\\t\\t// DEPTH_COMPONENT and type is not UNSIGNED_SHORT or UNSIGNED_INT\\n\\t\\t\\t\\t\\t// (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)\\n\\t\\t\\t\\t\\tif ( texture.type !== UnsignedShortType && texture.type !== UnsignedIntType ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture.' );\\n\\n\\t\\t\\t\\t\\t\\ttexture.type = UnsignedShortType;\\n\\t\\t\\t\\t\\t\\tglType = utils.convert( texture.type );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// Depth stencil textures need the DEPTH_STENCIL internal format\\n\\t\\t\\t\\t// (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)\\n\\t\\t\\t\\tif ( texture.format === DepthStencilFormat ) {\\n\\n\\t\\t\\t\\t\\tinternalFormat = _gl.DEPTH_STENCIL;\\n\\n\\t\\t\\t\\t\\t// The error INVALID_OPERATION is generated by texImage2D if format and internalformat are\\n\\t\\t\\t\\t\\t// DEPTH_STENCIL and type is not UNSIGNED_INT_24_8_WEBGL.\\n\\t\\t\\t\\t\\t// (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)\\n\\t\\t\\t\\t\\tif ( texture.type !== UnsignedInt248Type ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture.' );\\n\\n\\t\\t\\t\\t\\t\\ttexture.type = UnsignedInt248Type;\\n\\t\\t\\t\\t\\t\\tglType = utils.convert( texture.type );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_2D, 0, internalFormat, image.width, image.height, 0, glFormat, glType, null );\\n\\n\\t\\t\\t} else if ( texture.isDataTexture ) {\\n\\n\\t\\t\\t\\t// use manually created mipmaps if available\\n\\t\\t\\t\\t// if there are no manual mipmaps\\n\\t\\t\\t\\t// set 0 level mipmap and then use GL to generate other mipmap levels\\n\\n\\t\\t\\t\\tif ( mipmaps.length > 0 && isPowerOfTwoImage ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, il = mipmaps.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tmipmap = mipmaps[ i ];\\n\\t\\t\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\ttexture.generateMipmaps = false;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_2D, 0, glFormat, image.width, image.height, 0, glFormat, glType, image.data );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( texture.isCompressedTexture ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0, il = mipmaps.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tmipmap = mipmaps[ i ];\\n\\n\\t\\t\\t\\t\\tif ( texture.format !== RGBAFormat && texture.format !== RGBFormat ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( state.getCompressedTextureFormats().indexOf( glFormat ) > - 1 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tstate.compressedTexImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, mipmap.data );\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()' );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// regular Texture (image, video, canvas)\\n\\n\\t\\t\\t\\t// use manually created mipmaps if available\\n\\t\\t\\t\\t// if there are no manual mipmaps\\n\\t\\t\\t\\t// set 0 level mipmap and then use GL to generate other mipmap levels\\n\\n\\t\\t\\t\\tif ( mipmaps.length > 0 && isPowerOfTwoImage ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, il = mipmaps.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tmipmap = mipmaps[ i ];\\n\\t\\t\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_2D, i, glFormat, glFormat, glType, mipmap );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\ttexture.generateMipmaps = false;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_2D, 0, glFormat, glFormat, glType, image );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( textureNeedsGenerateMipmaps( texture, isPowerOfTwoImage ) ) _gl.generateMipmap( _gl.TEXTURE_2D );\\n\\n\\t\\t\\ttextureProperties.__version = texture.version;\\n\\n\\t\\t\\tif ( texture.onUpdate ) texture.onUpdate( texture );\\n\\n\\t\\t}\\n\\n\\t\\t// Render targets\\n\\n\\t\\t// Setup storage for target texture and bind it to correct framebuffer\\n\\t\\tfunction setupFrameBufferTexture( framebuffer, renderTarget, attachment, textureTarget ) {\\n\\n\\t\\t\\tvar glFormat = utils.convert( renderTarget.texture.format );\\n\\t\\t\\tvar glType = utils.convert( renderTarget.texture.type );\\n\\t\\t\\tstate.texImage2D( textureTarget, 0, glFormat, renderTarget.width, renderTarget.height, 0, glFormat, glType, null );\\n\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );\\n\\t\\t\\t_gl.framebufferTexture2D( _gl.FRAMEBUFFER, attachment, textureTarget, properties.get( renderTarget.texture ).__webglTexture, 0 );\\n\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, null );\\n\\n\\t\\t}\\n\\n\\t\\t// Setup storage for internal depth/stencil buffers and bind to correct framebuffer\\n\\t\\tfunction setupRenderBufferStorage( renderbuffer, renderTarget ) {\\n\\n\\t\\t\\t_gl.bindRenderbuffer( _gl.RENDERBUFFER, renderbuffer );\\n\\n\\t\\t\\tif ( renderTarget.depthBuffer && ! renderTarget.stencilBuffer ) {\\n\\n\\t\\t\\t\\t_gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.DEPTH_COMPONENT16, renderTarget.width, renderTarget.height );\\n\\t\\t\\t\\t_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer );\\n\\n\\t\\t\\t} else if ( renderTarget.depthBuffer && renderTarget.stencilBuffer ) {\\n\\n\\t\\t\\t\\t_gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.DEPTH_STENCIL, renderTarget.width, renderTarget.height );\\n\\t\\t\\t\\t_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// FIXME: We don't support !depth !stencil\\n\\t\\t\\t\\t_gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.RGBA4, renderTarget.width, renderTarget.height );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t_gl.bindRenderbuffer( _gl.RENDERBUFFER, null );\\n\\n\\t\\t}\\n\\n\\t\\t// Setup resources for a Depth Texture for a FBO (needs an extension)\\n\\t\\tfunction setupDepthTexture( framebuffer, renderTarget ) {\\n\\n\\t\\t\\tvar isCube = ( renderTarget && renderTarget.isWebGLRenderTargetCube );\\n\\t\\t\\tif ( isCube ) throw new Error( 'Depth Texture with cube render targets is not supported' );\\n\\n\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );\\n\\n\\t\\t\\tif ( ! ( renderTarget.depthTexture && renderTarget.depthTexture.isDepthTexture ) ) {\\n\\n\\t\\t\\t\\tthrow new Error( 'renderTarget.depthTexture must be an instance of THREE.DepthTexture' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// upload an empty depth texture with framebuffer size\\n\\t\\t\\tif ( ! properties.get( renderTarget.depthTexture ).__webglTexture ||\\n\\t\\t\\t\\t\\trenderTarget.depthTexture.image.width !== renderTarget.width ||\\n\\t\\t\\t\\t\\trenderTarget.depthTexture.image.height !== renderTarget.height ) {\\n\\n\\t\\t\\t\\trenderTarget.depthTexture.image.width = renderTarget.width;\\n\\t\\t\\t\\trenderTarget.depthTexture.image.height = renderTarget.height;\\n\\t\\t\\t\\trenderTarget.depthTexture.needsUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tsetTexture2D( renderTarget.depthTexture, 0 );\\n\\n\\t\\t\\tvar webglDepthTexture = properties.get( renderTarget.depthTexture ).__webglTexture;\\n\\n\\t\\t\\tif ( renderTarget.depthTexture.format === DepthFormat ) {\\n\\n\\t\\t\\t\\t_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0 );\\n\\n\\t\\t\\t} else if ( renderTarget.depthTexture.format === DepthStencilFormat ) {\\n\\n\\t\\t\\t\\t_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0 );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthrow new Error( 'Unknown depthTexture format' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// Setup GL resources for a non-texture depth buffer\\n\\t\\tfunction setupDepthRenderbuffer( renderTarget ) {\\n\\n\\t\\t\\tvar renderTargetProperties = properties.get( renderTarget );\\n\\n\\t\\t\\tvar isCube = ( renderTarget.isWebGLRenderTargetCube === true );\\n\\n\\t\\t\\tif ( renderTarget.depthTexture ) {\\n\\n\\t\\t\\t\\tif ( isCube ) throw new Error( 'target.depthTexture not supported in Cube render targets' );\\n\\n\\t\\t\\t\\tsetupDepthTexture( renderTargetProperties.__webglFramebuffer, renderTarget );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tif ( isCube ) {\\n\\n\\t\\t\\t\\t\\trenderTargetProperties.__webglDepthbuffer = [];\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer[ i ] );\\n\\t\\t\\t\\t\\t\\trenderTargetProperties.__webglDepthbuffer[ i ] = _gl.createRenderbuffer();\\n\\t\\t\\t\\t\\t\\tsetupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer[ i ], renderTarget );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer );\\n\\t\\t\\t\\t\\trenderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer();\\n\\t\\t\\t\\t\\tsetupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer, renderTarget );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, null );\\n\\n\\t\\t}\\n\\n\\t\\t// Set up GL resources for the render target\\n\\t\\tfunction setupRenderTarget( renderTarget ) {\\n\\n\\t\\t\\tvar renderTargetProperties = properties.get( renderTarget );\\n\\t\\t\\tvar textureProperties = properties.get( renderTarget.texture );\\n\\n\\t\\t\\trenderTarget.addEventListener( 'dispose', onRenderTargetDispose );\\n\\n\\t\\t\\ttextureProperties.__webglTexture = _gl.createTexture();\\n\\n\\t\\t\\tinfoMemory.textures ++;\\n\\n\\t\\t\\tvar isCube = ( renderTarget.isWebGLRenderTargetCube === true );\\n\\t\\t\\tvar isTargetPowerOfTwo = isPowerOfTwo( renderTarget );\\n\\n\\t\\t\\t// Setup framebuffer\\n\\n\\t\\t\\tif ( isCube ) {\\n\\n\\t\\t\\t\\trenderTargetProperties.__webglFramebuffer = [];\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\t\\trenderTargetProperties.__webglFramebuffer[ i ] = _gl.createFramebuffer();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\trenderTargetProperties.__webglFramebuffer = _gl.createFramebuffer();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Setup color buffer\\n\\n\\t\\t\\tif ( isCube ) {\\n\\n\\t\\t\\t\\tstate.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture );\\n\\t\\t\\t\\tsetTextureParameters( _gl.TEXTURE_CUBE_MAP, renderTarget.texture, isTargetPowerOfTwo );\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\t\\tsetupFrameBufferTexture( renderTargetProperties.__webglFramebuffer[ i ], renderTarget, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( textureNeedsGenerateMipmaps( renderTarget.texture, isTargetPowerOfTwo ) ) _gl.generateMipmap( _gl.TEXTURE_CUBE_MAP );\\n\\t\\t\\t\\tstate.bindTexture( _gl.TEXTURE_CUBE_MAP, null );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tstate.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture );\\n\\t\\t\\t\\tsetTextureParameters( _gl.TEXTURE_2D, renderTarget.texture, isTargetPowerOfTwo );\\n\\t\\t\\t\\tsetupFrameBufferTexture( renderTargetProperties.__webglFramebuffer, renderTarget, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D );\\n\\n\\t\\t\\t\\tif ( textureNeedsGenerateMipmaps( renderTarget.texture, isTargetPowerOfTwo ) ) _gl.generateMipmap( _gl.TEXTURE_2D );\\n\\t\\t\\t\\tstate.bindTexture( _gl.TEXTURE_2D, null );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Setup depth and stencil buffers\\n\\n\\t\\t\\tif ( renderTarget.depthBuffer ) {\\n\\n\\t\\t\\t\\tsetupDepthRenderbuffer( renderTarget );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction updateRenderTargetMipmap( renderTarget ) {\\n\\n\\t\\t\\tvar texture = renderTarget.texture;\\n\\t\\t\\tvar isTargetPowerOfTwo = isPowerOfTwo( renderTarget );\\n\\n\\t\\t\\tif ( textureNeedsGenerateMipmaps( texture, isTargetPowerOfTwo ) ) {\\n\\n\\t\\t\\t\\tvar target = renderTarget.isWebGLRenderTargetCube ? _gl.TEXTURE_CUBE_MAP : _gl.TEXTURE_2D;\\n\\t\\t\\t\\tvar webglTexture = properties.get( texture ).__webglTexture;\\n\\n\\t\\t\\t\\tstate.bindTexture( target, webglTexture );\\n\\t\\t\\t\\t_gl.generateMipmap( target );\\n\\t\\t\\t\\tstate.bindTexture( target, null );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction updateVideoTextures() {\\n\\n\\t\\t\\tfor ( var id in _videoTextures ) {\\n\\n\\t\\t\\t\\t_videoTextures[ id ].update();\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tthis.setTexture2D = setTexture2D;\\n\\t\\tthis.setTextureCube = setTextureCube;\\n\\t\\tthis.setTextureCubeDynamic = setTextureCubeDynamic;\\n\\t\\tthis.setupRenderTarget = setupRenderTarget;\\n\\t\\tthis.updateRenderTargetMipmap = updateRenderTargetMipmap;\\n\\t\\tthis.updateVideoTextures = updateVideoTextures;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author fordacious / fordacious.github.io\\n\\t */\\n\\n\\tfunction WebGLProperties() {\\n\\n\\t\\tvar properties = {};\\n\\n\\t\\tfunction get( object ) {\\n\\n\\t\\t\\tvar uuid = object.uuid;\\n\\t\\t\\tvar map = properties[ uuid ];\\n\\n\\t\\t\\tif ( map === undefined ) {\\n\\n\\t\\t\\t\\tmap = {};\\n\\t\\t\\t\\tproperties[ uuid ] = map;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn map;\\n\\n\\t\\t}\\n\\n\\t\\tfunction remove( object ) {\\n\\n\\t\\t\\tdelete properties[ object.uuid ];\\n\\n\\t\\t}\\n\\n\\t\\tfunction clear() {\\n\\n\\t\\t\\tproperties = {};\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\t\\t\\tget: get,\\n\\t\\t\\tremove: remove,\\n\\t\\t\\tclear: clear\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLState( gl, extensions, utils ) {\\n\\n\\t\\tfunction ColorBuffer() {\\n\\n\\t\\t\\tvar locked = false;\\n\\n\\t\\t\\tvar color = new Vector4();\\n\\t\\t\\tvar currentColorMask = null;\\n\\t\\t\\tvar currentColorClear = new Vector4( 0, 0, 0, 0 );\\n\\n\\t\\t\\treturn {\\n\\n\\t\\t\\t\\tsetMask: function ( colorMask ) {\\n\\n\\t\\t\\t\\t\\tif ( currentColorMask !== colorMask && ! locked ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.colorMask( colorMask, colorMask, colorMask, colorMask );\\n\\t\\t\\t\\t\\t\\tcurrentColorMask = colorMask;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetLocked: function ( lock ) {\\n\\n\\t\\t\\t\\t\\tlocked = lock;\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetClear: function ( r, g, b, a, premultipliedAlpha ) {\\n\\n\\t\\t\\t\\t\\tif ( premultipliedAlpha === true ) {\\n\\n\\t\\t\\t\\t\\t\\tr *= a; g *= a; b *= a;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tcolor.set( r, g, b, a );\\n\\n\\t\\t\\t\\t\\tif ( currentColorClear.equals( color ) === false ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.clearColor( r, g, b, a );\\n\\t\\t\\t\\t\\t\\tcurrentColorClear.copy( color );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\treset: function () {\\n\\n\\t\\t\\t\\t\\tlocked = false;\\n\\n\\t\\t\\t\\t\\tcurrentColorMask = null;\\n\\t\\t\\t\\t\\tcurrentColorClear.set( - 1, 0, 0, 0 ); // set to invalid state\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}\\n\\n\\t\\tfunction DepthBuffer() {\\n\\n\\t\\t\\tvar locked = false;\\n\\n\\t\\t\\tvar currentDepthMask = null;\\n\\t\\t\\tvar currentDepthFunc = null;\\n\\t\\t\\tvar currentDepthClear = null;\\n\\n\\t\\t\\treturn {\\n\\n\\t\\t\\t\\tsetTest: function ( depthTest ) {\\n\\n\\t\\t\\t\\t\\tif ( depthTest ) {\\n\\n\\t\\t\\t\\t\\t\\tenable( gl.DEPTH_TEST );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tdisable( gl.DEPTH_TEST );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetMask: function ( depthMask ) {\\n\\n\\t\\t\\t\\t\\tif ( currentDepthMask !== depthMask && ! locked ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.depthMask( depthMask );\\n\\t\\t\\t\\t\\t\\tcurrentDepthMask = depthMask;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetFunc: function ( depthFunc ) {\\n\\n\\t\\t\\t\\t\\tif ( currentDepthFunc !== depthFunc ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( depthFunc ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tswitch ( depthFunc ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase NeverDepth:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.NEVER );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase AlwaysDepth:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.ALWAYS );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase LessDepth:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.LESS );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase LessEqualDepth:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.LEQUAL );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase EqualDepth:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.EQUAL );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase GreaterEqualDepth:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.GEQUAL );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase GreaterDepth:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.GREATER );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase NotEqualDepth:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.NOTEQUAL );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tdefault:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.LEQUAL );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.LEQUAL );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tcurrentDepthFunc = depthFunc;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetLocked: function ( lock ) {\\n\\n\\t\\t\\t\\t\\tlocked = lock;\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetClear: function ( depth ) {\\n\\n\\t\\t\\t\\t\\tif ( currentDepthClear !== depth ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.clearDepth( depth );\\n\\t\\t\\t\\t\\t\\tcurrentDepthClear = depth;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\treset: function () {\\n\\n\\t\\t\\t\\t\\tlocked = false;\\n\\n\\t\\t\\t\\t\\tcurrentDepthMask = null;\\n\\t\\t\\t\\t\\tcurrentDepthFunc = null;\\n\\t\\t\\t\\t\\tcurrentDepthClear = null;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}\\n\\n\\t\\tfunction StencilBuffer() {\\n\\n\\t\\t\\tvar locked = false;\\n\\n\\t\\t\\tvar currentStencilMask = null;\\n\\t\\t\\tvar currentStencilFunc = null;\\n\\t\\t\\tvar currentStencilRef = null;\\n\\t\\t\\tvar currentStencilFuncMask = null;\\n\\t\\t\\tvar currentStencilFail = null;\\n\\t\\t\\tvar currentStencilZFail = null;\\n\\t\\t\\tvar currentStencilZPass = null;\\n\\t\\t\\tvar currentStencilClear = null;\\n\\n\\t\\t\\treturn {\\n\\n\\t\\t\\t\\tsetTest: function ( stencilTest ) {\\n\\n\\t\\t\\t\\t\\tif ( stencilTest ) {\\n\\n\\t\\t\\t\\t\\t\\tenable( gl.STENCIL_TEST );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tdisable( gl.STENCIL_TEST );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetMask: function ( stencilMask ) {\\n\\n\\t\\t\\t\\t\\tif ( currentStencilMask !== stencilMask && ! locked ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.stencilMask( stencilMask );\\n\\t\\t\\t\\t\\t\\tcurrentStencilMask = stencilMask;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetFunc: function ( stencilFunc, stencilRef, stencilMask ) {\\n\\n\\t\\t\\t\\t\\tif ( currentStencilFunc !== stencilFunc ||\\n\\t\\t\\t\\t\\t currentStencilRef \\t!== stencilRef \\t||\\n\\t\\t\\t\\t\\t currentStencilFuncMask !== stencilMask ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.stencilFunc( stencilFunc, stencilRef, stencilMask );\\n\\n\\t\\t\\t\\t\\t\\tcurrentStencilFunc = stencilFunc;\\n\\t\\t\\t\\t\\t\\tcurrentStencilRef = stencilRef;\\n\\t\\t\\t\\t\\t\\tcurrentStencilFuncMask = stencilMask;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetOp: function ( stencilFail, stencilZFail, stencilZPass ) {\\n\\n\\t\\t\\t\\t\\tif ( currentStencilFail\\t !== stencilFail \\t||\\n\\t\\t\\t\\t\\t currentStencilZFail !== stencilZFail ||\\n\\t\\t\\t\\t\\t currentStencilZPass !== stencilZPass ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.stencilOp( stencilFail, stencilZFail, stencilZPass );\\n\\n\\t\\t\\t\\t\\t\\tcurrentStencilFail = stencilFail;\\n\\t\\t\\t\\t\\t\\tcurrentStencilZFail = stencilZFail;\\n\\t\\t\\t\\t\\t\\tcurrentStencilZPass = stencilZPass;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetLocked: function ( lock ) {\\n\\n\\t\\t\\t\\t\\tlocked = lock;\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetClear: function ( stencil ) {\\n\\n\\t\\t\\t\\t\\tif ( currentStencilClear !== stencil ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.clearStencil( stencil );\\n\\t\\t\\t\\t\\t\\tcurrentStencilClear = stencil;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\treset: function () {\\n\\n\\t\\t\\t\\t\\tlocked = false;\\n\\n\\t\\t\\t\\t\\tcurrentStencilMask = null;\\n\\t\\t\\t\\t\\tcurrentStencilFunc = null;\\n\\t\\t\\t\\t\\tcurrentStencilRef = null;\\n\\t\\t\\t\\t\\tcurrentStencilFuncMask = null;\\n\\t\\t\\t\\t\\tcurrentStencilFail = null;\\n\\t\\t\\t\\t\\tcurrentStencilZFail = null;\\n\\t\\t\\t\\t\\tcurrentStencilZPass = null;\\n\\t\\t\\t\\t\\tcurrentStencilClear = null;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tvar colorBuffer = new ColorBuffer();\\n\\t\\tvar depthBuffer = new DepthBuffer();\\n\\t\\tvar stencilBuffer = new StencilBuffer();\\n\\n\\t\\tvar maxVertexAttributes = gl.getParameter( gl.MAX_VERTEX_ATTRIBS );\\n\\t\\tvar newAttributes = new Uint8Array( maxVertexAttributes );\\n\\t\\tvar enabledAttributes = new Uint8Array( maxVertexAttributes );\\n\\t\\tvar attributeDivisors = new Uint8Array( maxVertexAttributes );\\n\\n\\t\\tvar capabilities = {};\\n\\n\\t\\tvar compressedTextureFormats = null;\\n\\n\\t\\tvar currentProgram = null;\\n\\n\\t\\tvar currentBlending = null;\\n\\t\\tvar currentBlendEquation = null;\\n\\t\\tvar currentBlendSrc = null;\\n\\t\\tvar currentBlendDst = null;\\n\\t\\tvar currentBlendEquationAlpha = null;\\n\\t\\tvar currentBlendSrcAlpha = null;\\n\\t\\tvar currentBlendDstAlpha = null;\\n\\t\\tvar currentPremultipledAlpha = false;\\n\\n\\t\\tvar currentFlipSided = null;\\n\\t\\tvar currentCullFace = null;\\n\\n\\t\\tvar currentLineWidth = null;\\n\\n\\t\\tvar currentPolygonOffsetFactor = null;\\n\\t\\tvar currentPolygonOffsetUnits = null;\\n\\n\\t\\tvar maxTextures = gl.getParameter( gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS );\\n\\n\\t\\tvar version = parseFloat( /^WebGL\\\\ ([0-9])/.exec( gl.getParameter( gl.VERSION ) )[ 1 ] );\\n\\t\\tvar lineWidthAvailable = parseFloat( version ) >= 1.0;\\n\\n\\t\\tvar currentTextureSlot = null;\\n\\t\\tvar currentBoundTextures = {};\\n\\n\\t\\tvar currentScissor = new Vector4();\\n\\t\\tvar currentViewport = new Vector4();\\n\\n\\t\\tfunction createTexture( type, target, count ) {\\n\\n\\t\\t\\tvar data = new Uint8Array( 4 ); // 4 is required to match default unpack alignment of 4.\\n\\t\\t\\tvar texture = gl.createTexture();\\n\\n\\t\\t\\tgl.bindTexture( type, texture );\\n\\t\\t\\tgl.texParameteri( type, gl.TEXTURE_MIN_FILTER, gl.NEAREST );\\n\\t\\t\\tgl.texParameteri( type, gl.TEXTURE_MAG_FILTER, gl.NEAREST );\\n\\n\\t\\t\\tfor ( var i = 0; i < count; i ++ ) {\\n\\n\\t\\t\\t\\tgl.texImage2D( target + i, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, data );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn texture;\\n\\n\\t\\t}\\n\\n\\t\\tvar emptyTextures = {};\\n\\t\\temptyTextures[ gl.TEXTURE_2D ] = createTexture( gl.TEXTURE_2D, gl.TEXTURE_2D, 1 );\\n\\t\\temptyTextures[ gl.TEXTURE_CUBE_MAP ] = createTexture( gl.TEXTURE_CUBE_MAP, gl.TEXTURE_CUBE_MAP_POSITIVE_X, 6 );\\n\\n\\t\\t// init\\n\\n\\t\\tcolorBuffer.setClear( 0, 0, 0, 1 );\\n\\t\\tdepthBuffer.setClear( 1 );\\n\\t\\tstencilBuffer.setClear( 0 );\\n\\n\\t\\tenable( gl.DEPTH_TEST );\\n\\t\\tdepthBuffer.setFunc( LessEqualDepth );\\n\\n\\t\\tsetFlipSided( false );\\n\\t\\tsetCullFace( CullFaceBack );\\n\\t\\tenable( gl.CULL_FACE );\\n\\n\\t\\tenable( gl.BLEND );\\n\\t\\tsetBlending( NormalBlending );\\n\\n\\t\\t//\\n\\n\\t\\tfunction initAttributes() {\\n\\n\\t\\t\\tfor ( var i = 0, l = newAttributes.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tnewAttributes[ i ] = 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction enableAttribute( attribute ) {\\n\\n\\t\\t\\tnewAttributes[ attribute ] = 1;\\n\\n\\t\\t\\tif ( enabledAttributes[ attribute ] === 0 ) {\\n\\n\\t\\t\\t\\tgl.enableVertexAttribArray( attribute );\\n\\t\\t\\t\\tenabledAttributes[ attribute ] = 1;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( attributeDivisors[ attribute ] !== 0 ) {\\n\\n\\t\\t\\t\\tvar extension = extensions.get( 'ANGLE_instanced_arrays' );\\n\\n\\t\\t\\t\\textension.vertexAttribDivisorANGLE( attribute, 0 );\\n\\t\\t\\t\\tattributeDivisors[ attribute ] = 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction enableAttributeAndDivisor( attribute, meshPerAttribute ) {\\n\\n\\t\\t\\tnewAttributes[ attribute ] = 1;\\n\\n\\t\\t\\tif ( enabledAttributes[ attribute ] === 0 ) {\\n\\n\\t\\t\\t\\tgl.enableVertexAttribArray( attribute );\\n\\t\\t\\t\\tenabledAttributes[ attribute ] = 1;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( attributeDivisors[ attribute ] !== meshPerAttribute ) {\\n\\n\\t\\t\\t\\tvar extension = extensions.get( 'ANGLE_instanced_arrays' );\\n\\n\\t\\t\\t\\textension.vertexAttribDivisorANGLE( attribute, meshPerAttribute );\\n\\t\\t\\t\\tattributeDivisors[ attribute ] = meshPerAttribute;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction disableUnusedAttributes() {\\n\\n\\t\\t\\tfor ( var i = 0, l = enabledAttributes.length; i !== l; ++ i ) {\\n\\n\\t\\t\\t\\tif ( enabledAttributes[ i ] !== newAttributes[ i ] ) {\\n\\n\\t\\t\\t\\t\\tgl.disableVertexAttribArray( i );\\n\\t\\t\\t\\t\\tenabledAttributes[ i ] = 0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction enable( id ) {\\n\\n\\t\\t\\tif ( capabilities[ id ] !== true ) {\\n\\n\\t\\t\\t\\tgl.enable( id );\\n\\t\\t\\t\\tcapabilities[ id ] = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction disable( id ) {\\n\\n\\t\\t\\tif ( capabilities[ id ] !== false ) {\\n\\n\\t\\t\\t\\tgl.disable( id );\\n\\t\\t\\t\\tcapabilities[ id ] = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction getCompressedTextureFormats() {\\n\\n\\t\\t\\tif ( compressedTextureFormats === null ) {\\n\\n\\t\\t\\t\\tcompressedTextureFormats = [];\\n\\n\\t\\t\\t\\tif ( extensions.get( 'WEBGL_compressed_texture_pvrtc' ) ||\\n\\t\\t\\t\\t extensions.get( 'WEBGL_compressed_texture_s3tc' ) ||\\n\\t\\t\\t\\t extensions.get( 'WEBGL_compressed_texture_etc1' ) ) {\\n\\n\\t\\t\\t\\t\\tvar formats = gl.getParameter( gl.COMPRESSED_TEXTURE_FORMATS );\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < formats.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tcompressedTextureFormats.push( formats[ i ] );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn compressedTextureFormats;\\n\\n\\t\\t}\\n\\n\\t\\tfunction useProgram( program ) {\\n\\n\\t\\t\\tif ( currentProgram !== program ) {\\n\\n\\t\\t\\t\\tgl.useProgram( program );\\n\\n\\t\\t\\t\\tcurrentProgram = program;\\n\\n\\t\\t\\t\\treturn true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn false;\\n\\n\\t\\t}\\n\\n\\t\\tfunction setBlending( blending, blendEquation, blendSrc, blendDst, blendEquationAlpha, blendSrcAlpha, blendDstAlpha, premultipliedAlpha ) {\\n\\n\\t\\t\\tif ( blending !== NoBlending ) {\\n\\n\\t\\t\\t\\tenable( gl.BLEND );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tdisable( gl.BLEND );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( blending !== CustomBlending ) {\\n\\n\\t\\t\\t\\tif ( blending !== currentBlending || premultipliedAlpha !== currentPremultipledAlpha ) {\\n\\n\\t\\t\\t\\t\\tswitch ( blending ) {\\n\\n\\t\\t\\t\\t\\t\\tcase AdditiveBlending:\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( premultipliedAlpha ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendFuncSeparate( gl.ONE, gl.ONE, gl.ONE, gl.ONE );\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendEquation( gl.FUNC_ADD );\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendFunc( gl.SRC_ALPHA, gl.ONE );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase SubtractiveBlending:\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( premultipliedAlpha ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendFuncSeparate( gl.ZERO, gl.ZERO, gl.ONE_MINUS_SRC_COLOR, gl.ONE_MINUS_SRC_ALPHA );\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendEquation( gl.FUNC_ADD );\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendFunc( gl.ZERO, gl.ONE_MINUS_SRC_COLOR );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase MultiplyBlending:\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( premultipliedAlpha ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendFuncSeparate( gl.ZERO, gl.SRC_COLOR, gl.ZERO, gl.SRC_ALPHA );\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendEquation( gl.FUNC_ADD );\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendFunc( gl.ZERO, gl.SRC_COLOR );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tdefault:\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( premultipliedAlpha ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendFuncSeparate( gl.ONE, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA );\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendFuncSeparate( gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tcurrentBlendEquation = null;\\n\\t\\t\\t\\tcurrentBlendSrc = null;\\n\\t\\t\\t\\tcurrentBlendDst = null;\\n\\t\\t\\t\\tcurrentBlendEquationAlpha = null;\\n\\t\\t\\t\\tcurrentBlendSrcAlpha = null;\\n\\t\\t\\t\\tcurrentBlendDstAlpha = null;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tblendEquationAlpha = blendEquationAlpha || blendEquation;\\n\\t\\t\\t\\tblendSrcAlpha = blendSrcAlpha || blendSrc;\\n\\t\\t\\t\\tblendDstAlpha = blendDstAlpha || blendDst;\\n\\n\\t\\t\\t\\tif ( blendEquation !== currentBlendEquation || blendEquationAlpha !== currentBlendEquationAlpha ) {\\n\\n\\t\\t\\t\\t\\tgl.blendEquationSeparate( utils.convert( blendEquation ), utils.convert( blendEquationAlpha ) );\\n\\n\\t\\t\\t\\t\\tcurrentBlendEquation = blendEquation;\\n\\t\\t\\t\\t\\tcurrentBlendEquationAlpha = blendEquationAlpha;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( blendSrc !== currentBlendSrc || blendDst !== currentBlendDst || blendSrcAlpha !== currentBlendSrcAlpha || blendDstAlpha !== currentBlendDstAlpha ) {\\n\\n\\t\\t\\t\\t\\tgl.blendFuncSeparate( utils.convert( blendSrc ), utils.convert( blendDst ), utils.convert( blendSrcAlpha ), utils.convert( blendDstAlpha ) );\\n\\n\\t\\t\\t\\t\\tcurrentBlendSrc = blendSrc;\\n\\t\\t\\t\\t\\tcurrentBlendDst = blendDst;\\n\\t\\t\\t\\t\\tcurrentBlendSrcAlpha = blendSrcAlpha;\\n\\t\\t\\t\\t\\tcurrentBlendDstAlpha = blendDstAlpha;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tcurrentBlending = blending;\\n\\t\\t\\tcurrentPremultipledAlpha = premultipliedAlpha;\\n\\n\\t\\t}\\n\\n\\t\\tfunction setMaterial( material, frontFaceCW ) {\\n\\n\\t\\t\\tmaterial.side === DoubleSide\\n\\t\\t\\t\\t? disable( gl.CULL_FACE )\\n\\t\\t\\t\\t: enable( gl.CULL_FACE );\\n\\n\\t\\t\\tvar flipSided = ( material.side === BackSide );\\n\\t\\t\\tif ( frontFaceCW ) flipSided = ! flipSided;\\n\\n\\t\\t\\tsetFlipSided( flipSided );\\n\\n\\t\\t\\tmaterial.transparent === true\\n\\t\\t\\t\\t? setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha, material.premultipliedAlpha )\\n\\t\\t\\t\\t: setBlending( NoBlending );\\n\\n\\t\\t\\tdepthBuffer.setFunc( material.depthFunc );\\n\\t\\t\\tdepthBuffer.setTest( material.depthTest );\\n\\t\\t\\tdepthBuffer.setMask( material.depthWrite );\\n\\t\\t\\tcolorBuffer.setMask( material.colorWrite );\\n\\n\\t\\t\\tsetPolygonOffset( material.polygonOffset, material.polygonOffsetFactor, material.polygonOffsetUnits );\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tfunction setFlipSided( flipSided ) {\\n\\n\\t\\t\\tif ( currentFlipSided !== flipSided ) {\\n\\n\\t\\t\\t\\tif ( flipSided ) {\\n\\n\\t\\t\\t\\t\\tgl.frontFace( gl.CW );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tgl.frontFace( gl.CCW );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tcurrentFlipSided = flipSided;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction setCullFace( cullFace ) {\\n\\n\\t\\t\\tif ( cullFace !== CullFaceNone ) {\\n\\n\\t\\t\\t\\tenable( gl.CULL_FACE );\\n\\n\\t\\t\\t\\tif ( cullFace !== currentCullFace ) {\\n\\n\\t\\t\\t\\t\\tif ( cullFace === CullFaceBack ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.cullFace( gl.BACK );\\n\\n\\t\\t\\t\\t\\t} else if ( cullFace === CullFaceFront ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.cullFace( gl.FRONT );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tgl.cullFace( gl.FRONT_AND_BACK );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tdisable( gl.CULL_FACE );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tcurrentCullFace = cullFace;\\n\\n\\t\\t}\\n\\n\\t\\tfunction setLineWidth( width ) {\\n\\n\\t\\t\\tif ( width !== currentLineWidth ) {\\n\\n\\t\\t\\t\\tif ( lineWidthAvailable ) gl.lineWidth( width );\\n\\n\\t\\t\\t\\tcurrentLineWidth = width;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction setPolygonOffset( polygonOffset, factor, units ) {\\n\\n\\t\\t\\tif ( polygonOffset ) {\\n\\n\\t\\t\\t\\tenable( gl.POLYGON_OFFSET_FILL );\\n\\n\\t\\t\\t\\tif ( currentPolygonOffsetFactor !== factor || currentPolygonOffsetUnits !== units ) {\\n\\n\\t\\t\\t\\t\\tgl.polygonOffset( factor, units );\\n\\n\\t\\t\\t\\t\\tcurrentPolygonOffsetFactor = factor;\\n\\t\\t\\t\\t\\tcurrentPolygonOffsetUnits = units;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tdisable( gl.POLYGON_OFFSET_FILL );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction setScissorTest( scissorTest ) {\\n\\n\\t\\t\\tif ( scissorTest ) {\\n\\n\\t\\t\\t\\tenable( gl.SCISSOR_TEST );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tdisable( gl.SCISSOR_TEST );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// texture\\n\\n\\t\\tfunction activeTexture( webglSlot ) {\\n\\n\\t\\t\\tif ( webglSlot === undefined ) webglSlot = gl.TEXTURE0 + maxTextures - 1;\\n\\n\\t\\t\\tif ( currentTextureSlot !== webglSlot ) {\\n\\n\\t\\t\\t\\tgl.activeTexture( webglSlot );\\n\\t\\t\\t\\tcurrentTextureSlot = webglSlot;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction bindTexture( webglType, webglTexture ) {\\n\\n\\t\\t\\tif ( currentTextureSlot === null ) {\\n\\n\\t\\t\\t\\tactiveTexture();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar boundTexture = currentBoundTextures[ currentTextureSlot ];\\n\\n\\t\\t\\tif ( boundTexture === undefined ) {\\n\\n\\t\\t\\t\\tboundTexture = { type: undefined, texture: undefined };\\n\\t\\t\\t\\tcurrentBoundTextures[ currentTextureSlot ] = boundTexture;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( boundTexture.type !== webglType || boundTexture.texture !== webglTexture ) {\\n\\n\\t\\t\\t\\tgl.bindTexture( webglType, webglTexture || emptyTextures[ webglType ] );\\n\\n\\t\\t\\t\\tboundTexture.type = webglType;\\n\\t\\t\\t\\tboundTexture.texture = webglTexture;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction compressedTexImage2D() {\\n\\n\\t\\t\\ttry {\\n\\n\\t\\t\\t\\tgl.compressedTexImage2D.apply( gl, arguments );\\n\\n\\t\\t\\t} catch ( error ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.WebGLState:', error );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction texImage2D() {\\n\\n\\t\\t\\ttry {\\n\\n\\t\\t\\t\\tgl.texImage2D.apply( gl, arguments );\\n\\n\\t\\t\\t} catch ( error ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.WebGLState:', error );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tfunction scissor( scissor ) {\\n\\n\\t\\t\\tif ( currentScissor.equals( scissor ) === false ) {\\n\\n\\t\\t\\t\\tgl.scissor( scissor.x, scissor.y, scissor.z, scissor.w );\\n\\t\\t\\t\\tcurrentScissor.copy( scissor );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction viewport( viewport ) {\\n\\n\\t\\t\\tif ( currentViewport.equals( viewport ) === false ) {\\n\\n\\t\\t\\t\\tgl.viewport( viewport.x, viewport.y, viewport.z, viewport.w );\\n\\t\\t\\t\\tcurrentViewport.copy( viewport );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tfunction reset() {\\n\\n\\t\\t\\tfor ( var i = 0; i < enabledAttributes.length; i ++ ) {\\n\\n\\t\\t\\t\\tif ( enabledAttributes[ i ] === 1 ) {\\n\\n\\t\\t\\t\\t\\tgl.disableVertexAttribArray( i );\\n\\t\\t\\t\\t\\tenabledAttributes[ i ] = 0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tcapabilities = {};\\n\\n\\t\\t\\tcompressedTextureFormats = null;\\n\\n\\t\\t\\tcurrentTextureSlot = null;\\n\\t\\t\\tcurrentBoundTextures = {};\\n\\n\\t\\t\\tcurrentProgram = null;\\n\\n\\t\\t\\tcurrentBlending = null;\\n\\n\\t\\t\\tcurrentFlipSided = null;\\n\\t\\t\\tcurrentCullFace = null;\\n\\n\\t\\t\\tcolorBuffer.reset();\\n\\t\\t\\tdepthBuffer.reset();\\n\\t\\t\\tstencilBuffer.reset();\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tbuffers: {\\n\\t\\t\\t\\tcolor: colorBuffer,\\n\\t\\t\\t\\tdepth: depthBuffer,\\n\\t\\t\\t\\tstencil: stencilBuffer\\n\\t\\t\\t},\\n\\n\\t\\t\\tinitAttributes: initAttributes,\\n\\t\\t\\tenableAttribute: enableAttribute,\\n\\t\\t\\tenableAttributeAndDivisor: enableAttributeAndDivisor,\\n\\t\\t\\tdisableUnusedAttributes: disableUnusedAttributes,\\n\\t\\t\\tenable: enable,\\n\\t\\t\\tdisable: disable,\\n\\t\\t\\tgetCompressedTextureFormats: getCompressedTextureFormats,\\n\\n\\t\\t\\tuseProgram: useProgram,\\n\\n\\t\\t\\tsetBlending: setBlending,\\n\\t\\t\\tsetMaterial: setMaterial,\\n\\n\\t\\t\\tsetFlipSided: setFlipSided,\\n\\t\\t\\tsetCullFace: setCullFace,\\n\\n\\t\\t\\tsetLineWidth: setLineWidth,\\n\\t\\t\\tsetPolygonOffset: setPolygonOffset,\\n\\n\\t\\t\\tsetScissorTest: setScissorTest,\\n\\n\\t\\t\\tactiveTexture: activeTexture,\\n\\t\\t\\tbindTexture: bindTexture,\\n\\t\\t\\tcompressedTexImage2D: compressedTexImage2D,\\n\\t\\t\\ttexImage2D: texImage2D,\\n\\n\\t\\t\\tscissor: scissor,\\n\\t\\t\\tviewport: viewport,\\n\\n\\t\\t\\treset: reset\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLCapabilities( gl, extensions, parameters ) {\\n\\n\\t\\tvar maxAnisotropy;\\n\\n\\t\\tfunction getMaxAnisotropy() {\\n\\n\\t\\t\\tif ( maxAnisotropy !== undefined ) return maxAnisotropy;\\n\\n\\t\\t\\tvar extension = extensions.get( 'EXT_texture_filter_anisotropic' );\\n\\n\\t\\t\\tif ( extension !== null ) {\\n\\n\\t\\t\\t\\tmaxAnisotropy = gl.getParameter( extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tmaxAnisotropy = 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn maxAnisotropy;\\n\\n\\t\\t}\\n\\n\\t\\tfunction getMaxPrecision( precision ) {\\n\\n\\t\\t\\tif ( precision === 'highp' ) {\\n\\n\\t\\t\\t\\tif ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.HIGH_FLOAT ).precision > 0 &&\\n\\t\\t\\t\\t gl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.HIGH_FLOAT ).precision > 0 ) {\\n\\n\\t\\t\\t\\t\\treturn 'highp';\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tprecision = 'mediump';\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( precision === 'mediump' ) {\\n\\n\\t\\t\\t\\tif ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.MEDIUM_FLOAT ).precision > 0 &&\\n\\t\\t\\t\\t gl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT ).precision > 0 ) {\\n\\n\\t\\t\\t\\t\\treturn 'mediump';\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn 'lowp';\\n\\n\\t\\t}\\n\\n\\t\\tvar precision = parameters.precision !== undefined ? parameters.precision : 'highp';\\n\\t\\tvar maxPrecision = getMaxPrecision( precision );\\n\\n\\t\\tif ( maxPrecision !== precision ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer:', precision, 'not supported, using', maxPrecision, 'instead.' );\\n\\t\\t\\tprecision = maxPrecision;\\n\\n\\t\\t}\\n\\n\\t\\tvar logarithmicDepthBuffer = parameters.logarithmicDepthBuffer === true;\\n\\n\\t\\tvar maxTextures = gl.getParameter( gl.MAX_TEXTURE_IMAGE_UNITS );\\n\\t\\tvar maxVertexTextures = gl.getParameter( gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS );\\n\\t\\tvar maxTextureSize = gl.getParameter( gl.MAX_TEXTURE_SIZE );\\n\\t\\tvar maxCubemapSize = gl.getParameter( gl.MAX_CUBE_MAP_TEXTURE_SIZE );\\n\\n\\t\\tvar maxAttributes = gl.getParameter( gl.MAX_VERTEX_ATTRIBS );\\n\\t\\tvar maxVertexUniforms = gl.getParameter( gl.MAX_VERTEX_UNIFORM_VECTORS );\\n\\t\\tvar maxVaryings = gl.getParameter( gl.MAX_VARYING_VECTORS );\\n\\t\\tvar maxFragmentUniforms = gl.getParameter( gl.MAX_FRAGMENT_UNIFORM_VECTORS );\\n\\n\\t\\tvar vertexTextures = maxVertexTextures > 0;\\n\\t\\tvar floatFragmentTextures = !! extensions.get( 'OES_texture_float' );\\n\\t\\tvar floatVertexTextures = vertexTextures && floatFragmentTextures;\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tgetMaxAnisotropy: getMaxAnisotropy,\\n\\t\\t\\tgetMaxPrecision: getMaxPrecision,\\n\\n\\t\\t\\tprecision: precision,\\n\\t\\t\\tlogarithmicDepthBuffer: logarithmicDepthBuffer,\\n\\n\\t\\t\\tmaxTextures: maxTextures,\\n\\t\\t\\tmaxVertexTextures: maxVertexTextures,\\n\\t\\t\\tmaxTextureSize: maxTextureSize,\\n\\t\\t\\tmaxCubemapSize: maxCubemapSize,\\n\\n\\t\\t\\tmaxAttributes: maxAttributes,\\n\\t\\t\\tmaxVertexUniforms: maxVertexUniforms,\\n\\t\\t\\tmaxVaryings: maxVaryings,\\n\\t\\t\\tmaxFragmentUniforms: maxFragmentUniforms,\\n\\n\\t\\t\\tvertexTextures: vertexTextures,\\n\\t\\t\\tfloatFragmentTextures: floatFragmentTextures,\\n\\t\\t\\tfloatVertexTextures: floatVertexTextures\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author greggman / http://games.greggman.com/\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction PerspectiveCamera( fov, aspect, near, far ) {\\n\\n\\t\\tCamera.call( this );\\n\\n\\t\\tthis.type = 'PerspectiveCamera';\\n\\n\\t\\tthis.fov = fov !== undefined ? fov : 50;\\n\\t\\tthis.zoom = 1;\\n\\n\\t\\tthis.near = near !== undefined ? near : 0.1;\\n\\t\\tthis.far = far !== undefined ? far : 2000;\\n\\t\\tthis.focus = 10;\\n\\n\\t\\tthis.aspect = aspect !== undefined ? aspect : 1;\\n\\t\\tthis.view = null;\\n\\n\\t\\tthis.filmGauge = 35;\\t// width of the film (default in millimeters)\\n\\t\\tthis.filmOffset = 0;\\t// horizontal film offset (same unit as gauge)\\n\\n\\t\\tthis.updateProjectionMatrix();\\n\\n\\t}\\n\\n\\tPerspectiveCamera.prototype = Object.assign( Object.create( Camera.prototype ), {\\n\\n\\t\\tconstructor: PerspectiveCamera,\\n\\n\\t\\tisPerspectiveCamera: true,\\n\\n\\t\\tcopy: function ( source, recursive ) {\\n\\n\\t\\t\\tCamera.prototype.copy.call( this, source, recursive );\\n\\n\\t\\t\\tthis.fov = source.fov;\\n\\t\\t\\tthis.zoom = source.zoom;\\n\\n\\t\\t\\tthis.near = source.near;\\n\\t\\t\\tthis.far = source.far;\\n\\t\\t\\tthis.focus = source.focus;\\n\\n\\t\\t\\tthis.aspect = source.aspect;\\n\\t\\t\\tthis.view = source.view === null ? null : Object.assign( {}, source.view );\\n\\n\\t\\t\\tthis.filmGauge = source.filmGauge;\\n\\t\\t\\tthis.filmOffset = source.filmOffset;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t/**\\n\\t\\t * Sets the FOV by focal length in respect to the current .filmGauge.\\n\\t\\t *\\n\\t\\t * The default film gauge is 35, so that the focal length can be specified for\\n\\t\\t * a 35mm (full frame) camera.\\n\\t\\t *\\n\\t\\t * Values for focal length and film gauge must have the same unit.\\n\\t\\t */\\n\\t\\tsetFocalLength: function ( focalLength ) {\\n\\n\\t\\t\\t// see http://www.bobatkins.com/photography/technical/field_of_view.html\\n\\t\\t\\tvar vExtentSlope = 0.5 * this.getFilmHeight() / focalLength;\\n\\n\\t\\t\\tthis.fov = _Math.RAD2DEG * 2 * Math.atan( vExtentSlope );\\n\\t\\t\\tthis.updateProjectionMatrix();\\n\\n\\t\\t},\\n\\n\\t\\t/**\\n\\t\\t * Calculates the focal length from the current .fov and .filmGauge.\\n\\t\\t */\\n\\t\\tgetFocalLength: function () {\\n\\n\\t\\t\\tvar vExtentSlope = Math.tan( _Math.DEG2RAD * 0.5 * this.fov );\\n\\n\\t\\t\\treturn 0.5 * this.getFilmHeight() / vExtentSlope;\\n\\n\\t\\t},\\n\\n\\t\\tgetEffectiveFOV: function () {\\n\\n\\t\\t\\treturn _Math.RAD2DEG * 2 * Math.atan(\\n\\t\\t\\t\\tMath.tan( _Math.DEG2RAD * 0.5 * this.fov ) / this.zoom );\\n\\n\\t\\t},\\n\\n\\t\\tgetFilmWidth: function () {\\n\\n\\t\\t\\t// film not completely covered in portrait format (aspect < 1)\\n\\t\\t\\treturn this.filmGauge * Math.min( this.aspect, 1 );\\n\\n\\t\\t},\\n\\n\\t\\tgetFilmHeight: function () {\\n\\n\\t\\t\\t// film not completely covered in landscape format (aspect > 1)\\n\\t\\t\\treturn this.filmGauge / Math.max( this.aspect, 1 );\\n\\n\\t\\t},\\n\\n\\t\\t/**\\n\\t\\t * Sets an offset in a larger frustum. This is useful for multi-window or\\n\\t\\t * multi-monitor/multi-machine setups.\\n\\t\\t *\\n\\t\\t * For example, if you have 3x2 monitors and each monitor is 1920x1080 and\\n\\t\\t * the monitors are in grid like this\\n\\t\\t *\\n\\t\\t * +---+---+---+\\n\\t\\t * | A | B | C |\\n\\t\\t * +---+---+---+\\n\\t\\t * | D | E | F |\\n\\t\\t * +---+---+---+\\n\\t\\t *\\n\\t\\t * then for each monitor you would call it like this\\n\\t\\t *\\n\\t\\t * var w = 1920;\\n\\t\\t * var h = 1080;\\n\\t\\t * var fullWidth = w * 3;\\n\\t\\t * var fullHeight = h * 2;\\n\\t\\t *\\n\\t\\t * --A--\\n\\t\\t * camera.setOffset( fullWidth, fullHeight, w * 0, h * 0, w, h );\\n\\t\\t * --B--\\n\\t\\t * camera.setOffset( fullWidth, fullHeight, w * 1, h * 0, w, h );\\n\\t\\t * --C--\\n\\t\\t * camera.setOffset( fullWidth, fullHeight, w * 2, h * 0, w, h );\\n\\t\\t * --D--\\n\\t\\t * camera.setOffset( fullWidth, fullHeight, w * 0, h * 1, w, h );\\n\\t\\t * --E--\\n\\t\\t * camera.setOffset( fullWidth, fullHeight, w * 1, h * 1, w, h );\\n\\t\\t * --F--\\n\\t\\t * camera.setOffset( fullWidth, fullHeight, w * 2, h * 1, w, h );\\n\\t\\t *\\n\\t\\t * Note there is no reason monitors have to be the same size or in a grid.\\n\\t\\t */\\n\\t\\tsetViewOffset: function ( fullWidth, fullHeight, x, y, width, height ) {\\n\\n\\t\\t\\tthis.aspect = fullWidth / fullHeight;\\n\\n\\t\\t\\tif ( this.view === null ) {\\n\\n\\t\\t\\t\\tthis.view = {\\n\\t\\t\\t\\t\\tenabled: true,\\n\\t\\t\\t\\t\\tfullWidth: 1,\\n\\t\\t\\t\\t\\tfullHeight: 1,\\n\\t\\t\\t\\t\\toffsetX: 0,\\n\\t\\t\\t\\t\\toffsetY: 0,\\n\\t\\t\\t\\t\\twidth: 1,\\n\\t\\t\\t\\t\\theight: 1\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.view.enabled = true;\\n\\t\\t\\tthis.view.fullWidth = fullWidth;\\n\\t\\t\\tthis.view.fullHeight = fullHeight;\\n\\t\\t\\tthis.view.offsetX = x;\\n\\t\\t\\tthis.view.offsetY = y;\\n\\t\\t\\tthis.view.width = width;\\n\\t\\t\\tthis.view.height = height;\\n\\n\\t\\t\\tthis.updateProjectionMatrix();\\n\\n\\t\\t},\\n\\n\\t\\tclearViewOffset: function () {\\n\\n\\t\\t\\tif ( this.view !== null ) {\\n\\n\\t\\t\\t\\tthis.view.enabled = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.updateProjectionMatrix();\\n\\n\\t\\t},\\n\\n\\t\\tupdateProjectionMatrix: function () {\\n\\n\\t\\t\\tvar near = this.near,\\n\\t\\t\\t\\ttop = near * Math.tan(\\n\\t\\t\\t\\t\\t_Math.DEG2RAD * 0.5 * this.fov ) / this.zoom,\\n\\t\\t\\t\\theight = 2 * top,\\n\\t\\t\\t\\twidth = this.aspect * height,\\n\\t\\t\\t\\tleft = - 0.5 * width,\\n\\t\\t\\t\\tview = this.view;\\n\\n\\t\\t\\tif ( this.view !== null && this.view.enabled ) {\\n\\n\\t\\t\\t\\tvar fullWidth = view.fullWidth,\\n\\t\\t\\t\\t\\tfullHeight = view.fullHeight;\\n\\n\\t\\t\\t\\tleft += view.offsetX * width / fullWidth;\\n\\t\\t\\t\\ttop -= view.offsetY * height / fullHeight;\\n\\t\\t\\t\\twidth *= view.width / fullWidth;\\n\\t\\t\\t\\theight *= view.height / fullHeight;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar skew = this.filmOffset;\\n\\t\\t\\tif ( skew !== 0 ) left += near * skew / this.getFilmWidth();\\n\\n\\t\\t\\tthis.projectionMatrix.makePerspective( left, left + width, top, top - height, near, this.far );\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\tvar data = Object3D.prototype.toJSON.call( this, meta );\\n\\n\\t\\t\\tdata.object.fov = this.fov;\\n\\t\\t\\tdata.object.zoom = this.zoom;\\n\\n\\t\\t\\tdata.object.near = this.near;\\n\\t\\t\\tdata.object.far = this.far;\\n\\t\\t\\tdata.object.focus = this.focus;\\n\\n\\t\\t\\tdata.object.aspect = this.aspect;\\n\\n\\t\\t\\tif ( this.view !== null ) data.object.view = Object.assign( {}, this.view );\\n\\n\\t\\t\\tdata.object.filmGauge = this.filmGauge;\\n\\t\\t\\tdata.object.filmOffset = this.filmOffset;\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction ArrayCamera( array ) {\\n\\n\\t\\tPerspectiveCamera.call( this );\\n\\n\\t\\tthis.cameras = array || [];\\n\\n\\t}\\n\\n\\tArrayCamera.prototype = Object.assign( Object.create( PerspectiveCamera.prototype ), {\\n\\n\\t\\tconstructor: ArrayCamera,\\n\\n\\t\\tisArrayCamera: true\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebVRManager( renderer ) {\\n\\n\\t\\tvar scope = this;\\n\\n\\t\\tvar device = null;\\n\\t\\tvar frameData = null;\\n\\n\\t\\tvar poseTarget = null;\\n\\n\\t\\tif ( typeof window !== 'undefined' && 'VRFrameData' in window ) {\\n\\n\\t\\t\\tframeData = new window.VRFrameData();\\n\\n\\t\\t}\\n\\n\\t\\tvar matrixWorldInverse = new Matrix4();\\n\\n\\t\\tvar cameraL = new PerspectiveCamera();\\n\\t\\tcameraL.bounds = new Vector4( 0.0, 0.0, 0.5, 1.0 );\\n\\t\\tcameraL.layers.enable( 1 );\\n\\n\\t\\tvar cameraR = new PerspectiveCamera();\\n\\t\\tcameraR.bounds = new Vector4( 0.5, 0.0, 0.5, 1.0 );\\n\\t\\tcameraR.layers.enable( 2 );\\n\\n\\t\\tvar cameraVR = new ArrayCamera( [ cameraL, cameraR ] );\\n\\t\\tcameraVR.layers.enable( 1 );\\n\\t\\tcameraVR.layers.enable( 2 );\\n\\n\\t\\t//\\n\\n\\t\\tvar currentSize, currentPixelRatio;\\n\\n\\t\\tfunction onVRDisplayPresentChange() {\\n\\n\\t\\t\\tif ( device !== null && device.isPresenting ) {\\n\\n\\t\\t\\t\\tvar eyeParameters = device.getEyeParameters( 'left' );\\n\\t\\t\\t\\tvar renderWidth = eyeParameters.renderWidth;\\n\\t\\t\\t\\tvar renderHeight = eyeParameters.renderHeight;\\n\\n\\t\\t\\t\\tcurrentPixelRatio = renderer.getPixelRatio();\\n\\t\\t\\t\\tcurrentSize = renderer.getSize();\\n\\n\\t\\t\\t\\trenderer.setDrawingBufferSize( renderWidth * 2, renderHeight, 1 );\\n\\n\\t\\t\\t} else if ( scope.enabled ) {\\n\\n\\t\\t\\t\\trenderer.setDrawingBufferSize( currentSize.width, currentSize.height, currentPixelRatio );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tif ( typeof window !== 'undefined' ) {\\n\\n\\t\\t\\twindow.addEventListener( 'vrdisplaypresentchange', onVRDisplayPresentChange, false );\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tthis.enabled = false;\\n\\n\\t\\tthis.getDevice = function () {\\n\\n\\t\\t\\treturn device;\\n\\n\\t\\t};\\n\\n\\t\\tthis.setDevice = function ( value ) {\\n\\n\\t\\t\\tif ( value !== undefined ) device = value;\\n\\n\\t\\t};\\n\\n\\t\\tthis.setPoseTarget = function ( object ) {\\n\\n\\t\\t\\tif ( object !== undefined ) poseTarget = object;\\n\\n\\t\\t};\\n\\n\\t\\tthis.getCamera = function ( camera ) {\\n\\n\\t\\t\\tif ( device === null ) return camera;\\n\\n\\t\\t\\tdevice.depthNear = camera.near;\\n\\t\\t\\tdevice.depthFar = camera.far;\\n\\n\\t\\t\\tdevice.getFrameData( frameData );\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar pose = frameData.pose;\\n\\t\\t\\tvar poseObject = poseTarget !== null ? poseTarget : camera;\\n\\n\\t\\t\\tif ( pose.position !== null ) {\\n\\n\\t\\t\\t\\tposeObject.position.fromArray( pose.position );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tposeObject.position.set( 0, 0, 0 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( pose.orientation !== null ) {\\n\\n\\t\\t\\t\\tposeObject.quaternion.fromArray( pose.orientation );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tposeObject.updateMatrixWorld();\\n\\n\\t\\t\\tif ( device.isPresenting === false ) return camera;\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tcameraL.near = camera.near;\\n\\t\\t\\tcameraR.near = camera.near;\\n\\n\\t\\t\\tcameraL.far = camera.far;\\n\\t\\t\\tcameraR.far = camera.far;\\n\\n\\t\\t\\tcameraVR.matrixWorld.copy( camera.matrixWorld );\\n\\t\\t\\tcameraVR.matrixWorldInverse.copy( camera.matrixWorldInverse );\\n\\n\\t\\t\\tcameraL.matrixWorldInverse.fromArray( frameData.leftViewMatrix );\\n\\t\\t\\tcameraR.matrixWorldInverse.fromArray( frameData.rightViewMatrix );\\n\\n\\t\\t\\tvar parent = poseObject.parent;\\n\\n\\t\\t\\tif ( parent !== null ) {\\n\\n\\t\\t\\t\\tmatrixWorldInverse.getInverse( parent.matrixWorld );\\n\\n\\t\\t\\t\\tcameraL.matrixWorldInverse.multiply( matrixWorldInverse );\\n\\t\\t\\t\\tcameraR.matrixWorldInverse.multiply( matrixWorldInverse );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// envMap and Mirror needs camera.matrixWorld\\n\\n\\t\\t\\tcameraL.matrixWorld.getInverse( cameraL.matrixWorldInverse );\\n\\t\\t\\tcameraR.matrixWorld.getInverse( cameraR.matrixWorldInverse );\\n\\n\\t\\t\\tcameraL.projectionMatrix.fromArray( frameData.leftProjectionMatrix );\\n\\t\\t\\tcameraR.projectionMatrix.fromArray( frameData.rightProjectionMatrix );\\n\\n\\t\\t\\t// HACK @mrdoob\\n\\t\\t\\t// https://github.com/w3c/webvr/issues/203\\n\\n\\t\\t\\tcameraVR.projectionMatrix.copy( cameraL.projectionMatrix );\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar layers = device.getLayers();\\n\\n\\t\\t\\tif ( layers.length ) {\\n\\n\\t\\t\\t\\tvar layer = layers[ 0 ];\\n\\n\\t\\t\\t\\tif ( layer.leftBounds !== null && layer.leftBounds.length === 4 ) {\\n\\n\\t\\t\\t\\t\\tcameraL.bounds.fromArray( layer.leftBounds );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( layer.rightBounds !== null && layer.rightBounds.length === 4 ) {\\n\\n\\t\\t\\t\\t\\tcameraR.bounds.fromArray( layer.rightBounds );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn cameraVR;\\n\\n\\t\\t};\\n\\n\\t\\tthis.submitFrame = function () {\\n\\n\\t\\t\\tif ( device && device.isPresenting ) device.submitFrame();\\n\\n\\t\\t};\\n\\n\\t\\tthis.dispose = function () {\\n\\n\\t\\t\\tif ( typeof window !== 'undefined' ) {\\n\\n\\t\\t\\t\\twindow.removeEventListener( 'vrdisplaypresentchange', onVRDisplayPresentChange );\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLExtensions( gl ) {\\n\\n\\t\\tvar extensions = {};\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tget: function ( name ) {\\n\\n\\t\\t\\t\\tif ( extensions[ name ] !== undefined ) {\\n\\n\\t\\t\\t\\t\\treturn extensions[ name ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar extension;\\n\\n\\t\\t\\t\\tswitch ( name ) {\\n\\n\\t\\t\\t\\t\\tcase 'WEBGL_depth_texture':\\n\\t\\t\\t\\t\\t\\textension = gl.getExtension( 'WEBGL_depth_texture' ) || gl.getExtension( 'MOZ_WEBGL_depth_texture' ) || gl.getExtension( 'WEBKIT_WEBGL_depth_texture' );\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'EXT_texture_filter_anisotropic':\\n\\t\\t\\t\\t\\t\\textension = gl.getExtension( 'EXT_texture_filter_anisotropic' ) || gl.getExtension( 'MOZ_EXT_texture_filter_anisotropic' ) || gl.getExtension( 'WEBKIT_EXT_texture_filter_anisotropic' );\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'WEBGL_compressed_texture_s3tc':\\n\\t\\t\\t\\t\\t\\textension = gl.getExtension( 'WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'MOZ_WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_s3tc' );\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'WEBGL_compressed_texture_pvrtc':\\n\\t\\t\\t\\t\\t\\textension = gl.getExtension( 'WEBGL_compressed_texture_pvrtc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_pvrtc' );\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'WEBGL_compressed_texture_etc1':\\n\\t\\t\\t\\t\\t\\textension = gl.getExtension( 'WEBGL_compressed_texture_etc1' );\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tdefault:\\n\\t\\t\\t\\t\\t\\textension = gl.getExtension( name );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( extension === null ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: ' + name + ' extension not supported.' );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\textensions[ name ] = extension;\\n\\n\\t\\t\\t\\treturn extension;\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction WebGLClipping() {\\n\\n\\t\\tvar scope = this,\\n\\n\\t\\t\\tglobalState = null,\\n\\t\\t\\tnumGlobalPlanes = 0,\\n\\t\\t\\tlocalClippingEnabled = false,\\n\\t\\t\\trenderingShadows = false,\\n\\n\\t\\t\\tplane = new Plane(),\\n\\t\\t\\tviewNormalMatrix = new Matrix3(),\\n\\n\\t\\t\\tuniform = { value: null, needsUpdate: false };\\n\\n\\t\\tthis.uniform = uniform;\\n\\t\\tthis.numPlanes = 0;\\n\\t\\tthis.numIntersection = 0;\\n\\n\\t\\tthis.init = function ( planes, enableLocalClipping, camera ) {\\n\\n\\t\\t\\tvar enabled =\\n\\t\\t\\t\\tplanes.length !== 0 ||\\n\\t\\t\\t\\tenableLocalClipping ||\\n\\t\\t\\t\\t// enable state of previous frame - the clipping code has to\\n\\t\\t\\t\\t// run another frame in order to reset the state:\\n\\t\\t\\t\\tnumGlobalPlanes !== 0 ||\\n\\t\\t\\t\\tlocalClippingEnabled;\\n\\n\\t\\t\\tlocalClippingEnabled = enableLocalClipping;\\n\\n\\t\\t\\tglobalState = projectPlanes( planes, camera, 0 );\\n\\t\\t\\tnumGlobalPlanes = planes.length;\\n\\n\\t\\t\\treturn enabled;\\n\\n\\t\\t};\\n\\n\\t\\tthis.beginShadows = function () {\\n\\n\\t\\t\\trenderingShadows = true;\\n\\t\\t\\tprojectPlanes( null );\\n\\n\\t\\t};\\n\\n\\t\\tthis.endShadows = function () {\\n\\n\\t\\t\\trenderingShadows = false;\\n\\t\\t\\tresetGlobalState();\\n\\n\\t\\t};\\n\\n\\t\\tthis.setState = function ( planes, clipIntersection, clipShadows, camera, cache, fromCache ) {\\n\\n\\t\\t\\tif ( ! localClippingEnabled || planes === null || planes.length === 0 || renderingShadows && ! clipShadows ) {\\n\\n\\t\\t\\t\\t// there's no local clipping\\n\\n\\t\\t\\t\\tif ( renderingShadows ) {\\n\\n\\t\\t\\t\\t\\t// there's no global clipping\\n\\n\\t\\t\\t\\t\\tprojectPlanes( null );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tresetGlobalState();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tvar nGlobal = renderingShadows ? 0 : numGlobalPlanes,\\n\\t\\t\\t\\t\\tlGlobal = nGlobal * 4,\\n\\n\\t\\t\\t\\t\\tdstArray = cache.clippingState || null;\\n\\n\\t\\t\\t\\tuniform.value = dstArray; // ensure unique state\\n\\n\\t\\t\\t\\tdstArray = projectPlanes( planes, camera, lGlobal, fromCache );\\n\\n\\t\\t\\t\\tfor ( var i = 0; i !== lGlobal; ++ i ) {\\n\\n\\t\\t\\t\\t\\tdstArray[ i ] = globalState[ i ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tcache.clippingState = dstArray;\\n\\t\\t\\t\\tthis.numIntersection = clipIntersection ? this.numPlanes : 0;\\n\\t\\t\\t\\tthis.numPlanes += nGlobal;\\n\\n\\t\\t\\t}\\n\\n\\n\\t\\t};\\n\\n\\t\\tfunction resetGlobalState() {\\n\\n\\t\\t\\tif ( uniform.value !== globalState ) {\\n\\n\\t\\t\\t\\tuniform.value = globalState;\\n\\t\\t\\t\\tuniform.needsUpdate = numGlobalPlanes > 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tscope.numPlanes = numGlobalPlanes;\\n\\t\\t\\tscope.numIntersection = 0;\\n\\n\\t\\t}\\n\\n\\t\\tfunction projectPlanes( planes, camera, dstOffset, skipTransform ) {\\n\\n\\t\\t\\tvar nPlanes = planes !== null ? planes.length : 0,\\n\\t\\t\\t\\tdstArray = null;\\n\\n\\t\\t\\tif ( nPlanes !== 0 ) {\\n\\n\\t\\t\\t\\tdstArray = uniform.value;\\n\\n\\t\\t\\t\\tif ( skipTransform !== true || dstArray === null ) {\\n\\n\\t\\t\\t\\t\\tvar flatSize = dstOffset + nPlanes * 4,\\n\\t\\t\\t\\t\\t\\tviewMatrix = camera.matrixWorldInverse;\\n\\n\\t\\t\\t\\t\\tviewNormalMatrix.getNormalMatrix( viewMatrix );\\n\\n\\t\\t\\t\\t\\tif ( dstArray === null || dstArray.length < flatSize ) {\\n\\n\\t\\t\\t\\t\\t\\tdstArray = new Float32Array( flatSize );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, i4 = dstOffset; i !== nPlanes; ++ i, i4 += 4 ) {\\n\\n\\t\\t\\t\\t\\t\\tplane.copy( planes[ i ] ).applyMatrix4( viewMatrix, viewNormalMatrix );\\n\\n\\t\\t\\t\\t\\t\\tplane.normal.toArray( dstArray, i4 );\\n\\t\\t\\t\\t\\t\\tdstArray[ i4 + 3 ] = plane.constant;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tuniform.value = dstArray;\\n\\t\\t\\t\\tuniform.needsUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tscope.numPlanes = nPlanes;\\n\\n\\t\\t\\treturn dstArray;\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author thespite / http://www.twitter.com/thespite\\n\\t */\\n\\n\\tfunction WebGLUtils( gl, extensions ) {\\n\\n\\t\\tfunction convert( p ) {\\n\\n\\t\\t\\tvar extension;\\n\\n\\t\\t\\tif ( p === RepeatWrapping ) return gl.REPEAT;\\n\\t\\t\\tif ( p === ClampToEdgeWrapping ) return gl.CLAMP_TO_EDGE;\\n\\t\\t\\tif ( p === MirroredRepeatWrapping ) return gl.MIRRORED_REPEAT;\\n\\n\\t\\t\\tif ( p === NearestFilter ) return gl.NEAREST;\\n\\t\\t\\tif ( p === NearestMipMapNearestFilter ) return gl.NEAREST_MIPMAP_NEAREST;\\n\\t\\t\\tif ( p === NearestMipMapLinearFilter ) return gl.NEAREST_MIPMAP_LINEAR;\\n\\n\\t\\t\\tif ( p === LinearFilter ) return gl.LINEAR;\\n\\t\\t\\tif ( p === LinearMipMapNearestFilter ) return gl.LINEAR_MIPMAP_NEAREST;\\n\\t\\t\\tif ( p === LinearMipMapLinearFilter ) return gl.LINEAR_MIPMAP_LINEAR;\\n\\n\\t\\t\\tif ( p === UnsignedByteType ) return gl.UNSIGNED_BYTE;\\n\\t\\t\\tif ( p === UnsignedShort4444Type ) return gl.UNSIGNED_SHORT_4_4_4_4;\\n\\t\\t\\tif ( p === UnsignedShort5551Type ) return gl.UNSIGNED_SHORT_5_5_5_1;\\n\\t\\t\\tif ( p === UnsignedShort565Type ) return gl.UNSIGNED_SHORT_5_6_5;\\n\\n\\t\\t\\tif ( p === ByteType ) return gl.BYTE;\\n\\t\\t\\tif ( p === ShortType ) return gl.SHORT;\\n\\t\\t\\tif ( p === UnsignedShortType ) return gl.UNSIGNED_SHORT;\\n\\t\\t\\tif ( p === IntType ) return gl.INT;\\n\\t\\t\\tif ( p === UnsignedIntType ) return gl.UNSIGNED_INT;\\n\\t\\t\\tif ( p === FloatType ) return gl.FLOAT;\\n\\n\\t\\t\\tif ( p === HalfFloatType ) {\\n\\n\\t\\t\\t\\textension = extensions.get( 'OES_texture_half_float' );\\n\\n\\t\\t\\t\\tif ( extension !== null ) return extension.HALF_FLOAT_OES;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( p === AlphaFormat ) return gl.ALPHA;\\n\\t\\t\\tif ( p === RGBFormat ) return gl.RGB;\\n\\t\\t\\tif ( p === RGBAFormat ) return gl.RGBA;\\n\\t\\t\\tif ( p === LuminanceFormat ) return gl.LUMINANCE;\\n\\t\\t\\tif ( p === LuminanceAlphaFormat ) return gl.LUMINANCE_ALPHA;\\n\\t\\t\\tif ( p === DepthFormat ) return gl.DEPTH_COMPONENT;\\n\\t\\t\\tif ( p === DepthStencilFormat ) return gl.DEPTH_STENCIL;\\n\\n\\t\\t\\tif ( p === AddEquation ) return gl.FUNC_ADD;\\n\\t\\t\\tif ( p === SubtractEquation ) return gl.FUNC_SUBTRACT;\\n\\t\\t\\tif ( p === ReverseSubtractEquation ) return gl.FUNC_REVERSE_SUBTRACT;\\n\\n\\t\\t\\tif ( p === ZeroFactor ) return gl.ZERO;\\n\\t\\t\\tif ( p === OneFactor ) return gl.ONE;\\n\\t\\t\\tif ( p === SrcColorFactor ) return gl.SRC_COLOR;\\n\\t\\t\\tif ( p === OneMinusSrcColorFactor ) return gl.ONE_MINUS_SRC_COLOR;\\n\\t\\t\\tif ( p === SrcAlphaFactor ) return gl.SRC_ALPHA;\\n\\t\\t\\tif ( p === OneMinusSrcAlphaFactor ) return gl.ONE_MINUS_SRC_ALPHA;\\n\\t\\t\\tif ( p === DstAlphaFactor ) return gl.DST_ALPHA;\\n\\t\\t\\tif ( p === OneMinusDstAlphaFactor ) return gl.ONE_MINUS_DST_ALPHA;\\n\\n\\t\\t\\tif ( p === DstColorFactor ) return gl.DST_COLOR;\\n\\t\\t\\tif ( p === OneMinusDstColorFactor ) return gl.ONE_MINUS_DST_COLOR;\\n\\t\\t\\tif ( p === SrcAlphaSaturateFactor ) return gl.SRC_ALPHA_SATURATE;\\n\\n\\t\\t\\tif ( p === RGB_S3TC_DXT1_Format || p === RGBA_S3TC_DXT1_Format ||\\n\\t\\t\\t\\tp === RGBA_S3TC_DXT3_Format || p === RGBA_S3TC_DXT5_Format ) {\\n\\n\\t\\t\\t\\textension = extensions.get( 'WEBGL_compressed_texture_s3tc' );\\n\\n\\t\\t\\t\\tif ( extension !== null ) {\\n\\n\\t\\t\\t\\t\\tif ( p === RGB_S3TC_DXT1_Format ) return extension.COMPRESSED_RGB_S3TC_DXT1_EXT;\\n\\t\\t\\t\\t\\tif ( p === RGBA_S3TC_DXT1_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT1_EXT;\\n\\t\\t\\t\\t\\tif ( p === RGBA_S3TC_DXT3_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT3_EXT;\\n\\t\\t\\t\\t\\tif ( p === RGBA_S3TC_DXT5_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT5_EXT;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( p === RGB_PVRTC_4BPPV1_Format || p === RGB_PVRTC_2BPPV1_Format ||\\n\\t\\t\\t\\tp === RGBA_PVRTC_4BPPV1_Format || p === RGBA_PVRTC_2BPPV1_Format ) {\\n\\n\\t\\t\\t\\textension = extensions.get( 'WEBGL_compressed_texture_pvrtc' );\\n\\n\\t\\t\\t\\tif ( extension !== null ) {\\n\\n\\t\\t\\t\\t\\tif ( p === RGB_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;\\n\\t\\t\\t\\t\\tif ( p === RGB_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;\\n\\t\\t\\t\\t\\tif ( p === RGBA_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;\\n\\t\\t\\t\\t\\tif ( p === RGBA_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( p === RGB_ETC1_Format ) {\\n\\n\\t\\t\\t\\textension = extensions.get( 'WEBGL_compressed_texture_etc1' );\\n\\n\\t\\t\\t\\tif ( extension !== null ) return extension.COMPRESSED_RGB_ETC1_WEBGL;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( p === MinEquation || p === MaxEquation ) {\\n\\n\\t\\t\\t\\textension = extensions.get( 'EXT_blend_minmax' );\\n\\n\\t\\t\\t\\tif ( extension !== null ) {\\n\\n\\t\\t\\t\\t\\tif ( p === MinEquation ) return extension.MIN_EXT;\\n\\t\\t\\t\\t\\tif ( p === MaxEquation ) return extension.MAX_EXT;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( p === UnsignedInt248Type ) {\\n\\n\\t\\t\\t\\textension = extensions.get( 'WEBGL_depth_texture' );\\n\\n\\t\\t\\t\\tif ( extension !== null ) return extension.UNSIGNED_INT_24_8_WEBGL;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn 0;\\n\\n\\t\\t}\\n\\n\\t\\treturn { convert: convert };\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author supereggbert / http://www.paulbrunt.co.uk/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author szimek / https://github.com/szimek/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction WebGLRenderer( parameters ) {\\n\\n\\t\\tconsole.log( 'THREE.WebGLRenderer', REVISION );\\n\\n\\t\\tparameters = parameters || {};\\n\\n\\t\\tvar _canvas = parameters.canvas !== undefined ? parameters.canvas : document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' ),\\n\\t\\t\\t_context = parameters.context !== undefined ? parameters.context : null,\\n\\n\\t\\t\\t_alpha = parameters.alpha !== undefined ? parameters.alpha : false,\\n\\t\\t\\t_depth = parameters.depth !== undefined ? parameters.depth : true,\\n\\t\\t\\t_stencil = parameters.stencil !== undefined ? parameters.stencil : true,\\n\\t\\t\\t_antialias = parameters.antialias !== undefined ? parameters.antialias : false,\\n\\t\\t\\t_premultipliedAlpha = parameters.premultipliedAlpha !== undefined ? parameters.premultipliedAlpha : true,\\n\\t\\t\\t_preserveDrawingBuffer = parameters.preserveDrawingBuffer !== undefined ? parameters.preserveDrawingBuffer : false,\\n\\t\\t\\t_powerPreference = parameters.powerPreference !== undefined ? parameters.powerPreference : 'default';\\n\\n\\t\\tvar lightsArray = [];\\n\\t\\tvar shadowsArray = [];\\n\\n\\t\\tvar currentRenderList = null;\\n\\n\\t\\tvar spritesArray = [];\\n\\t\\tvar flaresArray = [];\\n\\n\\t\\t// public properties\\n\\n\\t\\tthis.domElement = _canvas;\\n\\t\\tthis.context = null;\\n\\n\\t\\t// clearing\\n\\n\\t\\tthis.autoClear = true;\\n\\t\\tthis.autoClearColor = true;\\n\\t\\tthis.autoClearDepth = true;\\n\\t\\tthis.autoClearStencil = true;\\n\\n\\t\\t// scene graph\\n\\n\\t\\tthis.sortObjects = true;\\n\\n\\t\\t// user-defined clipping\\n\\n\\t\\tthis.clippingPlanes = [];\\n\\t\\tthis.localClippingEnabled = false;\\n\\n\\t\\t// physically based shading\\n\\n\\t\\tthis.gammaFactor = 2.0;\\t// for backwards compatibility\\n\\t\\tthis.gammaInput = false;\\n\\t\\tthis.gammaOutput = false;\\n\\n\\t\\t// physical lights\\n\\n\\t\\tthis.physicallyCorrectLights = false;\\n\\n\\t\\t// tone mapping\\n\\n\\t\\tthis.toneMapping = LinearToneMapping;\\n\\t\\tthis.toneMappingExposure = 1.0;\\n\\t\\tthis.toneMappingWhitePoint = 1.0;\\n\\n\\t\\t// morphs\\n\\n\\t\\tthis.maxMorphTargets = 8;\\n\\t\\tthis.maxMorphNormals = 4;\\n\\n\\t\\t// internal properties\\n\\n\\t\\tvar _this = this,\\n\\n\\t\\t\\t_isContextLost = false,\\n\\n\\t\\t\\t// internal state cache\\n\\n\\t\\t\\t_currentRenderTarget = null,\\n\\t\\t\\t_currentFramebuffer = null,\\n\\t\\t\\t_currentMaterialId = - 1,\\n\\t\\t\\t_currentGeometryProgram = '',\\n\\n\\t\\t\\t_currentCamera = null,\\n\\t\\t\\t_currentArrayCamera = null,\\n\\n\\t\\t\\t_currentViewport = new Vector4(),\\n\\t\\t\\t_currentScissor = new Vector4(),\\n\\t\\t\\t_currentScissorTest = null,\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\t_usedTextureUnits = 0,\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\t_width = _canvas.width,\\n\\t\\t\\t_height = _canvas.height,\\n\\n\\t\\t\\t_pixelRatio = 1,\\n\\n\\t\\t\\t_viewport = new Vector4( 0, 0, _width, _height ),\\n\\t\\t\\t_scissor = new Vector4( 0, 0, _width, _height ),\\n\\t\\t\\t_scissorTest = false,\\n\\n\\t\\t\\t// frustum\\n\\n\\t\\t\\t_frustum = new Frustum(),\\n\\n\\t\\t\\t// clipping\\n\\n\\t\\t\\t_clipping = new WebGLClipping(),\\n\\t\\t\\t_clippingEnabled = false,\\n\\t\\t\\t_localClippingEnabled = false,\\n\\n\\t\\t\\t// camera matrices cache\\n\\n\\t\\t\\t_projScreenMatrix = new Matrix4(),\\n\\n\\t\\t\\t_vector3 = new Vector3(),\\n\\n\\t\\t\\t// info\\n\\n\\t\\t\\t_infoMemory = {\\n\\t\\t\\t\\tgeometries: 0,\\n\\t\\t\\t\\ttextures: 0\\n\\t\\t\\t},\\n\\n\\t\\t\\t_infoRender = {\\n\\n\\t\\t\\t\\tframe: 0,\\n\\t\\t\\t\\tcalls: 0,\\n\\t\\t\\t\\tvertices: 0,\\n\\t\\t\\t\\tfaces: 0,\\n\\t\\t\\t\\tpoints: 0\\n\\n\\t\\t\\t};\\n\\n\\t\\tthis.info = {\\n\\n\\t\\t\\trender: _infoRender,\\n\\t\\t\\tmemory: _infoMemory,\\n\\t\\t\\tprograms: null\\n\\n\\t\\t};\\n\\n\\t\\tfunction getTargetPixelRatio() {\\n\\n\\t\\t\\treturn _currentRenderTarget === null ? _pixelRatio : 1;\\n\\n\\t\\t}\\n\\n\\t\\t// initialize\\n\\n\\t\\tvar _gl;\\n\\n\\t\\ttry {\\n\\n\\t\\t\\tvar contextAttributes = {\\n\\t\\t\\t\\talpha: _alpha,\\n\\t\\t\\t\\tdepth: _depth,\\n\\t\\t\\t\\tstencil: _stencil,\\n\\t\\t\\t\\tantialias: _antialias,\\n\\t\\t\\t\\tpremultipliedAlpha: _premultipliedAlpha,\\n\\t\\t\\t\\tpreserveDrawingBuffer: _preserveDrawingBuffer,\\n\\t\\t\\t\\tpowerPreference: _powerPreference\\n\\t\\t\\t};\\n\\n\\t\\t\\t// event listeners must be registered before WebGL context is created, see #12753\\n\\n\\t\\t\\t_canvas.addEventListener( 'webglcontextlost', onContextLost, false );\\n\\t\\t\\t_canvas.addEventListener( 'webglcontextrestored', onContextRestore, false );\\n\\n\\t\\t\\t_gl = _context || _canvas.getContext( 'webgl', contextAttributes ) || _canvas.getContext( 'experimental-webgl', contextAttributes );\\n\\n\\t\\t\\tif ( _gl === null ) {\\n\\n\\t\\t\\t\\tif ( _canvas.getContext( 'webgl' ) !== null ) {\\n\\n\\t\\t\\t\\t\\tthrow new Error( 'Error creating WebGL context with your selected attributes.' );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthrow new Error( 'Error creating WebGL context.' );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Some experimental-webgl implementations do not have getShaderPrecisionFormat\\n\\n\\t\\t\\tif ( _gl.getShaderPrecisionFormat === undefined ) {\\n\\n\\t\\t\\t\\t_gl.getShaderPrecisionFormat = function () {\\n\\n\\t\\t\\t\\t\\treturn { 'rangeMin': 1, 'rangeMax': 1, 'precision': 1 };\\n\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t} catch ( error ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.WebGLRenderer: ' + error.message );\\n\\n\\t\\t}\\n\\n\\t\\tvar extensions, capabilities, state;\\n\\t\\tvar properties, textures, attributes, geometries, objects, lights;\\n\\t\\tvar programCache, renderLists;\\n\\n\\t\\tvar background, morphtargets, bufferRenderer, indexedBufferRenderer;\\n\\t\\tvar flareRenderer, spriteRenderer;\\n\\n\\t\\tvar utils;\\n\\n\\t\\tfunction initGLContext() {\\n\\n\\t\\t\\textensions = new WebGLExtensions( _gl );\\n\\t\\t\\textensions.get( 'WEBGL_depth_texture' );\\n\\t\\t\\textensions.get( 'OES_texture_float' );\\n\\t\\t\\textensions.get( 'OES_texture_float_linear' );\\n\\t\\t\\textensions.get( 'OES_texture_half_float' );\\n\\t\\t\\textensions.get( 'OES_texture_half_float_linear' );\\n\\t\\t\\textensions.get( 'OES_standard_derivatives' );\\n\\t\\t\\textensions.get( 'OES_element_index_uint' );\\n\\t\\t\\textensions.get( 'ANGLE_instanced_arrays' );\\n\\n\\t\\t\\tutils = new WebGLUtils( _gl, extensions );\\n\\n\\t\\t\\tcapabilities = new WebGLCapabilities( _gl, extensions, parameters );\\n\\n\\t\\t\\tstate = new WebGLState( _gl, extensions, utils );\\n\\t\\t\\tstate.scissor( _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ) );\\n\\t\\t\\tstate.viewport( _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ) );\\n\\n\\t\\t\\tproperties = new WebGLProperties();\\n\\t\\t\\ttextures = new WebGLTextures( _gl, extensions, state, properties, capabilities, utils, _infoMemory );\\n\\t\\t\\tattributes = new WebGLAttributes( _gl );\\n\\t\\t\\tgeometries = new WebGLGeometries( _gl, attributes, _infoMemory );\\n\\t\\t\\tobjects = new WebGLObjects( geometries, _infoRender );\\n\\t\\t\\tmorphtargets = new WebGLMorphtargets( _gl );\\n\\t\\t\\tprogramCache = new WebGLPrograms( _this, extensions, capabilities );\\n\\t\\t\\tlights = new WebGLLights();\\n\\t\\t\\trenderLists = new WebGLRenderLists();\\n\\n\\t\\t\\tbackground = new WebGLBackground( _this, state, geometries, _premultipliedAlpha );\\n\\n\\t\\t\\tbufferRenderer = new WebGLBufferRenderer( _gl, extensions, _infoRender );\\n\\t\\t\\tindexedBufferRenderer = new WebGLIndexedBufferRenderer( _gl, extensions, _infoRender );\\n\\n\\t\\t\\tflareRenderer = new WebGLFlareRenderer( _this, _gl, state, textures, capabilities );\\n\\t\\t\\tspriteRenderer = new WebGLSpriteRenderer( _this, _gl, state, textures, capabilities );\\n\\n\\t\\t\\t_this.info.programs = programCache.programs;\\n\\n\\t\\t\\t_this.context = _gl;\\n\\t\\t\\t_this.capabilities = capabilities;\\n\\t\\t\\t_this.extensions = extensions;\\n\\t\\t\\t_this.properties = properties;\\n\\t\\t\\t_this.renderLists = renderLists;\\n\\t\\t\\t_this.state = state;\\n\\n\\t\\t}\\n\\n\\t\\tinitGLContext();\\n\\n\\t\\t// vr\\n\\n\\t\\tvar vr = new WebVRManager( _this );\\n\\n\\t\\tthis.vr = vr;\\n\\n\\t\\t// shadow map\\n\\n\\t\\tvar shadowMap = new WebGLShadowMap( _this, objects, capabilities.maxTextureSize );\\n\\n\\t\\tthis.shadowMap = shadowMap;\\n\\n\\t\\t// API\\n\\n\\t\\tthis.getContext = function () {\\n\\n\\t\\t\\treturn _gl;\\n\\n\\t\\t};\\n\\n\\t\\tthis.getContextAttributes = function () {\\n\\n\\t\\t\\treturn _gl.getContextAttributes();\\n\\n\\t\\t};\\n\\n\\t\\tthis.forceContextLoss = function () {\\n\\n\\t\\t\\tvar extension = extensions.get( 'WEBGL_lose_context' );\\n\\t\\t\\tif ( extension ) extension.loseContext();\\n\\n\\t\\t};\\n\\n\\t\\tthis.forceContextRestore = function () {\\n\\n\\t\\t\\tvar extension = extensions.get( 'WEBGL_lose_context' );\\n\\t\\t\\tif ( extension ) extension.restoreContext();\\n\\n\\t\\t};\\n\\n\\t\\tthis.getPixelRatio = function () {\\n\\n\\t\\t\\treturn _pixelRatio;\\n\\n\\t\\t};\\n\\n\\t\\tthis.setPixelRatio = function ( value ) {\\n\\n\\t\\t\\tif ( value === undefined ) return;\\n\\n\\t\\t\\t_pixelRatio = value;\\n\\n\\t\\t\\tthis.setSize( _width, _height, false );\\n\\n\\t\\t};\\n\\n\\t\\tthis.getSize = function () {\\n\\n\\t\\t\\treturn {\\n\\t\\t\\t\\twidth: _width,\\n\\t\\t\\t\\theight: _height\\n\\t\\t\\t};\\n\\n\\t\\t};\\n\\n\\t\\tthis.setSize = function ( width, height, updateStyle ) {\\n\\n\\t\\t\\tvar device = vr.getDevice();\\n\\n\\t\\t\\tif ( device && device.isPresenting ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Can\\\\'t change size while VR device is presenting.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t_width = width;\\n\\t\\t\\t_height = height;\\n\\n\\t\\t\\t_canvas.width = width * _pixelRatio;\\n\\t\\t\\t_canvas.height = height * _pixelRatio;\\n\\n\\t\\t\\tif ( updateStyle !== false ) {\\n\\n\\t\\t\\t\\t_canvas.style.width = width + 'px';\\n\\t\\t\\t\\t_canvas.style.height = height + 'px';\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.setViewport( 0, 0, width, height );\\n\\n\\t\\t};\\n\\n\\t\\tthis.getDrawingBufferSize = function () {\\n\\n\\t\\t\\treturn {\\n\\t\\t\\t\\twidth: _width * _pixelRatio,\\n\\t\\t\\t\\theight: _height * _pixelRatio\\n\\t\\t\\t};\\n\\n\\t\\t};\\n\\n\\t\\tthis.setDrawingBufferSize = function ( width, height, pixelRatio ) {\\n\\n\\t\\t\\t_width = width;\\n\\t\\t\\t_height = height;\\n\\n\\t\\t\\t_pixelRatio = pixelRatio;\\n\\n\\t\\t\\t_canvas.width = width * pixelRatio;\\n\\t\\t\\t_canvas.height = height * pixelRatio;\\n\\n\\t\\t\\tthis.setViewport( 0, 0, width, height );\\n\\n\\t\\t};\\n\\n\\t\\tthis.setViewport = function ( x, y, width, height ) {\\n\\n\\t\\t\\t_viewport.set( x, _height - y - height, width, height );\\n\\t\\t\\tstate.viewport( _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ) );\\n\\n\\t\\t};\\n\\n\\t\\tthis.setScissor = function ( x, y, width, height ) {\\n\\n\\t\\t\\t_scissor.set( x, _height - y - height, width, height );\\n\\t\\t\\tstate.scissor( _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ) );\\n\\n\\t\\t};\\n\\n\\t\\tthis.setScissorTest = function ( boolean ) {\\n\\n\\t\\t\\tstate.setScissorTest( _scissorTest = boolean );\\n\\n\\t\\t};\\n\\n\\t\\t// Clearing\\n\\n\\t\\tthis.getClearColor = function () {\\n\\n\\t\\t\\treturn background.getClearColor();\\n\\n\\t\\t};\\n\\n\\t\\tthis.setClearColor = function () {\\n\\n\\t\\t\\tbackground.setClearColor.apply( background, arguments );\\n\\n\\t\\t};\\n\\n\\t\\tthis.getClearAlpha = function () {\\n\\n\\t\\t\\treturn background.getClearAlpha();\\n\\n\\t\\t};\\n\\n\\t\\tthis.setClearAlpha = function () {\\n\\n\\t\\t\\tbackground.setClearAlpha.apply( background, arguments );\\n\\n\\t\\t};\\n\\n\\t\\tthis.clear = function ( color, depth, stencil ) {\\n\\n\\t\\t\\tvar bits = 0;\\n\\n\\t\\t\\tif ( color === undefined || color ) bits |= _gl.COLOR_BUFFER_BIT;\\n\\t\\t\\tif ( depth === undefined || depth ) bits |= _gl.DEPTH_BUFFER_BIT;\\n\\t\\t\\tif ( stencil === undefined || stencil ) bits |= _gl.STENCIL_BUFFER_BIT;\\n\\n\\t\\t\\t_gl.clear( bits );\\n\\n\\t\\t};\\n\\n\\t\\tthis.clearColor = function () {\\n\\n\\t\\t\\tthis.clear( true, false, false );\\n\\n\\t\\t};\\n\\n\\t\\tthis.clearDepth = function () {\\n\\n\\t\\t\\tthis.clear( false, true, false );\\n\\n\\t\\t};\\n\\n\\t\\tthis.clearStencil = function () {\\n\\n\\t\\t\\tthis.clear( false, false, true );\\n\\n\\t\\t};\\n\\n\\t\\tthis.clearTarget = function ( renderTarget, color, depth, stencil ) {\\n\\n\\t\\t\\tthis.setRenderTarget( renderTarget );\\n\\t\\t\\tthis.clear( color, depth, stencil );\\n\\n\\t\\t};\\n\\n\\t\\t//\\n\\n\\t\\tthis.dispose = function () {\\n\\n\\t\\t\\t_canvas.removeEventListener( 'webglcontextlost', onContextLost, false );\\n\\t\\t\\t_canvas.removeEventListener( 'webglcontextrestored', onContextRestore, false );\\n\\n\\t\\t\\trenderLists.dispose();\\n\\n\\t\\t\\tvr.dispose();\\n\\n\\t\\t};\\n\\n\\t\\t// Events\\n\\n\\t\\tfunction onContextLost( event ) {\\n\\n\\t\\t\\tevent.preventDefault();\\n\\n\\t\\t\\tconsole.log( 'THREE.WebGLRenderer: Context Lost.' );\\n\\n\\t\\t\\t_isContextLost = true;\\n\\n\\t\\t}\\n\\n\\t\\tfunction onContextRestore( /* event */ ) {\\n\\n\\t\\t\\tconsole.log( 'THREE.WebGLRenderer: Context Restored.' );\\n\\n\\t\\t\\t_isContextLost = false;\\n\\n\\t\\t\\tinitGLContext();\\n\\n\\t\\t}\\n\\n\\t\\tfunction onMaterialDispose( event ) {\\n\\n\\t\\t\\tvar material = event.target;\\n\\n\\t\\t\\tmaterial.removeEventListener( 'dispose', onMaterialDispose );\\n\\n\\t\\t\\tdeallocateMaterial( material );\\n\\n\\t\\t}\\n\\n\\t\\t// Buffer deallocation\\n\\n\\t\\tfunction deallocateMaterial( material ) {\\n\\n\\t\\t\\treleaseMaterialProgramReference( material );\\n\\n\\t\\t\\tproperties.remove( material );\\n\\n\\t\\t}\\n\\n\\n\\t\\tfunction releaseMaterialProgramReference( material ) {\\n\\n\\t\\t\\tvar programInfo = properties.get( material ).program;\\n\\n\\t\\t\\tmaterial.program = undefined;\\n\\n\\t\\t\\tif ( programInfo !== undefined ) {\\n\\n\\t\\t\\t\\tprogramCache.releaseProgram( programInfo );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// Buffer rendering\\n\\n\\t\\tfunction renderObjectImmediate( object, program, material ) {\\n\\n\\t\\t\\tobject.render( function ( object ) {\\n\\n\\t\\t\\t\\t_this.renderBufferImmediate( object, program, material );\\n\\n\\t\\t\\t} );\\n\\n\\t\\t}\\n\\n\\t\\tthis.renderBufferImmediate = function ( object, program, material ) {\\n\\n\\t\\t\\tstate.initAttributes();\\n\\n\\t\\t\\tvar buffers = properties.get( object );\\n\\n\\t\\t\\tif ( object.hasPositions && ! buffers.position ) buffers.position = _gl.createBuffer();\\n\\t\\t\\tif ( object.hasNormals && ! buffers.normal ) buffers.normal = _gl.createBuffer();\\n\\t\\t\\tif ( object.hasUvs && ! buffers.uv ) buffers.uv = _gl.createBuffer();\\n\\t\\t\\tif ( object.hasColors && ! buffers.color ) buffers.color = _gl.createBuffer();\\n\\n\\t\\t\\tvar programAttributes = program.getAttributes();\\n\\n\\t\\t\\tif ( object.hasPositions ) {\\n\\n\\t\\t\\t\\t_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.position );\\n\\t\\t\\t\\t_gl.bufferData( _gl.ARRAY_BUFFER, object.positionArray, _gl.DYNAMIC_DRAW );\\n\\n\\t\\t\\t\\tstate.enableAttribute( programAttributes.position );\\n\\t\\t\\t\\t_gl.vertexAttribPointer( programAttributes.position, 3, _gl.FLOAT, false, 0, 0 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( object.hasNormals ) {\\n\\n\\t\\t\\t\\t_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.normal );\\n\\n\\t\\t\\t\\tif ( ! material.isMeshPhongMaterial &&\\n\\t\\t\\t\\t\\t! material.isMeshStandardMaterial &&\\n\\t\\t\\t\\t\\t! material.isMeshNormalMaterial &&\\n\\t\\t\\t\\t\\tmaterial.flatShading === true ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, l = object.count * 3; i < l; i += 9 ) {\\n\\n\\t\\t\\t\\t\\t\\tvar array = object.normalArray;\\n\\n\\t\\t\\t\\t\\t\\tvar nx = ( array[ i + 0 ] + array[ i + 3 ] + array[ i + 6 ] ) / 3;\\n\\t\\t\\t\\t\\t\\tvar ny = ( array[ i + 1 ] + array[ i + 4 ] + array[ i + 7 ] ) / 3;\\n\\t\\t\\t\\t\\t\\tvar nz = ( array[ i + 2 ] + array[ i + 5 ] + array[ i + 8 ] ) / 3;\\n\\n\\t\\t\\t\\t\\t\\tarray[ i + 0 ] = nx;\\n\\t\\t\\t\\t\\t\\tarray[ i + 1 ] = ny;\\n\\t\\t\\t\\t\\t\\tarray[ i + 2 ] = nz;\\n\\n\\t\\t\\t\\t\\t\\tarray[ i + 3 ] = nx;\\n\\t\\t\\t\\t\\t\\tarray[ i + 4 ] = ny;\\n\\t\\t\\t\\t\\t\\tarray[ i + 5 ] = nz;\\n\\n\\t\\t\\t\\t\\t\\tarray[ i + 6 ] = nx;\\n\\t\\t\\t\\t\\t\\tarray[ i + 7 ] = ny;\\n\\t\\t\\t\\t\\t\\tarray[ i + 8 ] = nz;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t_gl.bufferData( _gl.ARRAY_BUFFER, object.normalArray, _gl.DYNAMIC_DRAW );\\n\\n\\t\\t\\t\\tstate.enableAttribute( programAttributes.normal );\\n\\n\\t\\t\\t\\t_gl.vertexAttribPointer( programAttributes.normal, 3, _gl.FLOAT, false, 0, 0 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( object.hasUvs && material.map ) {\\n\\n\\t\\t\\t\\t_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.uv );\\n\\t\\t\\t\\t_gl.bufferData( _gl.ARRAY_BUFFER, object.uvArray, _gl.DYNAMIC_DRAW );\\n\\n\\t\\t\\t\\tstate.enableAttribute( programAttributes.uv );\\n\\n\\t\\t\\t\\t_gl.vertexAttribPointer( programAttributes.uv, 2, _gl.FLOAT, false, 0, 0 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( object.hasColors && material.vertexColors !== NoColors ) {\\n\\n\\t\\t\\t\\t_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.color );\\n\\t\\t\\t\\t_gl.bufferData( _gl.ARRAY_BUFFER, object.colorArray, _gl.DYNAMIC_DRAW );\\n\\n\\t\\t\\t\\tstate.enableAttribute( programAttributes.color );\\n\\n\\t\\t\\t\\t_gl.vertexAttribPointer( programAttributes.color, 3, _gl.FLOAT, false, 0, 0 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tstate.disableUnusedAttributes();\\n\\n\\t\\t\\t_gl.drawArrays( _gl.TRIANGLES, 0, object.count );\\n\\n\\t\\t\\tobject.count = 0;\\n\\n\\t\\t};\\n\\n\\t\\tthis.renderBufferDirect = function ( camera, fog, geometry, material, object, group ) {\\n\\n\\t\\t\\tvar frontFaceCW = ( object.isMesh && object.matrixWorld.determinant() < 0 );\\n\\n\\t\\t\\tstate.setMaterial( material, frontFaceCW );\\n\\n\\t\\t\\tvar program = setProgram( camera, fog, material, object );\\n\\t\\t\\tvar geometryProgram = geometry.id + '_' + program.id + '_' + ( material.wireframe === true );\\n\\n\\t\\t\\tvar updateBuffers = false;\\n\\n\\t\\t\\tif ( geometryProgram !== _currentGeometryProgram ) {\\n\\n\\t\\t\\t\\t_currentGeometryProgram = geometryProgram;\\n\\t\\t\\t\\tupdateBuffers = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( object.morphTargetInfluences ) {\\n\\n\\t\\t\\t\\tmorphtargets.update( object, geometry, material, program );\\n\\n\\t\\t\\t\\tupdateBuffers = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar index = geometry.index;\\n\\t\\t\\tvar position = geometry.attributes.position;\\n\\t\\t\\tvar rangeFactor = 1;\\n\\n\\t\\t\\tif ( material.wireframe === true ) {\\n\\n\\t\\t\\t\\tindex = geometries.getWireframeAttribute( geometry );\\n\\t\\t\\t\\trangeFactor = 2;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar attribute;\\n\\t\\t\\tvar renderer = bufferRenderer;\\n\\n\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\tattribute = attributes.get( index );\\n\\n\\t\\t\\t\\trenderer = indexedBufferRenderer;\\n\\t\\t\\t\\trenderer.setIndex( attribute );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( updateBuffers ) {\\n\\n\\t\\t\\t\\tsetupVertexAttributes( material, program, geometry );\\n\\n\\t\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\t\\t_gl.bindBuffer( _gl.ELEMENT_ARRAY_BUFFER, attribute.buffer );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar dataCount = 0;\\n\\n\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\tdataCount = index.count;\\n\\n\\t\\t\\t} else if ( position !== undefined ) {\\n\\n\\t\\t\\t\\tdataCount = position.count;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar rangeStart = geometry.drawRange.start * rangeFactor;\\n\\t\\t\\tvar rangeCount = geometry.drawRange.count * rangeFactor;\\n\\n\\t\\t\\tvar groupStart = group !== null ? group.start * rangeFactor : 0;\\n\\t\\t\\tvar groupCount = group !== null ? group.count * rangeFactor : Infinity;\\n\\n\\t\\t\\tvar drawStart = Math.max( rangeStart, groupStart );\\n\\t\\t\\tvar drawEnd = Math.min( dataCount, rangeStart + rangeCount, groupStart + groupCount ) - 1;\\n\\n\\t\\t\\tvar drawCount = Math.max( 0, drawEnd - drawStart + 1 );\\n\\n\\t\\t\\tif ( drawCount === 0 ) return;\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tif ( object.isMesh ) {\\n\\n\\t\\t\\t\\tif ( material.wireframe === true ) {\\n\\n\\t\\t\\t\\t\\tstate.setLineWidth( material.wireframeLinewidth * getTargetPixelRatio() );\\n\\t\\t\\t\\t\\trenderer.setMode( _gl.LINES );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tswitch ( object.drawMode ) {\\n\\n\\t\\t\\t\\t\\t\\tcase TrianglesDrawMode:\\n\\t\\t\\t\\t\\t\\t\\trenderer.setMode( _gl.TRIANGLES );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase TriangleStripDrawMode:\\n\\t\\t\\t\\t\\t\\t\\trenderer.setMode( _gl.TRIANGLE_STRIP );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase TriangleFanDrawMode:\\n\\t\\t\\t\\t\\t\\t\\trenderer.setMode( _gl.TRIANGLE_FAN );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\n\\t\\t\\t} else if ( object.isLine ) {\\n\\n\\t\\t\\t\\tvar lineWidth = material.linewidth;\\n\\n\\t\\t\\t\\tif ( lineWidth === undefined ) lineWidth = 1; // Not using Line*Material\\n\\n\\t\\t\\t\\tstate.setLineWidth( lineWidth * getTargetPixelRatio() );\\n\\n\\t\\t\\t\\tif ( object.isLineSegments ) {\\n\\n\\t\\t\\t\\t\\trenderer.setMode( _gl.LINES );\\n\\n\\t\\t\\t\\t} else if ( object.isLineLoop ) {\\n\\n\\t\\t\\t\\t\\trenderer.setMode( _gl.LINE_LOOP );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\trenderer.setMode( _gl.LINE_STRIP );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( object.isPoints ) {\\n\\n\\t\\t\\t\\trenderer.setMode( _gl.POINTS );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry && geometry.isInstancedBufferGeometry ) {\\n\\n\\t\\t\\t\\tif ( geometry.maxInstancedCount > 0 ) {\\n\\n\\t\\t\\t\\t\\trenderer.renderInstances( geometry, drawStart, drawCount );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\trenderer.render( drawStart, drawCount );\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t\\tfunction setupVertexAttributes( material, program, geometry, startIndex ) {\\n\\n\\t\\t\\tif ( geometry && geometry.isInstancedBufferGeometry ) {\\n\\n\\t\\t\\t\\tif ( extensions.get( 'ANGLE_instanced_arrays' ) === null ) {\\n\\n\\t\\t\\t\\t\\tconsole.error( 'THREE.WebGLRenderer.setupVertexAttributes: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' );\\n\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( startIndex === undefined ) startIndex = 0;\\n\\n\\t\\t\\tstate.initAttributes();\\n\\n\\t\\t\\tvar geometryAttributes = geometry.attributes;\\n\\n\\t\\t\\tvar programAttributes = program.getAttributes();\\n\\n\\t\\t\\tvar materialDefaultAttributeValues = material.defaultAttributeValues;\\n\\n\\t\\t\\tfor ( var name in programAttributes ) {\\n\\n\\t\\t\\t\\tvar programAttribute = programAttributes[ name ];\\n\\n\\t\\t\\t\\tif ( programAttribute >= 0 ) {\\n\\n\\t\\t\\t\\t\\tvar geometryAttribute = geometryAttributes[ name ];\\n\\n\\t\\t\\t\\t\\tif ( geometryAttribute !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tvar normalized = geometryAttribute.normalized;\\n\\t\\t\\t\\t\\t\\tvar size = geometryAttribute.itemSize;\\n\\n\\t\\t\\t\\t\\t\\tvar attribute = attributes.get( geometryAttribute );\\n\\n\\t\\t\\t\\t\\t\\t// TODO Attribute may not be available on context restore\\n\\n\\t\\t\\t\\t\\t\\tif ( attribute === undefined ) continue;\\n\\n\\t\\t\\t\\t\\t\\tvar buffer = attribute.buffer;\\n\\t\\t\\t\\t\\t\\tvar type = attribute.type;\\n\\t\\t\\t\\t\\t\\tvar bytesPerElement = attribute.bytesPerElement;\\n\\n\\t\\t\\t\\t\\t\\tif ( geometryAttribute.isInterleavedBufferAttribute ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar data = geometryAttribute.data;\\n\\t\\t\\t\\t\\t\\t\\tvar stride = data.stride;\\n\\t\\t\\t\\t\\t\\t\\tvar offset = geometryAttribute.offset;\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( data && data.isInstancedInterleavedBuffer ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tstate.enableAttributeAndDivisor( programAttribute, data.meshPerAttribute );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( geometry.maxInstancedCount === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgeometry.maxInstancedCount = data.meshPerAttribute * data.count;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tstate.enableAttribute( programAttribute );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t_gl.bindBuffer( _gl.ARRAY_BUFFER, buffer );\\n\\t\\t\\t\\t\\t\\t\\t_gl.vertexAttribPointer( programAttribute, size, type, normalized, stride * bytesPerElement, ( startIndex * stride + offset ) * bytesPerElement );\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( geometryAttribute.isInstancedBufferAttribute ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tstate.enableAttributeAndDivisor( programAttribute, geometryAttribute.meshPerAttribute );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( geometry.maxInstancedCount === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgeometry.maxInstancedCount = geometryAttribute.meshPerAttribute * geometryAttribute.count;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tstate.enableAttribute( programAttribute );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t_gl.bindBuffer( _gl.ARRAY_BUFFER, buffer );\\n\\t\\t\\t\\t\\t\\t\\t_gl.vertexAttribPointer( programAttribute, size, type, normalized, 0, startIndex * size * bytesPerElement );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else if ( materialDefaultAttributeValues !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tvar value = materialDefaultAttributeValues[ name ];\\n\\n\\t\\t\\t\\t\\t\\tif ( value !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tswitch ( value.length ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase 2:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t_gl.vertexAttrib2fv( programAttribute, value );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase 3:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t_gl.vertexAttrib3fv( programAttribute, value );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase 4:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t_gl.vertexAttrib4fv( programAttribute, value );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tdefault:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t_gl.vertexAttrib1fv( programAttribute, value );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tstate.disableUnusedAttributes();\\n\\n\\t\\t}\\n\\n\\t\\t// Compile\\n\\n\\t\\tthis.compile = function ( scene, camera ) {\\n\\n\\t\\t\\tlightsArray.length = 0;\\n\\t\\t\\tshadowsArray.length = 0;\\n\\n\\t\\t\\tscene.traverse( function ( object ) {\\n\\n\\t\\t\\t\\tif ( object.isLight ) {\\n\\n\\t\\t\\t\\t\\tlightsArray.push( object );\\n\\n\\t\\t\\t\\t\\tif ( object.castShadow ) {\\n\\n\\t\\t\\t\\t\\t\\tshadowsArray.push( object );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} );\\n\\n\\t\\t\\tlights.setup( lightsArray, shadowsArray, camera );\\n\\n\\t\\t\\tscene.traverse( function ( object ) {\\n\\n\\t\\t\\t\\tif ( object.material ) {\\n\\n\\t\\t\\t\\t\\tif ( Array.isArray( object.material ) ) {\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0; i < object.material.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tinitMaterial( object.material[ i ], scene.fog, object );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tinitMaterial( object.material, scene.fog, object );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} );\\n\\n\\t\\t};\\n\\n\\t\\t// Animation Loop\\n\\n\\t\\tvar isAnimating = false;\\n\\t\\tvar onAnimationFrame = null;\\n\\n\\t\\tfunction start() {\\n\\n\\t\\t\\tif ( isAnimating ) return;\\n\\n\\t\\t\\tvar device = vr.getDevice();\\n\\n\\t\\t\\tif ( device && device.isPresenting ) {\\n\\n\\t\\t\\t\\tdevice.requestAnimationFrame( loop );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\twindow.requestAnimationFrame( loop );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tisAnimating = true;\\n\\n\\t\\t}\\n\\n\\t\\tfunction loop( time ) {\\n\\n\\t\\t\\tif ( onAnimationFrame !== null ) onAnimationFrame( time );\\n\\n\\t\\t\\tvar device = vr.getDevice();\\n\\n\\t\\t\\tif ( device && device.isPresenting ) {\\n\\n\\t\\t\\t\\tdevice.requestAnimationFrame( loop );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\twindow.requestAnimationFrame( loop );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tthis.animate = function ( callback ) {\\n\\n\\t\\t\\tonAnimationFrame = callback;\\n\\t\\t\\tstart();\\n\\n\\t\\t};\\n\\n\\t\\t// Rendering\\n\\n\\t\\tthis.render = function ( scene, camera, renderTarget, forceClear ) {\\n\\n\\t\\t\\tif ( ! ( camera && camera.isCamera ) ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( _isContextLost ) return;\\n\\n\\t\\t\\t// reset caching for this frame\\n\\n\\t\\t\\t_currentGeometryProgram = '';\\n\\t\\t\\t_currentMaterialId = - 1;\\n\\t\\t\\t_currentCamera = null;\\n\\n\\t\\t\\t// update scene graph\\n\\n\\t\\t\\tif ( scene.autoUpdate === true ) scene.updateMatrixWorld();\\n\\n\\t\\t\\t// update camera matrices and frustum\\n\\n\\t\\t\\tif ( camera.parent === null ) camera.updateMatrixWorld();\\n\\n\\t\\t\\tif ( vr.enabled ) {\\n\\n\\t\\t\\t\\tcamera = vr.getCamera( camera );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t_projScreenMatrix.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse );\\n\\t\\t\\t_frustum.setFromMatrix( _projScreenMatrix );\\n\\n\\t\\t\\tlightsArray.length = 0;\\n\\t\\t\\tshadowsArray.length = 0;\\n\\n\\t\\t\\tspritesArray.length = 0;\\n\\t\\t\\tflaresArray.length = 0;\\n\\n\\t\\t\\t_localClippingEnabled = this.localClippingEnabled;\\n\\t\\t\\t_clippingEnabled = _clipping.init( this.clippingPlanes, _localClippingEnabled, camera );\\n\\n\\t\\t\\tcurrentRenderList = renderLists.get( scene, camera );\\n\\t\\t\\tcurrentRenderList.init();\\n\\n\\t\\t\\tprojectObject( scene, camera, _this.sortObjects );\\n\\n\\t\\t\\tif ( _this.sortObjects === true ) {\\n\\n\\t\\t\\t\\tcurrentRenderList.sort();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\ttextures.updateVideoTextures();\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tif ( _clippingEnabled ) _clipping.beginShadows();\\n\\n\\t\\t\\tshadowMap.render( shadowsArray, scene, camera );\\n\\n\\t\\t\\tlights.setup( lightsArray, shadowsArray, camera );\\n\\n\\t\\t\\tif ( _clippingEnabled ) _clipping.endShadows();\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\t_infoRender.frame ++;\\n\\t\\t\\t_infoRender.calls = 0;\\n\\t\\t\\t_infoRender.vertices = 0;\\n\\t\\t\\t_infoRender.faces = 0;\\n\\t\\t\\t_infoRender.points = 0;\\n\\n\\t\\t\\tif ( renderTarget === undefined ) {\\n\\n\\t\\t\\t\\trenderTarget = null;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.setRenderTarget( renderTarget );\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tbackground.render( currentRenderList, scene, camera, forceClear );\\n\\n\\t\\t\\t// render scene\\n\\n\\t\\t\\tvar opaqueObjects = currentRenderList.opaque;\\n\\t\\t\\tvar transparentObjects = currentRenderList.transparent;\\n\\n\\t\\t\\tif ( scene.overrideMaterial ) {\\n\\n\\t\\t\\t\\tvar overrideMaterial = scene.overrideMaterial;\\n\\n\\t\\t\\t\\tif ( opaqueObjects.length ) renderObjects( opaqueObjects, scene, camera, overrideMaterial );\\n\\t\\t\\t\\tif ( transparentObjects.length ) renderObjects( transparentObjects, scene, camera, overrideMaterial );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// opaque pass (front-to-back order)\\n\\n\\t\\t\\t\\tif ( opaqueObjects.length ) renderObjects( opaqueObjects, scene, camera );\\n\\n\\t\\t\\t\\t// transparent pass (back-to-front order)\\n\\n\\t\\t\\t\\tif ( transparentObjects.length ) renderObjects( transparentObjects, scene, camera );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// custom renderers\\n\\n\\t\\t\\tspriteRenderer.render( spritesArray, scene, camera );\\n\\t\\t\\tflareRenderer.render( flaresArray, scene, camera, _currentViewport );\\n\\n\\t\\t\\t// Generate mipmap if we're using any kind of mipmap filtering\\n\\n\\t\\t\\tif ( renderTarget ) {\\n\\n\\t\\t\\t\\ttextures.updateRenderTargetMipmap( renderTarget );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Ensure depth buffer writing is enabled so it can be cleared on next render\\n\\n\\t\\t\\tstate.buffers.depth.setTest( true );\\n\\t\\t\\tstate.buffers.depth.setMask( true );\\n\\t\\t\\tstate.buffers.color.setMask( true );\\n\\n\\t\\t\\tstate.setPolygonOffset( false );\\n\\n\\t\\t\\tif ( vr.enabled ) {\\n\\n\\t\\t\\t\\tvr.submitFrame();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// _gl.finish();\\n\\n\\t\\t};\\n\\n\\t\\t/*\\n\\t\\t// TODO Duplicated code (Frustum)\\n\\n\\t\\tvar _sphere = new Sphere();\\n\\n\\t\\tfunction isObjectViewable( object ) {\\n\\n\\t\\t\\tvar geometry = object.geometry;\\n\\n\\t\\t\\tif ( geometry.boundingSphere === null )\\n\\t\\t\\t\\tgeometry.computeBoundingSphere();\\n\\n\\t\\t\\t_sphere.copy( geometry.boundingSphere ).\\n\\t\\t\\tapplyMatrix4( object.matrixWorld );\\n\\n\\t\\t\\treturn isSphereViewable( _sphere );\\n\\n\\t\\t}\\n\\n\\t\\tfunction isSpriteViewable( sprite ) {\\n\\n\\t\\t\\t_sphere.center.set( 0, 0, 0 );\\n\\t\\t\\t_sphere.radius = 0.7071067811865476;\\n\\t\\t\\t_sphere.applyMatrix4( sprite.matrixWorld );\\n\\n\\t\\t\\treturn isSphereViewable( _sphere );\\n\\n\\t\\t}\\n\\n\\t\\tfunction isSphereViewable( sphere ) {\\n\\n\\t\\t\\tif ( ! _frustum.intersectsSphere( sphere ) ) return false;\\n\\n\\t\\t\\tvar numPlanes = _clipping.numPlanes;\\n\\n\\t\\t\\tif ( numPlanes === 0 ) return true;\\n\\n\\t\\t\\tvar planes = _this.clippingPlanes,\\n\\n\\t\\t\\t\\tcenter = sphere.center,\\n\\t\\t\\t\\tnegRad = - sphere.radius,\\n\\t\\t\\t\\ti = 0;\\n\\n\\t\\t\\tdo {\\n\\n\\t\\t\\t\\t// out when deeper than radius in the negative halfspace\\n\\t\\t\\t\\tif ( planes[ i ].distanceToPoint( center ) < negRad ) return false;\\n\\n\\t\\t\\t} while ( ++ i !== numPlanes );\\n\\n\\t\\t\\treturn true;\\n\\n\\t\\t}\\n\\t\\t*/\\n\\n\\t\\tfunction projectObject( object, camera, sortObjects ) {\\n\\n\\t\\t\\tif ( object.visible === false ) return;\\n\\n\\t\\t\\tvar visible = object.layers.test( camera.layers );\\n\\n\\t\\t\\tif ( visible ) {\\n\\n\\t\\t\\t\\tif ( object.isLight ) {\\n\\n\\t\\t\\t\\t\\tlightsArray.push( object );\\n\\n\\t\\t\\t\\t\\tif ( object.castShadow ) {\\n\\n\\t\\t\\t\\t\\t\\tshadowsArray.push( object );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( object.isSprite ) {\\n\\n\\t\\t\\t\\t\\tif ( ! object.frustumCulled || _frustum.intersectsSprite( object ) ) {\\n\\n\\t\\t\\t\\t\\t\\tspritesArray.push( object );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( object.isLensFlare ) {\\n\\n\\t\\t\\t\\t\\tflaresArray.push( object );\\n\\n\\t\\t\\t\\t} else if ( object.isImmediateRenderObject ) {\\n\\n\\t\\t\\t\\t\\tif ( sortObjects ) {\\n\\n\\t\\t\\t\\t\\t\\t_vector3.setFromMatrixPosition( object.matrixWorld )\\n\\t\\t\\t\\t\\t\\t\\t.applyMatrix4( _projScreenMatrix );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tcurrentRenderList.push( object, null, object.material, _vector3.z, null );\\n\\n\\t\\t\\t\\t} else if ( object.isMesh || object.isLine || object.isPoints ) {\\n\\n\\t\\t\\t\\t\\tif ( object.isSkinnedMesh ) {\\n\\n\\t\\t\\t\\t\\t\\tobject.skeleton.update();\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( ! object.frustumCulled || _frustum.intersectsObject( object ) ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( sortObjects ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t_vector3.setFromMatrixPosition( object.matrixWorld )\\n\\t\\t\\t\\t\\t\\t\\t\\t.applyMatrix4( _projScreenMatrix );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tvar geometry = objects.update( object );\\n\\t\\t\\t\\t\\t\\tvar material = object.material;\\n\\n\\t\\t\\t\\t\\t\\tif ( Array.isArray( material ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar groups = geometry.groups;\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var i = 0, l = groups.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tvar group = groups[ i ];\\n\\t\\t\\t\\t\\t\\t\\t\\tvar groupMaterial = material[ group.materialIndex ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( groupMaterial && groupMaterial.visible ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcurrentRenderList.push( object, geometry, groupMaterial, _vector3.z, group );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t} else if ( material.visible ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tcurrentRenderList.push( object, geometry, material, _vector3.z, null );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar children = object.children;\\n\\n\\t\\t\\tfor ( var i = 0, l = children.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tprojectObject( children[ i ], camera, sortObjects );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction renderObjects( renderList, scene, camera, overrideMaterial ) {\\n\\n\\t\\t\\tfor ( var i = 0, l = renderList.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar renderItem = renderList[ i ];\\n\\n\\t\\t\\t\\tvar object = renderItem.object;\\n\\t\\t\\t\\tvar geometry = renderItem.geometry;\\n\\t\\t\\t\\tvar material = overrideMaterial === undefined ? renderItem.material : overrideMaterial;\\n\\t\\t\\t\\tvar group = renderItem.group;\\n\\n\\t\\t\\t\\tif ( camera.isArrayCamera ) {\\n\\n\\t\\t\\t\\t\\t_currentArrayCamera = camera;\\n\\n\\t\\t\\t\\t\\tvar cameras = camera.cameras;\\n\\n\\t\\t\\t\\t\\tfor ( var j = 0, jl = cameras.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar camera2 = cameras[ j ];\\n\\n\\t\\t\\t\\t\\t\\tif ( object.layers.test( camera2.layers ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar bounds = camera2.bounds;\\n\\n\\t\\t\\t\\t\\t\\t\\tvar x = bounds.x * _width;\\n\\t\\t\\t\\t\\t\\t\\tvar y = bounds.y * _height;\\n\\t\\t\\t\\t\\t\\t\\tvar width = bounds.z * _width;\\n\\t\\t\\t\\t\\t\\t\\tvar height = bounds.w * _height;\\n\\n\\t\\t\\t\\t\\t\\t\\tstate.viewport( _currentViewport.set( x, y, width, height ).multiplyScalar( _pixelRatio ) );\\n\\n\\t\\t\\t\\t\\t\\t\\trenderObject( object, scene, camera2, geometry, material, group );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t_currentArrayCamera = null;\\n\\n\\t\\t\\t\\t\\trenderObject( object, scene, camera, geometry, material, group );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction renderObject( object, scene, camera, geometry, material, group ) {\\n\\n\\t\\t\\tobject.onBeforeRender( _this, scene, camera, geometry, material, group );\\n\\n\\t\\t\\tobject.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, object.matrixWorld );\\n\\t\\t\\tobject.normalMatrix.getNormalMatrix( object.modelViewMatrix );\\n\\n\\t\\t\\tif ( object.isImmediateRenderObject ) {\\n\\n\\t\\t\\t\\tvar frontFaceCW = ( object.isMesh && object.matrixWorld.determinant() < 0 );\\n\\n\\t\\t\\t\\tstate.setMaterial( material, frontFaceCW );\\n\\n\\t\\t\\t\\tvar program = setProgram( camera, scene.fog, material, object );\\n\\n\\t\\t\\t\\t_currentGeometryProgram = '';\\n\\n\\t\\t\\t\\trenderObjectImmediate( object, program, material );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t_this.renderBufferDirect( camera, scene.fog, geometry, material, object, group );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tobject.onAfterRender( _this, scene, camera, geometry, material, group );\\n\\n\\t\\t}\\n\\n\\t\\tfunction initMaterial( material, fog, object ) {\\n\\n\\t\\t\\tvar materialProperties = properties.get( material );\\n\\n\\t\\t\\tvar parameters = programCache.getParameters(\\n\\t\\t\\t\\tmaterial, lights.state, shadowsArray, fog, _clipping.numPlanes, _clipping.numIntersection, object );\\n\\n\\t\\t\\tvar code = programCache.getProgramCode( material, parameters );\\n\\n\\t\\t\\tvar program = materialProperties.program;\\n\\t\\t\\tvar programChange = true;\\n\\n\\t\\t\\tif ( program === undefined ) {\\n\\n\\t\\t\\t\\t// new material\\n\\t\\t\\t\\tmaterial.addEventListener( 'dispose', onMaterialDispose );\\n\\n\\t\\t\\t} else if ( program.code !== code ) {\\n\\n\\t\\t\\t\\t// changed glsl or parameters\\n\\t\\t\\t\\treleaseMaterialProgramReference( material );\\n\\n\\t\\t\\t} else if ( parameters.shaderID !== undefined ) {\\n\\n\\t\\t\\t\\t// same glsl and uniform list\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// only rebuild uniform list\\n\\t\\t\\t\\tprogramChange = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( programChange ) {\\n\\n\\t\\t\\t\\tif ( parameters.shaderID ) {\\n\\n\\t\\t\\t\\t\\tvar shader = ShaderLib[ parameters.shaderID ];\\n\\n\\t\\t\\t\\t\\tmaterialProperties.shader = {\\n\\t\\t\\t\\t\\t\\tname: material.type,\\n\\t\\t\\t\\t\\t\\tuniforms: UniformsUtils.clone( shader.uniforms ),\\n\\t\\t\\t\\t\\t\\tvertexShader: shader.vertexShader,\\n\\t\\t\\t\\t\\t\\tfragmentShader: shader.fragmentShader\\n\\t\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tmaterialProperties.shader = {\\n\\t\\t\\t\\t\\t\\tname: material.type,\\n\\t\\t\\t\\t\\t\\tuniforms: material.uniforms,\\n\\t\\t\\t\\t\\t\\tvertexShader: material.vertexShader,\\n\\t\\t\\t\\t\\t\\tfragmentShader: material.fragmentShader\\n\\t\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tmaterial.onBeforeCompile( materialProperties.shader );\\n\\n\\t\\t\\t\\tprogram = programCache.acquireProgram( material, materialProperties.shader, parameters, code );\\n\\n\\t\\t\\t\\tmaterialProperties.program = program;\\n\\t\\t\\t\\tmaterial.program = program;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar programAttributes = program.getAttributes();\\n\\n\\t\\t\\tif ( material.morphTargets ) {\\n\\n\\t\\t\\t\\tmaterial.numSupportedMorphTargets = 0;\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < _this.maxMorphTargets; i ++ ) {\\n\\n\\t\\t\\t\\t\\tif ( programAttributes[ 'morphTarget' + i ] >= 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tmaterial.numSupportedMorphTargets ++;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.morphNormals ) {\\n\\n\\t\\t\\t\\tmaterial.numSupportedMorphNormals = 0;\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < _this.maxMorphNormals; i ++ ) {\\n\\n\\t\\t\\t\\t\\tif ( programAttributes[ 'morphNormal' + i ] >= 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tmaterial.numSupportedMorphNormals ++;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar uniforms = materialProperties.shader.uniforms;\\n\\n\\t\\t\\tif ( ! material.isShaderMaterial &&\\n\\t\\t\\t\\t! material.isRawShaderMaterial ||\\n\\t\\t\\t\\tmaterial.clipping === true ) {\\n\\n\\t\\t\\t\\tmaterialProperties.numClippingPlanes = _clipping.numPlanes;\\n\\t\\t\\t\\tmaterialProperties.numIntersection = _clipping.numIntersection;\\n\\t\\t\\t\\tuniforms.clippingPlanes = _clipping.uniform;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tmaterialProperties.fog = fog;\\n\\n\\t\\t\\t// store the light setup it was created for\\n\\n\\t\\t\\tmaterialProperties.lightsHash = lights.state.hash;\\n\\n\\t\\t\\tif ( material.lights ) {\\n\\n\\t\\t\\t\\t// wire up the material to this renderer's lighting state\\n\\n\\t\\t\\t\\tuniforms.ambientLightColor.value = lights.state.ambient;\\n\\t\\t\\t\\tuniforms.directionalLights.value = lights.state.directional;\\n\\t\\t\\t\\tuniforms.spotLights.value = lights.state.spot;\\n\\t\\t\\t\\tuniforms.rectAreaLights.value = lights.state.rectArea;\\n\\t\\t\\t\\tuniforms.pointLights.value = lights.state.point;\\n\\t\\t\\t\\tuniforms.hemisphereLights.value = lights.state.hemi;\\n\\n\\t\\t\\t\\tuniforms.directionalShadowMap.value = lights.state.directionalShadowMap;\\n\\t\\t\\t\\tuniforms.directionalShadowMatrix.value = lights.state.directionalShadowMatrix;\\n\\t\\t\\t\\tuniforms.spotShadowMap.value = lights.state.spotShadowMap;\\n\\t\\t\\t\\tuniforms.spotShadowMatrix.value = lights.state.spotShadowMatrix;\\n\\t\\t\\t\\tuniforms.pointShadowMap.value = lights.state.pointShadowMap;\\n\\t\\t\\t\\tuniforms.pointShadowMatrix.value = lights.state.pointShadowMatrix;\\n\\t\\t\\t\\t// TODO (abelnation): add area lights shadow info to uniforms\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar progUniforms = materialProperties.program.getUniforms(),\\n\\t\\t\\t\\tuniformsList =\\n\\t\\t\\t\\t\\tWebGLUniforms.seqWithValue( progUniforms.seq, uniforms );\\n\\n\\t\\t\\tmaterialProperties.uniformsList = uniformsList;\\n\\n\\t\\t}\\n\\n\\t\\tfunction setProgram( camera, fog, material, object ) {\\n\\n\\t\\t\\t_usedTextureUnits = 0;\\n\\n\\t\\t\\tvar materialProperties = properties.get( material );\\n\\n\\t\\t\\tif ( _clippingEnabled ) {\\n\\n\\t\\t\\t\\tif ( _localClippingEnabled || camera !== _currentCamera ) {\\n\\n\\t\\t\\t\\t\\tvar useCache =\\n\\t\\t\\t\\t\\t\\tcamera === _currentCamera &&\\n\\t\\t\\t\\t\\t\\tmaterial.id === _currentMaterialId;\\n\\n\\t\\t\\t\\t\\t// we might want to call this function with some ClippingGroup\\n\\t\\t\\t\\t\\t// object instead of the material, once it becomes feasible\\n\\t\\t\\t\\t\\t// (#8465, #8379)\\n\\t\\t\\t\\t\\t_clipping.setState(\\n\\t\\t\\t\\t\\t\\tmaterial.clippingPlanes, material.clipIntersection, material.clipShadows,\\n\\t\\t\\t\\t\\t\\tcamera, materialProperties, useCache );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.needsUpdate === false ) {\\n\\n\\t\\t\\t\\tif ( materialProperties.program === undefined ) {\\n\\n\\t\\t\\t\\t\\tmaterial.needsUpdate = true;\\n\\n\\t\\t\\t\\t} else if ( material.fog && materialProperties.fog !== fog ) {\\n\\n\\t\\t\\t\\t\\tmaterial.needsUpdate = true;\\n\\n\\t\\t\\t\\t} else if ( material.lights && materialProperties.lightsHash !== lights.state.hash ) {\\n\\n\\t\\t\\t\\t\\tmaterial.needsUpdate = true;\\n\\n\\t\\t\\t\\t} else if ( materialProperties.numClippingPlanes !== undefined &&\\n\\t\\t\\t\\t\\t( materialProperties.numClippingPlanes !== _clipping.numPlanes ||\\n\\t\\t\\t\\t\\tmaterialProperties.numIntersection !== _clipping.numIntersection ) ) {\\n\\n\\t\\t\\t\\t\\tmaterial.needsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.needsUpdate ) {\\n\\n\\t\\t\\t\\tinitMaterial( material, fog, object );\\n\\t\\t\\t\\tmaterial.needsUpdate = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar refreshProgram = false;\\n\\t\\t\\tvar refreshMaterial = false;\\n\\t\\t\\tvar refreshLights = false;\\n\\n\\t\\t\\tvar program = materialProperties.program,\\n\\t\\t\\t\\tp_uniforms = program.getUniforms(),\\n\\t\\t\\t\\tm_uniforms = materialProperties.shader.uniforms;\\n\\n\\t\\t\\tif ( state.useProgram( program.program ) ) {\\n\\n\\t\\t\\t\\trefreshProgram = true;\\n\\t\\t\\t\\trefreshMaterial = true;\\n\\t\\t\\t\\trefreshLights = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.id !== _currentMaterialId ) {\\n\\n\\t\\t\\t\\t_currentMaterialId = material.id;\\n\\n\\t\\t\\t\\trefreshMaterial = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( refreshProgram || camera !== _currentCamera ) {\\n\\n\\t\\t\\t\\tp_uniforms.setValue( _gl, 'projectionMatrix', camera.projectionMatrix );\\n\\n\\t\\t\\t\\tif ( capabilities.logarithmicDepthBuffer ) {\\n\\n\\t\\t\\t\\t\\tp_uniforms.setValue( _gl, 'logDepthBufFC',\\n\\t\\t\\t\\t\\t\\t2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// Avoid unneeded uniform updates per ArrayCamera's sub-camera\\n\\n\\t\\t\\t\\tif ( _currentCamera !== ( _currentArrayCamera || camera ) ) {\\n\\n\\t\\t\\t\\t\\t_currentCamera = ( _currentArrayCamera || camera );\\n\\n\\t\\t\\t\\t\\t// lighting uniforms depend on the camera so enforce an update\\n\\t\\t\\t\\t\\t// now, in case this material supports lights - or later, when\\n\\t\\t\\t\\t\\t// the next material that does gets activated:\\n\\n\\t\\t\\t\\t\\trefreshMaterial = true;\\t\\t// set to true on material change\\n\\t\\t\\t\\t\\trefreshLights = true;\\t\\t// remains set until update done\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// load material specific uniforms\\n\\t\\t\\t\\t// (shader material also gets them for the sake of genericity)\\n\\n\\t\\t\\t\\tif ( material.isShaderMaterial ||\\n\\t\\t\\t\\t\\tmaterial.isMeshPhongMaterial ||\\n\\t\\t\\t\\t\\tmaterial.isMeshStandardMaterial ||\\n\\t\\t\\t\\t\\tmaterial.envMap ) {\\n\\n\\t\\t\\t\\t\\tvar uCamPos = p_uniforms.map.cameraPosition;\\n\\n\\t\\t\\t\\t\\tif ( uCamPos !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tuCamPos.setValue( _gl,\\n\\t\\t\\t\\t\\t\\t\\t_vector3.setFromMatrixPosition( camera.matrixWorld ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( material.isMeshPhongMaterial ||\\n\\t\\t\\t\\t\\tmaterial.isMeshLambertMaterial ||\\n\\t\\t\\t\\t\\tmaterial.isMeshBasicMaterial ||\\n\\t\\t\\t\\t\\tmaterial.isMeshStandardMaterial ||\\n\\t\\t\\t\\t\\tmaterial.isShaderMaterial ||\\n\\t\\t\\t\\t\\tmaterial.skinning ) {\\n\\n\\t\\t\\t\\t\\tp_uniforms.setValue( _gl, 'viewMatrix', camera.matrixWorldInverse );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// skinning uniforms must be set even if material didn't change\\n\\t\\t\\t// auto-setting of texture unit for bone texture must go before other textures\\n\\t\\t\\t// not sure why, but otherwise weird things happen\\n\\n\\t\\t\\tif ( material.skinning ) {\\n\\n\\t\\t\\t\\tp_uniforms.setOptional( _gl, object, 'bindMatrix' );\\n\\t\\t\\t\\tp_uniforms.setOptional( _gl, object, 'bindMatrixInverse' );\\n\\n\\t\\t\\t\\tvar skeleton = object.skeleton;\\n\\n\\t\\t\\t\\tif ( skeleton ) {\\n\\n\\t\\t\\t\\t\\tvar bones = skeleton.bones;\\n\\n\\t\\t\\t\\t\\tif ( capabilities.floatVertexTextures ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( skeleton.boneTexture === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// layout (1 matrix = 4 pixels)\\n\\t\\t\\t\\t\\t\\t\\t// RGBA RGBA RGBA RGBA (=> column1, column2, column3, column4)\\n\\t\\t\\t\\t\\t\\t\\t// with 8x8 pixel texture max 16 bones * 4 pixels = (8 * 8)\\n\\t\\t\\t\\t\\t\\t\\t// 16x16 pixel texture max 64 bones * 4 pixels = (16 * 16)\\n\\t\\t\\t\\t\\t\\t\\t// 32x32 pixel texture max 256 bones * 4 pixels = (32 * 32)\\n\\t\\t\\t\\t\\t\\t\\t// 64x64 pixel texture max 1024 bones * 4 pixels = (64 * 64)\\n\\n\\n\\t\\t\\t\\t\\t\\t\\tvar size = Math.sqrt( bones.length * 4 ); // 4 pixels needed for 1 matrix\\n\\t\\t\\t\\t\\t\\t\\tsize = _Math.ceilPowerOfTwo( size );\\n\\t\\t\\t\\t\\t\\t\\tsize = Math.max( size, 4 );\\n\\n\\t\\t\\t\\t\\t\\t\\tvar boneMatrices = new Float32Array( size * size * 4 ); // 4 floats per RGBA pixel\\n\\t\\t\\t\\t\\t\\t\\tboneMatrices.set( skeleton.boneMatrices ); // copy current values\\n\\n\\t\\t\\t\\t\\t\\t\\tvar boneTexture = new DataTexture( boneMatrices, size, size, RGBAFormat, FloatType );\\n\\n\\t\\t\\t\\t\\t\\t\\tskeleton.boneMatrices = boneMatrices;\\n\\t\\t\\t\\t\\t\\t\\tskeleton.boneTexture = boneTexture;\\n\\t\\t\\t\\t\\t\\t\\tskeleton.boneTextureSize = size;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tp_uniforms.setValue( _gl, 'boneTexture', skeleton.boneTexture );\\n\\t\\t\\t\\t\\t\\tp_uniforms.setValue( _gl, 'boneTextureSize', skeleton.boneTextureSize );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tp_uniforms.setOptional( _gl, skeleton, 'boneMatrices' );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( refreshMaterial ) {\\n\\n\\t\\t\\t\\tp_uniforms.setValue( _gl, 'toneMappingExposure', _this.toneMappingExposure );\\n\\t\\t\\t\\tp_uniforms.setValue( _gl, 'toneMappingWhitePoint', _this.toneMappingWhitePoint );\\n\\n\\t\\t\\t\\tif ( material.lights ) {\\n\\n\\t\\t\\t\\t\\t// the current material requires lighting info\\n\\n\\t\\t\\t\\t\\t// note: all lighting uniforms are always set correctly\\n\\t\\t\\t\\t\\t// they simply reference the renderer's state for their\\n\\t\\t\\t\\t\\t// values\\n\\t\\t\\t\\t\\t//\\n\\t\\t\\t\\t\\t// use the current material's .needsUpdate flags to set\\n\\t\\t\\t\\t\\t// the GL state when required\\n\\n\\t\\t\\t\\t\\tmarkUniformsLightsNeedsUpdate( m_uniforms, refreshLights );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// refresh uniforms common to several materials\\n\\n\\t\\t\\t\\tif ( fog && material.fog ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsFog( m_uniforms, fog );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( material.isMeshBasicMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsCommon( m_uniforms, material );\\n\\n\\t\\t\\t\\t} else if ( material.isMeshLambertMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsCommon( m_uniforms, material );\\n\\t\\t\\t\\t\\trefreshUniformsLambert( m_uniforms, material );\\n\\n\\t\\t\\t\\t} else if ( material.isMeshPhongMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsCommon( m_uniforms, material );\\n\\n\\t\\t\\t\\t\\tif ( material.isMeshToonMaterial ) {\\n\\n\\t\\t\\t\\t\\t\\trefreshUniformsToon( m_uniforms, material );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\trefreshUniformsPhong( m_uniforms, material );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( material.isMeshStandardMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsCommon( m_uniforms, material );\\n\\n\\t\\t\\t\\t\\tif ( material.isMeshPhysicalMaterial ) {\\n\\n\\t\\t\\t\\t\\t\\trefreshUniformsPhysical( m_uniforms, material );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\trefreshUniformsStandard( m_uniforms, material );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( material.isMeshDepthMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsCommon( m_uniforms, material );\\n\\t\\t\\t\\t\\trefreshUniformsDepth( m_uniforms, material );\\n\\n\\t\\t\\t\\t} else if ( material.isMeshDistanceMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsCommon( m_uniforms, material );\\n\\t\\t\\t\\t\\trefreshUniformsDistance( m_uniforms, material );\\n\\n\\t\\t\\t\\t} else if ( material.isMeshNormalMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsCommon( m_uniforms, material );\\n\\t\\t\\t\\t\\trefreshUniformsNormal( m_uniforms, material );\\n\\n\\t\\t\\t\\t} else if ( material.isLineBasicMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsLine( m_uniforms, material );\\n\\n\\t\\t\\t\\t\\tif ( material.isLineDashedMaterial ) {\\n\\n\\t\\t\\t\\t\\t\\trefreshUniformsDash( m_uniforms, material );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( material.isPointsMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsPoints( m_uniforms, material );\\n\\n\\t\\t\\t\\t} else if ( material.isShadowMaterial ) {\\n\\n\\t\\t\\t\\t\\tm_uniforms.color.value = material.color;\\n\\t\\t\\t\\t\\tm_uniforms.opacity.value = material.opacity;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// RectAreaLight Texture\\n\\t\\t\\t\\t// TODO (mrdoob): Find a nicer implementation\\n\\n\\t\\t\\t\\tif ( m_uniforms.ltcMat !== undefined ) m_uniforms.ltcMat.value = UniformsLib.LTC_MAT_TEXTURE;\\n\\t\\t\\t\\tif ( m_uniforms.ltcMag !== undefined ) m_uniforms.ltcMag.value = UniformsLib.LTC_MAG_TEXTURE;\\n\\n\\t\\t\\t\\tWebGLUniforms.upload(\\n\\t\\t\\t\\t\\t_gl, materialProperties.uniformsList, m_uniforms, _this );\\n\\n\\t\\t\\t}\\n\\n\\n\\t\\t\\t// common matrices\\n\\n\\t\\t\\tp_uniforms.setValue( _gl, 'modelViewMatrix', object.modelViewMatrix );\\n\\t\\t\\tp_uniforms.setValue( _gl, 'normalMatrix', object.normalMatrix );\\n\\t\\t\\tp_uniforms.setValue( _gl, 'modelMatrix', object.matrixWorld );\\n\\n\\t\\t\\treturn program;\\n\\n\\t\\t}\\n\\n\\t\\t// Uniforms (refresh uniforms objects)\\n\\n\\t\\tfunction refreshUniformsCommon( uniforms, material ) {\\n\\n\\t\\t\\tuniforms.opacity.value = material.opacity;\\n\\n\\t\\t\\tif ( material.color ) {\\n\\n\\t\\t\\t\\tuniforms.diffuse.value = material.color;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.emissive ) {\\n\\n\\t\\t\\t\\tuniforms.emissive.value.copy( material.emissive ).multiplyScalar( material.emissiveIntensity );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.map ) {\\n\\n\\t\\t\\t\\tuniforms.map.value = material.map;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.alphaMap ) {\\n\\n\\t\\t\\t\\tuniforms.alphaMap.value = material.alphaMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.specularMap ) {\\n\\n\\t\\t\\t\\tuniforms.specularMap.value = material.specularMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.envMap ) {\\n\\n\\t\\t\\t\\tuniforms.envMap.value = material.envMap;\\n\\n\\t\\t\\t\\t// don't flip CubeTexture envMaps, flip everything else:\\n\\t\\t\\t\\t// WebGLRenderTargetCube will be flipped for backwards compatibility\\n\\t\\t\\t\\t// WebGLRenderTargetCube.texture will be flipped because it's a Texture and NOT a CubeTexture\\n\\t\\t\\t\\t// this check must be handled differently, or removed entirely, if WebGLRenderTargetCube uses a CubeTexture in the future\\n\\t\\t\\t\\tuniforms.flipEnvMap.value = ( ! ( material.envMap && material.envMap.isCubeTexture ) ) ? 1 : - 1;\\n\\n\\t\\t\\t\\tuniforms.reflectivity.value = material.reflectivity;\\n\\t\\t\\t\\tuniforms.refractionRatio.value = material.refractionRatio;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.lightMap ) {\\n\\n\\t\\t\\t\\tuniforms.lightMap.value = material.lightMap;\\n\\t\\t\\t\\tuniforms.lightMapIntensity.value = material.lightMapIntensity;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.aoMap ) {\\n\\n\\t\\t\\t\\tuniforms.aoMap.value = material.aoMap;\\n\\t\\t\\t\\tuniforms.aoMapIntensity.value = material.aoMapIntensity;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// uv repeat and offset setting priorities\\n\\t\\t\\t// 1. color map\\n\\t\\t\\t// 2. specular map\\n\\t\\t\\t// 3. normal map\\n\\t\\t\\t// 4. bump map\\n\\t\\t\\t// 5. alpha map\\n\\t\\t\\t// 6. emissive map\\n\\n\\t\\t\\tvar uvScaleMap;\\n\\n\\t\\t\\tif ( material.map ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.map;\\n\\n\\t\\t\\t} else if ( material.specularMap ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.specularMap;\\n\\n\\t\\t\\t} else if ( material.displacementMap ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.displacementMap;\\n\\n\\t\\t\\t} else if ( material.normalMap ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.normalMap;\\n\\n\\t\\t\\t} else if ( material.bumpMap ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.bumpMap;\\n\\n\\t\\t\\t} else if ( material.roughnessMap ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.roughnessMap;\\n\\n\\t\\t\\t} else if ( material.metalnessMap ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.metalnessMap;\\n\\n\\t\\t\\t} else if ( material.alphaMap ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.alphaMap;\\n\\n\\t\\t\\t} else if ( material.emissiveMap ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.emissiveMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( uvScaleMap !== undefined ) {\\n\\n\\t\\t\\t\\t// backwards compatibility\\n\\t\\t\\t\\tif ( uvScaleMap.isWebGLRenderTarget ) {\\n\\n\\t\\t\\t\\t\\tuvScaleMap = uvScaleMap.texture;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( uvScaleMap.matrixAutoUpdate === true ) {\\n\\n\\t\\t\\t\\t\\tvar offset = uvScaleMap.offset;\\n\\t\\t\\t\\t\\tvar repeat = uvScaleMap.repeat;\\n\\t\\t\\t\\t\\tvar rotation = uvScaleMap.rotation;\\n\\t\\t\\t\\t\\tvar center = uvScaleMap.center;\\n\\n\\t\\t\\t\\t\\tuvScaleMap.matrix.setUvTransform( offset.x, offset.y, repeat.x, repeat.y, rotation, center.x, center.y );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tuniforms.uvTransform.value.copy( uvScaleMap.matrix );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsLine( uniforms, material ) {\\n\\n\\t\\t\\tuniforms.diffuse.value = material.color;\\n\\t\\t\\tuniforms.opacity.value = material.opacity;\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsDash( uniforms, material ) {\\n\\n\\t\\t\\tuniforms.dashSize.value = material.dashSize;\\n\\t\\t\\tuniforms.totalSize.value = material.dashSize + material.gapSize;\\n\\t\\t\\tuniforms.scale.value = material.scale;\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsPoints( uniforms, material ) {\\n\\n\\t\\t\\tuniforms.diffuse.value = material.color;\\n\\t\\t\\tuniforms.opacity.value = material.opacity;\\n\\t\\t\\tuniforms.size.value = material.size * _pixelRatio;\\n\\t\\t\\tuniforms.scale.value = _height * 0.5;\\n\\n\\t\\t\\tuniforms.map.value = material.map;\\n\\n\\t\\t\\tif ( material.map !== null ) {\\n\\n\\t\\t\\t\\tif ( material.map.matrixAutoUpdate === true ) {\\n\\n\\t\\t\\t\\t\\tvar offset = material.map.offset;\\n\\t\\t\\t\\t\\tvar repeat = material.map.repeat;\\n\\t\\t\\t\\t\\tvar rotation = material.map.rotation;\\n\\t\\t\\t\\t\\tvar center = material.map.center;\\n\\n\\t\\t\\t\\t\\tmaterial.map.matrix.setUvTransform( offset.x, offset.y, repeat.x, repeat.y, rotation, center.x, center.y );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tuniforms.uvTransform.value.copy( material.map.matrix );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsFog( uniforms, fog ) {\\n\\n\\t\\t\\tuniforms.fogColor.value = fog.color;\\n\\n\\t\\t\\tif ( fog.isFog ) {\\n\\n\\t\\t\\t\\tuniforms.fogNear.value = fog.near;\\n\\t\\t\\t\\tuniforms.fogFar.value = fog.far;\\n\\n\\t\\t\\t} else if ( fog.isFogExp2 ) {\\n\\n\\t\\t\\t\\tuniforms.fogDensity.value = fog.density;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsLambert( uniforms, material ) {\\n\\n\\t\\t\\tif ( material.emissiveMap ) {\\n\\n\\t\\t\\t\\tuniforms.emissiveMap.value = material.emissiveMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsPhong( uniforms, material ) {\\n\\n\\t\\t\\tuniforms.specular.value = material.specular;\\n\\t\\t\\tuniforms.shininess.value = Math.max( material.shininess, 1e-4 ); // to prevent pow( 0.0, 0.0 )\\n\\n\\t\\t\\tif ( material.emissiveMap ) {\\n\\n\\t\\t\\t\\tuniforms.emissiveMap.value = material.emissiveMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.bumpMap ) {\\n\\n\\t\\t\\t\\tuniforms.bumpMap.value = material.bumpMap;\\n\\t\\t\\t\\tuniforms.bumpScale.value = material.bumpScale;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.normalMap ) {\\n\\n\\t\\t\\t\\tuniforms.normalMap.value = material.normalMap;\\n\\t\\t\\t\\tuniforms.normalScale.value.copy( material.normalScale );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.displacementMap ) {\\n\\n\\t\\t\\t\\tuniforms.displacementMap.value = material.displacementMap;\\n\\t\\t\\t\\tuniforms.displacementScale.value = material.displacementScale;\\n\\t\\t\\t\\tuniforms.displacementBias.value = material.displacementBias;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsToon( uniforms, material ) {\\n\\n\\t\\t\\trefreshUniformsPhong( uniforms, material );\\n\\n\\t\\t\\tif ( material.gradientMap ) {\\n\\n\\t\\t\\t\\tuniforms.gradientMap.value = material.gradientMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsStandard( uniforms, material ) {\\n\\n\\t\\t\\tuniforms.roughness.value = material.roughness;\\n\\t\\t\\tuniforms.metalness.value = material.metalness;\\n\\n\\t\\t\\tif ( material.roughnessMap ) {\\n\\n\\t\\t\\t\\tuniforms.roughnessMap.value = material.roughnessMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.metalnessMap ) {\\n\\n\\t\\t\\t\\tuniforms.metalnessMap.value = material.metalnessMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.emissiveMap ) {\\n\\n\\t\\t\\t\\tuniforms.emissiveMap.value = material.emissiveMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.bumpMap ) {\\n\\n\\t\\t\\t\\tuniforms.bumpMap.value = material.bumpMap;\\n\\t\\t\\t\\tuniforms.bumpScale.value = material.bumpScale;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.normalMap ) {\\n\\n\\t\\t\\t\\tuniforms.normalMap.value = material.normalMap;\\n\\t\\t\\t\\tuniforms.normalScale.value.copy( material.normalScale );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.displacementMap ) {\\n\\n\\t\\t\\t\\tuniforms.displacementMap.value = material.displacementMap;\\n\\t\\t\\t\\tuniforms.displacementScale.value = material.displacementScale;\\n\\t\\t\\t\\tuniforms.displacementBias.value = material.displacementBias;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.envMap ) {\\n\\n\\t\\t\\t\\t//uniforms.envMap.value = material.envMap; // part of uniforms common\\n\\t\\t\\t\\tuniforms.envMapIntensity.value = material.envMapIntensity;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsPhysical( uniforms, material ) {\\n\\n\\t\\t\\tuniforms.clearCoat.value = material.clearCoat;\\n\\t\\t\\tuniforms.clearCoatRoughness.value = material.clearCoatRoughness;\\n\\n\\t\\t\\trefreshUniformsStandard( uniforms, material );\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsDepth( uniforms, material ) {\\n\\n\\t\\t\\tif ( material.displacementMap ) {\\n\\n\\t\\t\\t\\tuniforms.displacementMap.value = material.displacementMap;\\n\\t\\t\\t\\tuniforms.displacementScale.value = material.displacementScale;\\n\\t\\t\\t\\tuniforms.displacementBias.value = material.displacementBias;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsDistance( uniforms, material ) {\\n\\n\\t\\t\\tif ( material.displacementMap ) {\\n\\n\\t\\t\\t\\tuniforms.displacementMap.value = material.displacementMap;\\n\\t\\t\\t\\tuniforms.displacementScale.value = material.displacementScale;\\n\\t\\t\\t\\tuniforms.displacementBias.value = material.displacementBias;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tuniforms.referencePosition.value.copy( material.referencePosition );\\n\\t\\t\\tuniforms.nearDistance.value = material.nearDistance;\\n\\t\\t\\tuniforms.farDistance.value = material.farDistance;\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsNormal( uniforms, material ) {\\n\\n\\t\\t\\tif ( material.bumpMap ) {\\n\\n\\t\\t\\t\\tuniforms.bumpMap.value = material.bumpMap;\\n\\t\\t\\t\\tuniforms.bumpScale.value = material.bumpScale;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.normalMap ) {\\n\\n\\t\\t\\t\\tuniforms.normalMap.value = material.normalMap;\\n\\t\\t\\t\\tuniforms.normalScale.value.copy( material.normalScale );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.displacementMap ) {\\n\\n\\t\\t\\t\\tuniforms.displacementMap.value = material.displacementMap;\\n\\t\\t\\t\\tuniforms.displacementScale.value = material.displacementScale;\\n\\t\\t\\t\\tuniforms.displacementBias.value = material.displacementBias;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// If uniforms are marked as clean, they don't need to be loaded to the GPU.\\n\\n\\t\\tfunction markUniformsLightsNeedsUpdate( uniforms, value ) {\\n\\n\\t\\t\\tuniforms.ambientLightColor.needsUpdate = value;\\n\\n\\t\\t\\tuniforms.directionalLights.needsUpdate = value;\\n\\t\\t\\tuniforms.pointLights.needsUpdate = value;\\n\\t\\t\\tuniforms.spotLights.needsUpdate = value;\\n\\t\\t\\tuniforms.rectAreaLights.needsUpdate = value;\\n\\t\\t\\tuniforms.hemisphereLights.needsUpdate = value;\\n\\n\\t\\t}\\n\\n\\t\\t// GL state setting\\n\\n\\t\\tthis.setFaceCulling = function ( cullFace, frontFaceDirection ) {\\n\\n\\t\\t\\tstate.setCullFace( cullFace );\\n\\t\\t\\tstate.setFlipSided( frontFaceDirection === FrontFaceDirectionCW );\\n\\n\\t\\t};\\n\\n\\t\\t// Textures\\n\\n\\t\\tfunction allocTextureUnit() {\\n\\n\\t\\t\\tvar textureUnit = _usedTextureUnits;\\n\\n\\t\\t\\tif ( textureUnit >= capabilities.maxTextures ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Trying to use ' + textureUnit + ' texture units while this GPU supports only ' + capabilities.maxTextures );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t_usedTextureUnits += 1;\\n\\n\\t\\t\\treturn textureUnit;\\n\\n\\t\\t}\\n\\n\\t\\tthis.allocTextureUnit = allocTextureUnit;\\n\\n\\t\\t// this.setTexture2D = setTexture2D;\\n\\t\\tthis.setTexture2D = ( function () {\\n\\n\\t\\t\\tvar warned = false;\\n\\n\\t\\t\\t// backwards compatibility: peel texture.texture\\n\\t\\t\\treturn function setTexture2D( texture, slot ) {\\n\\n\\t\\t\\t\\tif ( texture && texture.isWebGLRenderTarget ) {\\n\\n\\t\\t\\t\\t\\tif ( ! warned ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( \\\"THREE.WebGLRenderer.setTexture2D: don't use render targets as textures. Use their .texture property instead.\\\" );\\n\\t\\t\\t\\t\\t\\twarned = true;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\ttexture = texture.texture;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\ttextures.setTexture2D( texture, slot );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}() );\\n\\n\\t\\tthis.setTexture = ( function () {\\n\\n\\t\\t\\tvar warned = false;\\n\\n\\t\\t\\treturn function setTexture( texture, slot ) {\\n\\n\\t\\t\\t\\tif ( ! warned ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( \\\"THREE.WebGLRenderer: .setTexture is deprecated, use setTexture2D instead.\\\" );\\n\\t\\t\\t\\t\\twarned = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\ttextures.setTexture2D( texture, slot );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}() );\\n\\n\\t\\tthis.setTextureCube = ( function () {\\n\\n\\t\\t\\tvar warned = false;\\n\\n\\t\\t\\treturn function setTextureCube( texture, slot ) {\\n\\n\\t\\t\\t\\t// backwards compatibility: peel texture.texture\\n\\t\\t\\t\\tif ( texture && texture.isWebGLRenderTargetCube ) {\\n\\n\\t\\t\\t\\t\\tif ( ! warned ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( \\\"THREE.WebGLRenderer.setTextureCube: don't use cube render targets as textures. Use their .texture property instead.\\\" );\\n\\t\\t\\t\\t\\t\\twarned = true;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\ttexture = texture.texture;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// currently relying on the fact that WebGLRenderTargetCube.texture is a Texture and NOT a CubeTexture\\n\\t\\t\\t\\t// TODO: unify these code paths\\n\\t\\t\\t\\tif ( ( texture && texture.isCubeTexture ) ||\\n\\t\\t\\t\\t\\t( Array.isArray( texture.image ) && texture.image.length === 6 ) ) {\\n\\n\\t\\t\\t\\t\\t// CompressedTexture can have Array in image :/\\n\\n\\t\\t\\t\\t\\t// this function alone should take care of cube textures\\n\\t\\t\\t\\t\\ttextures.setTextureCube( texture, slot );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// assumed: texture property of THREE.WebGLRenderTargetCube\\n\\n\\t\\t\\t\\t\\ttextures.setTextureCubeDynamic( texture, slot );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}() );\\n\\n\\t\\tthis.getRenderTarget = function () {\\n\\n\\t\\t\\treturn _currentRenderTarget;\\n\\n\\t\\t};\\n\\n\\t\\tthis.setRenderTarget = function ( renderTarget ) {\\n\\n\\t\\t\\t_currentRenderTarget = renderTarget;\\n\\n\\t\\t\\tif ( renderTarget && properties.get( renderTarget ).__webglFramebuffer === undefined ) {\\n\\n\\t\\t\\t\\ttextures.setupRenderTarget( renderTarget );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar framebuffer = null;\\n\\t\\t\\tvar isCube = false;\\n\\n\\t\\t\\tif ( renderTarget ) {\\n\\n\\t\\t\\t\\tvar __webglFramebuffer = properties.get( renderTarget ).__webglFramebuffer;\\n\\n\\t\\t\\t\\tif ( renderTarget.isWebGLRenderTargetCube ) {\\n\\n\\t\\t\\t\\t\\tframebuffer = __webglFramebuffer[ renderTarget.activeCubeFace ];\\n\\t\\t\\t\\t\\tisCube = true;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tframebuffer = __webglFramebuffer;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t_currentViewport.copy( renderTarget.viewport );\\n\\t\\t\\t\\t_currentScissor.copy( renderTarget.scissor );\\n\\t\\t\\t\\t_currentScissorTest = renderTarget.scissorTest;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t_currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio );\\n\\t\\t\\t\\t_currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio );\\n\\t\\t\\t\\t_currentScissorTest = _scissorTest;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( _currentFramebuffer !== framebuffer ) {\\n\\n\\t\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );\\n\\t\\t\\t\\t_currentFramebuffer = framebuffer;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tstate.viewport( _currentViewport );\\n\\t\\t\\tstate.scissor( _currentScissor );\\n\\t\\t\\tstate.setScissorTest( _currentScissorTest );\\n\\n\\t\\t\\tif ( isCube ) {\\n\\n\\t\\t\\t\\tvar textureProperties = properties.get( renderTarget.texture );\\n\\t\\t\\t\\t_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + renderTarget.activeCubeFace, textureProperties.__webglTexture, renderTarget.activeMipMapLevel );\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t\\tthis.readRenderTargetPixels = function ( renderTarget, x, y, width, height, buffer ) {\\n\\n\\t\\t\\tif ( ! ( renderTarget && renderTarget.isWebGLRenderTarget ) ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar framebuffer = properties.get( renderTarget ).__webglFramebuffer;\\n\\n\\t\\t\\tif ( framebuffer ) {\\n\\n\\t\\t\\t\\tvar restore = false;\\n\\n\\t\\t\\t\\tif ( framebuffer !== _currentFramebuffer ) {\\n\\n\\t\\t\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );\\n\\n\\t\\t\\t\\t\\trestore = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\ttry {\\n\\n\\t\\t\\t\\t\\tvar texture = renderTarget.texture;\\n\\t\\t\\t\\t\\tvar textureFormat = texture.format;\\n\\t\\t\\t\\t\\tvar textureType = texture.type;\\n\\n\\t\\t\\t\\t\\tif ( textureFormat !== RGBAFormat && utils.convert( textureFormat ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_FORMAT ) ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.' );\\n\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( textureType !== UnsignedByteType && utils.convert( textureType ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_TYPE ) && // IE11, Edge and Chrome Mac < 52 (#9513)\\n\\t\\t\\t\\t\\t\\t! ( textureType === FloatType && ( extensions.get( 'OES_texture_float' ) || extensions.get( 'WEBGL_color_buffer_float' ) ) ) && // Chrome Mac >= 52 and Firefox\\n\\t\\t\\t\\t\\t\\t! ( textureType === HalfFloatType && extensions.get( 'EXT_color_buffer_half_float' ) ) ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.' );\\n\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( _gl.checkFramebufferStatus( _gl.FRAMEBUFFER ) === _gl.FRAMEBUFFER_COMPLETE ) {\\n\\n\\t\\t\\t\\t\\t\\t// the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604)\\n\\n\\t\\t\\t\\t\\t\\tif ( ( x >= 0 && x <= ( renderTarget.width - width ) ) && ( y >= 0 && y <= ( renderTarget.height - height ) ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t_gl.readPixels( x, y, width, height, utils.convert( textureFormat ), utils.convert( textureType ), buffer );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.' );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} finally {\\n\\n\\t\\t\\t\\t\\tif ( restore ) {\\n\\n\\t\\t\\t\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, _currentFramebuffer );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction FogExp2( color, density ) {\\n\\n\\t\\tthis.name = '';\\n\\n\\t\\tthis.color = new Color( color );\\n\\t\\tthis.density = ( density !== undefined ) ? density : 0.00025;\\n\\n\\t}\\n\\n\\tFogExp2.prototype.isFogExp2 = true;\\n\\n\\tFogExp2.prototype.clone = function () {\\n\\n\\t\\treturn new FogExp2( this.color.getHex(), this.density );\\n\\n\\t};\\n\\n\\tFogExp2.prototype.toJSON = function ( /* meta */ ) {\\n\\n\\t\\treturn {\\n\\t\\t\\ttype: 'FogExp2',\\n\\t\\t\\tcolor: this.color.getHex(),\\n\\t\\t\\tdensity: this.density\\n\\t\\t};\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction Fog( color, near, far ) {\\n\\n\\t\\tthis.name = '';\\n\\n\\t\\tthis.color = new Color( color );\\n\\n\\t\\tthis.near = ( near !== undefined ) ? near : 1;\\n\\t\\tthis.far = ( far !== undefined ) ? far : 1000;\\n\\n\\t}\\n\\n\\tFog.prototype.isFog = true;\\n\\n\\tFog.prototype.clone = function () {\\n\\n\\t\\treturn new Fog( this.color.getHex(), this.near, this.far );\\n\\n\\t};\\n\\n\\tFog.prototype.toJSON = function ( /* meta */ ) {\\n\\n\\t\\treturn {\\n\\t\\t\\ttype: 'Fog',\\n\\t\\t\\tcolor: this.color.getHex(),\\n\\t\\t\\tnear: this.near,\\n\\t\\t\\tfar: this.far\\n\\t\\t};\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Scene() {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Scene';\\n\\n\\t\\tthis.background = null;\\n\\t\\tthis.fog = null;\\n\\t\\tthis.overrideMaterial = null;\\n\\n\\t\\tthis.autoUpdate = true; // checked by the renderer\\n\\n\\t}\\n\\n\\tScene.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Scene,\\n\\n\\t\\tcopy: function ( source, recursive ) {\\n\\n\\t\\t\\tObject3D.prototype.copy.call( this, source, recursive );\\n\\n\\t\\t\\tif ( source.background !== null ) this.background = source.background.clone();\\n\\t\\t\\tif ( source.fog !== null ) this.fog = source.fog.clone();\\n\\t\\t\\tif ( source.overrideMaterial !== null ) this.overrideMaterial = source.overrideMaterial.clone();\\n\\n\\t\\t\\tthis.autoUpdate = source.autoUpdate;\\n\\t\\t\\tthis.matrixAutoUpdate = source.matrixAutoUpdate;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\tvar data = Object3D.prototype.toJSON.call( this, meta );\\n\\n\\t\\t\\tif ( this.background !== null ) data.object.background = this.background.toJSON( meta );\\n\\t\\t\\tif ( this.fog !== null ) data.object.fog = this.fog.toJSON();\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction LensFlare( texture, size, distance, blending, color ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.lensFlares = [];\\n\\n\\t\\tthis.positionScreen = new Vector3();\\n\\t\\tthis.customUpdateCallback = undefined;\\n\\n\\t\\tif ( texture !== undefined ) {\\n\\n\\t\\t\\tthis.add( texture, size, distance, blending, color );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tLensFlare.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: LensFlare,\\n\\n\\t\\tisLensFlare: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tObject3D.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.positionScreen.copy( source.positionScreen );\\n\\t\\t\\tthis.customUpdateCallback = source.customUpdateCallback;\\n\\n\\t\\t\\tfor ( var i = 0, l = source.lensFlares.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tthis.lensFlares.push( source.lensFlares[ i ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tadd: function ( texture, size, distance, blending, color, opacity ) {\\n\\n\\t\\t\\tif ( size === undefined ) size = - 1;\\n\\t\\t\\tif ( distance === undefined ) distance = 0;\\n\\t\\t\\tif ( opacity === undefined ) opacity = 1;\\n\\t\\t\\tif ( color === undefined ) color = new Color( 0xffffff );\\n\\t\\t\\tif ( blending === undefined ) blending = NormalBlending;\\n\\n\\t\\t\\tdistance = Math.min( distance, Math.max( 0, distance ) );\\n\\n\\t\\t\\tthis.lensFlares.push( {\\n\\t\\t\\t\\ttexture: texture,\\t// THREE.Texture\\n\\t\\t\\t\\tsize: size, \\t\\t// size in pixels (-1 = use texture.width)\\n\\t\\t\\t\\tdistance: distance, \\t// distance (0-1) from light source (0=at light source)\\n\\t\\t\\t\\tx: 0, y: 0, z: 0,\\t// screen position (-1 => 1) z = 0 is in front z = 1 is back\\n\\t\\t\\t\\tscale: 1, \\t\\t// scale\\n\\t\\t\\t\\trotation: 0, \\t\\t// rotation\\n\\t\\t\\t\\topacity: opacity,\\t// opacity\\n\\t\\t\\t\\tcolor: color,\\t\\t// color\\n\\t\\t\\t\\tblending: blending\\t// blending\\n\\t\\t\\t} );\\n\\n\\t\\t},\\n\\n\\t\\t/*\\n\\t\\t * Update lens flares update positions on all flares based on the screen position\\n\\t\\t * Set myLensFlare.customUpdateCallback to alter the flares in your project specific way.\\n\\t\\t */\\n\\n\\t\\tupdateLensFlares: function () {\\n\\n\\t\\t\\tvar f, fl = this.lensFlares.length;\\n\\t\\t\\tvar flare;\\n\\t\\t\\tvar vecX = - this.positionScreen.x * 2;\\n\\t\\t\\tvar vecY = - this.positionScreen.y * 2;\\n\\n\\t\\t\\tfor ( f = 0; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\tflare = this.lensFlares[ f ];\\n\\n\\t\\t\\t\\tflare.x = this.positionScreen.x + vecX * flare.distance;\\n\\t\\t\\t\\tflare.y = this.positionScreen.y + vecY * flare.distance;\\n\\n\\t\\t\\t\\tflare.wantedRotation = flare.x * Math.PI * 0.25;\\n\\t\\t\\t\\tflare.rotation += ( flare.wantedRotation - flare.rotation ) * 0.25;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * parameters = {\\n\\t * color: ,\\n\\t * opacity: ,\\n\\t * map: new THREE.Texture( ),\\n\\t *\\n\\t *\\tuvOffset: new THREE.Vector2(),\\n\\t *\\tuvScale: new THREE.Vector2()\\n\\t * }\\n\\t */\\n\\n\\tfunction SpriteMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'SpriteMaterial';\\n\\n\\t\\tthis.color = new Color( 0xffffff );\\n\\t\\tthis.map = null;\\n\\n\\t\\tthis.rotation = 0;\\n\\n\\t\\tthis.fog = false;\\n\\t\\tthis.lights = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tSpriteMaterial.prototype = Object.create( Material.prototype );\\n\\tSpriteMaterial.prototype.constructor = SpriteMaterial;\\n\\tSpriteMaterial.prototype.isSpriteMaterial = true;\\n\\n\\tSpriteMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.color.copy( source.color );\\n\\t\\tthis.map = source.map;\\n\\n\\t\\tthis.rotation = source.rotation;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction Sprite( material ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Sprite';\\n\\n\\t\\tthis.material = ( material !== undefined ) ? material : new SpriteMaterial();\\n\\n\\t}\\n\\n\\tSprite.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Sprite,\\n\\n\\t\\tisSprite: true,\\n\\n\\t\\traycast: ( function () {\\n\\n\\t\\t\\tvar intersectPoint = new Vector3();\\n\\t\\t\\tvar worldPosition = new Vector3();\\n\\t\\t\\tvar worldScale = new Vector3();\\n\\n\\t\\t\\treturn function raycast( raycaster, intersects ) {\\n\\n\\t\\t\\t\\tworldPosition.setFromMatrixPosition( this.matrixWorld );\\n\\t\\t\\t\\traycaster.ray.closestPointToPoint( worldPosition, intersectPoint );\\n\\n\\t\\t\\t\\tworldScale.setFromMatrixScale( this.matrixWorld );\\n\\t\\t\\t\\tvar guessSizeSq = worldScale.x * worldScale.y / 4;\\n\\n\\t\\t\\t\\tif ( worldPosition.distanceToSquared( intersectPoint ) > guessSizeSq ) return;\\n\\n\\t\\t\\t\\tvar distance = raycaster.ray.origin.distanceTo( intersectPoint );\\n\\n\\t\\t\\t\\tif ( distance < raycaster.near || distance > raycaster.far ) return;\\n\\n\\t\\t\\t\\tintersects.push( {\\n\\n\\t\\t\\t\\t\\tdistance: distance,\\n\\t\\t\\t\\t\\tpoint: intersectPoint.clone(),\\n\\t\\t\\t\\t\\tface: null,\\n\\t\\t\\t\\t\\tobject: this\\n\\n\\t\\t\\t\\t} );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}() ),\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.material ).copy( this );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction LOD() {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'LOD';\\n\\n\\t\\tObject.defineProperties( this, {\\n\\t\\t\\tlevels: {\\n\\t\\t\\t\\tenumerable: true,\\n\\t\\t\\t\\tvalue: []\\n\\t\\t\\t}\\n\\t\\t} );\\n\\n\\t}\\n\\n\\tLOD.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: LOD,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tObject3D.prototype.copy.call( this, source, false );\\n\\n\\t\\t\\tvar levels = source.levels;\\n\\n\\t\\t\\tfor ( var i = 0, l = levels.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar level = levels[ i ];\\n\\n\\t\\t\\t\\tthis.addLevel( level.object.clone(), level.distance );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddLevel: function ( object, distance ) {\\n\\n\\t\\t\\tif ( distance === undefined ) distance = 0;\\n\\n\\t\\t\\tdistance = Math.abs( distance );\\n\\n\\t\\t\\tvar levels = this.levels;\\n\\n\\t\\t\\tfor ( var l = 0; l < levels.length; l ++ ) {\\n\\n\\t\\t\\t\\tif ( distance < levels[ l ].distance ) {\\n\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tlevels.splice( l, 0, { distance: distance, object: object } );\\n\\n\\t\\t\\tthis.add( object );\\n\\n\\t\\t},\\n\\n\\t\\tgetObjectForDistance: function ( distance ) {\\n\\n\\t\\t\\tvar levels = this.levels;\\n\\n\\t\\t\\tfor ( var i = 1, l = levels.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tif ( distance < levels[ i ].distance ) {\\n\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn levels[ i - 1 ].object;\\n\\n\\t\\t},\\n\\n\\t\\traycast: ( function () {\\n\\n\\t\\t\\tvar matrixPosition = new Vector3();\\n\\n\\t\\t\\treturn function raycast( raycaster, intersects ) {\\n\\n\\t\\t\\t\\tmatrixPosition.setFromMatrixPosition( this.matrixWorld );\\n\\n\\t\\t\\t\\tvar distance = raycaster.ray.origin.distanceTo( matrixPosition );\\n\\n\\t\\t\\t\\tthis.getObjectForDistance( distance ).raycast( raycaster, intersects );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}() ),\\n\\n\\t\\tupdate: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\t\\t\\tvar v2 = new Vector3();\\n\\n\\t\\t\\treturn function update( camera ) {\\n\\n\\t\\t\\t\\tvar levels = this.levels;\\n\\n\\t\\t\\t\\tif ( levels.length > 1 ) {\\n\\n\\t\\t\\t\\t\\tv1.setFromMatrixPosition( camera.matrixWorld );\\n\\t\\t\\t\\t\\tv2.setFromMatrixPosition( this.matrixWorld );\\n\\n\\t\\t\\t\\t\\tvar distance = v1.distanceTo( v2 );\\n\\n\\t\\t\\t\\t\\tlevels[ 0 ].object.visible = true;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 1, l = levels.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( distance >= levels[ i ].distance ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tlevels[ i - 1 ].object.visible = false;\\n\\t\\t\\t\\t\\t\\t\\tlevels[ i ].object.visible = true;\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tfor ( ; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tlevels[ i ].object.visible = false;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\tvar data = Object3D.prototype.toJSON.call( this, meta );\\n\\n\\t\\t\\tdata.object.levels = [];\\n\\n\\t\\t\\tvar levels = this.levels;\\n\\n\\t\\t\\tfor ( var i = 0, l = levels.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar level = levels[ i ];\\n\\n\\t\\t\\t\\tdata.object.levels.push( {\\n\\t\\t\\t\\t\\tobject: level.object.uuid,\\n\\t\\t\\t\\t\\tdistance: level.distance\\n\\t\\t\\t\\t} );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author michael guerrero / http://realitymeltdown.com\\n\\t * @author ikerr / http://verold.com\\n\\t */\\n\\n\\tfunction Skeleton( bones, boneInverses ) {\\n\\n\\t\\t// copy the bone array\\n\\n\\t\\tbones = bones || [];\\n\\n\\t\\tthis.bones = bones.slice( 0 );\\n\\t\\tthis.boneMatrices = new Float32Array( this.bones.length * 16 );\\n\\n\\t\\t// use the supplied bone inverses or calculate the inverses\\n\\n\\t\\tif ( boneInverses === undefined ) {\\n\\n\\t\\t\\tthis.calculateInverses();\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tif ( this.bones.length === boneInverses.length ) {\\n\\n\\t\\t\\t\\tthis.boneInverses = boneInverses.slice( 0 );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Skeleton boneInverses is the wrong length.' );\\n\\n\\t\\t\\t\\tthis.boneInverses = [];\\n\\n\\t\\t\\t\\tfor ( var i = 0, il = this.bones.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tthis.boneInverses.push( new Matrix4() );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tObject.assign( Skeleton.prototype, {\\n\\n\\t\\tcalculateInverses: function () {\\n\\n\\t\\t\\tthis.boneInverses = [];\\n\\n\\t\\t\\tfor ( var i = 0, il = this.bones.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar inverse = new Matrix4();\\n\\n\\t\\t\\t\\tif ( this.bones[ i ] ) {\\n\\n\\t\\t\\t\\t\\tinverse.getInverse( this.bones[ i ].matrixWorld );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.boneInverses.push( inverse );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tpose: function () {\\n\\n\\t\\t\\tvar bone, i, il;\\n\\n\\t\\t\\t// recover the bind-time world matrices\\n\\n\\t\\t\\tfor ( i = 0, il = this.bones.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tbone = this.bones[ i ];\\n\\n\\t\\t\\t\\tif ( bone ) {\\n\\n\\t\\t\\t\\t\\tbone.matrixWorld.getInverse( this.boneInverses[ i ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// compute the local matrices, positions, rotations and scales\\n\\n\\t\\t\\tfor ( i = 0, il = this.bones.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tbone = this.bones[ i ];\\n\\n\\t\\t\\t\\tif ( bone ) {\\n\\n\\t\\t\\t\\t\\tif ( bone.parent && bone.parent.isBone ) {\\n\\n\\t\\t\\t\\t\\t\\tbone.matrix.getInverse( bone.parent.matrixWorld );\\n\\t\\t\\t\\t\\t\\tbone.matrix.multiply( bone.matrixWorld );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tbone.matrix.copy( bone.matrixWorld );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tbone.matrix.decompose( bone.position, bone.quaternion, bone.scale );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tupdate: ( function () {\\n\\n\\t\\t\\tvar offsetMatrix = new Matrix4();\\n\\t\\t\\tvar identityMatrix = new Matrix4();\\n\\n\\t\\t\\treturn function update() {\\n\\n\\t\\t\\t\\tvar bones = this.bones;\\n\\t\\t\\t\\tvar boneInverses = this.boneInverses;\\n\\t\\t\\t\\tvar boneMatrices = this.boneMatrices;\\n\\t\\t\\t\\tvar boneTexture = this.boneTexture;\\n\\n\\t\\t\\t\\t// flatten bone matrices to array\\n\\n\\t\\t\\t\\tfor ( var i = 0, il = bones.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t// compute the offset between the current and the original transform\\n\\n\\t\\t\\t\\t\\tvar matrix = bones[ i ] ? bones[ i ].matrixWorld : identityMatrix;\\n\\n\\t\\t\\t\\t\\toffsetMatrix.multiplyMatrices( matrix, boneInverses[ i ] );\\n\\t\\t\\t\\t\\toffsetMatrix.toArray( boneMatrices, i * 16 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( boneTexture !== undefined ) {\\n\\n\\t\\t\\t\\t\\tboneTexture.needsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )(),\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new Skeleton( this.bones, this.boneInverses );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author ikerr / http://verold.com\\n\\t */\\n\\n\\tfunction Bone() {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Bone';\\n\\n\\t}\\n\\n\\tBone.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Bone,\\n\\n\\t\\tisBone: true\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author ikerr / http://verold.com\\n\\t */\\n\\n\\tfunction SkinnedMesh( geometry, material ) {\\n\\n\\t\\tMesh.call( this, geometry, material );\\n\\n\\t\\tthis.type = 'SkinnedMesh';\\n\\n\\t\\tthis.bindMode = 'attached';\\n\\t\\tthis.bindMatrix = new Matrix4();\\n\\t\\tthis.bindMatrixInverse = new Matrix4();\\n\\n\\t\\tvar bones = this.initBones();\\n\\t\\tvar skeleton = new Skeleton( bones );\\n\\n\\t\\tthis.bind( skeleton, this.matrixWorld );\\n\\n\\t\\tthis.normalizeSkinWeights();\\n\\n\\t}\\n\\n\\tSkinnedMesh.prototype = Object.assign( Object.create( Mesh.prototype ), {\\n\\n\\t\\tconstructor: SkinnedMesh,\\n\\n\\t\\tisSkinnedMesh: true,\\n\\n\\t\\tinitBones: function () {\\n\\n\\t\\t\\tvar bones = [], bone, gbone;\\n\\t\\t\\tvar i, il;\\n\\n\\t\\t\\tif ( this.geometry && this.geometry.bones !== undefined ) {\\n\\n\\t\\t\\t\\t// first, create array of 'Bone' objects from geometry data\\n\\n\\t\\t\\t\\tfor ( i = 0, il = this.geometry.bones.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tgbone = this.geometry.bones[ i ];\\n\\n\\t\\t\\t\\t\\t// create new 'Bone' object\\n\\n\\t\\t\\t\\t\\tbone = new Bone();\\n\\t\\t\\t\\t\\tbones.push( bone );\\n\\n\\t\\t\\t\\t\\t// apply values\\n\\n\\t\\t\\t\\t\\tbone.name = gbone.name;\\n\\t\\t\\t\\t\\tbone.position.fromArray( gbone.pos );\\n\\t\\t\\t\\t\\tbone.quaternion.fromArray( gbone.rotq );\\n\\t\\t\\t\\t\\tif ( gbone.scl !== undefined ) bone.scale.fromArray( gbone.scl );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// second, create bone hierarchy\\n\\n\\t\\t\\t\\tfor ( i = 0, il = this.geometry.bones.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tgbone = this.geometry.bones[ i ];\\n\\n\\t\\t\\t\\t\\tif ( ( gbone.parent !== - 1 ) && ( gbone.parent !== null ) && ( bones[ gbone.parent ] !== undefined ) ) {\\n\\n\\t\\t\\t\\t\\t\\t// subsequent bones in the hierarchy\\n\\n\\t\\t\\t\\t\\t\\tbones[ gbone.parent ].add( bones[ i ] );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t// topmost bone, immediate child of the skinned mesh\\n\\n\\t\\t\\t\\t\\t\\tthis.add( bones[ i ] );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// now the bones are part of the scene graph and children of the skinned mesh.\\n\\t\\t\\t// let's update the corresponding matrices\\n\\n\\t\\t\\tthis.updateMatrixWorld( true );\\n\\n\\t\\t\\treturn bones;\\n\\n\\t\\t},\\n\\n\\t\\tbind: function ( skeleton, bindMatrix ) {\\n\\n\\t\\t\\tthis.skeleton = skeleton;\\n\\n\\t\\t\\tif ( bindMatrix === undefined ) {\\n\\n\\t\\t\\t\\tthis.updateMatrixWorld( true );\\n\\n\\t\\t\\t\\tthis.skeleton.calculateInverses();\\n\\n\\t\\t\\t\\tbindMatrix = this.matrixWorld;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.bindMatrix.copy( bindMatrix );\\n\\t\\t\\tthis.bindMatrixInverse.getInverse( bindMatrix );\\n\\n\\t\\t},\\n\\n\\t\\tpose: function () {\\n\\n\\t\\t\\tthis.skeleton.pose();\\n\\n\\t\\t},\\n\\n\\t\\tnormalizeSkinWeights: function () {\\n\\n\\t\\t\\tvar scale, i;\\n\\n\\t\\t\\tif ( this.geometry && this.geometry.isGeometry ) {\\n\\n\\t\\t\\t\\tfor ( i = 0; i < this.geometry.skinWeights.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar sw = this.geometry.skinWeights[ i ];\\n\\n\\t\\t\\t\\t\\tscale = 1.0 / sw.manhattanLength();\\n\\n\\t\\t\\t\\t\\tif ( scale !== Infinity ) {\\n\\n\\t\\t\\t\\t\\t\\tsw.multiplyScalar( scale );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tsw.set( 1, 0, 0, 0 ); // do something reasonable\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( this.geometry && this.geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\tvar vec = new Vector4();\\n\\n\\t\\t\\t\\tvar skinWeight = this.geometry.attributes.skinWeight;\\n\\n\\t\\t\\t\\tfor ( i = 0; i < skinWeight.count; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvec.x = skinWeight.getX( i );\\n\\t\\t\\t\\t\\tvec.y = skinWeight.getY( i );\\n\\t\\t\\t\\t\\tvec.z = skinWeight.getZ( i );\\n\\t\\t\\t\\t\\tvec.w = skinWeight.getW( i );\\n\\n\\t\\t\\t\\t\\tscale = 1.0 / vec.manhattanLength();\\n\\n\\t\\t\\t\\t\\tif ( scale !== Infinity ) {\\n\\n\\t\\t\\t\\t\\t\\tvec.multiplyScalar( scale );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tvec.set( 1, 0, 0, 0 ); // do something reasonable\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tskinWeight.setXYZW( i, vec.x, vec.y, vec.z, vec.w );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tupdateMatrixWorld: function ( force ) {\\n\\n\\t\\t\\tMesh.prototype.updateMatrixWorld.call( this, force );\\n\\n\\t\\t\\tif ( this.bindMode === 'attached' ) {\\n\\n\\t\\t\\t\\tthis.bindMatrixInverse.getInverse( this.matrixWorld );\\n\\n\\t\\t\\t} else if ( this.bindMode === 'detached' ) {\\n\\n\\t\\t\\t\\tthis.bindMatrixInverse.getInverse( this.bindMatrix );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.SkinnedMesh: Unrecognized bindMode: ' + this.bindMode );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.geometry, this.material ).copy( this );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * parameters = {\\n\\t * color: ,\\n\\t * opacity: ,\\n\\t *\\n\\t * linewidth: ,\\n\\t * linecap: \\\"round\\\",\\n\\t * linejoin: \\\"round\\\"\\n\\t * }\\n\\t */\\n\\n\\tfunction LineBasicMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'LineBasicMaterial';\\n\\n\\t\\tthis.color = new Color( 0xffffff );\\n\\n\\t\\tthis.linewidth = 1;\\n\\t\\tthis.linecap = 'round';\\n\\t\\tthis.linejoin = 'round';\\n\\n\\t\\tthis.lights = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tLineBasicMaterial.prototype = Object.create( Material.prototype );\\n\\tLineBasicMaterial.prototype.constructor = LineBasicMaterial;\\n\\n\\tLineBasicMaterial.prototype.isLineBasicMaterial = true;\\n\\n\\tLineBasicMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.color.copy( source.color );\\n\\n\\t\\tthis.linewidth = source.linewidth;\\n\\t\\tthis.linecap = source.linecap;\\n\\t\\tthis.linejoin = source.linejoin;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Line( geometry, material, mode ) {\\n\\n\\t\\tif ( mode === 1 ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Line: parameter THREE.LinePieces no longer supported. Created THREE.LineSegments instead.' );\\n\\t\\t\\treturn new LineSegments( geometry, material );\\n\\n\\t\\t}\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Line';\\n\\n\\t\\tthis.geometry = geometry !== undefined ? geometry : new BufferGeometry();\\n\\t\\tthis.material = material !== undefined ? material : new LineBasicMaterial( { color: Math.random() * 0xffffff } );\\n\\n\\t}\\n\\n\\tLine.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Line,\\n\\n\\t\\tisLine: true,\\n\\n\\t\\traycast: ( function () {\\n\\n\\t\\t\\tvar inverseMatrix = new Matrix4();\\n\\t\\t\\tvar ray = new Ray();\\n\\t\\t\\tvar sphere = new Sphere();\\n\\n\\t\\t\\treturn function raycast( raycaster, intersects ) {\\n\\n\\t\\t\\t\\tvar precision = raycaster.linePrecision;\\n\\t\\t\\t\\tvar precisionSq = precision * precision;\\n\\n\\t\\t\\t\\tvar geometry = this.geometry;\\n\\t\\t\\t\\tvar matrixWorld = this.matrixWorld;\\n\\n\\t\\t\\t\\t// Checking boundingSphere distance to ray\\n\\n\\t\\t\\t\\tif ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();\\n\\n\\t\\t\\t\\tsphere.copy( geometry.boundingSphere );\\n\\t\\t\\t\\tsphere.applyMatrix4( matrixWorld );\\n\\n\\t\\t\\t\\tif ( raycaster.ray.intersectsSphere( sphere ) === false ) return;\\n\\n\\t\\t\\t\\t//\\n\\n\\t\\t\\t\\tinverseMatrix.getInverse( matrixWorld );\\n\\t\\t\\t\\tray.copy( raycaster.ray ).applyMatrix4( inverseMatrix );\\n\\n\\t\\t\\t\\tvar vStart = new Vector3();\\n\\t\\t\\t\\tvar vEnd = new Vector3();\\n\\t\\t\\t\\tvar interSegment = new Vector3();\\n\\t\\t\\t\\tvar interRay = new Vector3();\\n\\t\\t\\t\\tvar step = ( this && this.isLineSegments ) ? 2 : 1;\\n\\n\\t\\t\\t\\tif ( geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\t\\tvar index = geometry.index;\\n\\t\\t\\t\\t\\tvar attributes = geometry.attributes;\\n\\t\\t\\t\\t\\tvar positions = attributes.position.array;\\n\\n\\t\\t\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\t\\t\\tvar indices = index.array;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, l = indices.length - 1; i < l; i += step ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar a = indices[ i ];\\n\\t\\t\\t\\t\\t\\t\\tvar b = indices[ i + 1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\tvStart.fromArray( positions, a * 3 );\\n\\t\\t\\t\\t\\t\\t\\tvEnd.fromArray( positions, b * 3 );\\n\\n\\t\\t\\t\\t\\t\\t\\tvar distSq = ray.distanceSqToSegment( vStart, vEnd, interRay, interSegment );\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( distSq > precisionSq ) continue;\\n\\n\\t\\t\\t\\t\\t\\t\\tinterRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation\\n\\n\\t\\t\\t\\t\\t\\t\\tvar distance = raycaster.ray.origin.distanceTo( interRay );\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( distance < raycaster.near || distance > raycaster.far ) continue;\\n\\n\\t\\t\\t\\t\\t\\t\\tintersects.push( {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tdistance: distance,\\n\\t\\t\\t\\t\\t\\t\\t\\t// What do we want? intersection point on the ray or on the segment??\\n\\t\\t\\t\\t\\t\\t\\t\\t// point: raycaster.ray.at( distance ),\\n\\t\\t\\t\\t\\t\\t\\t\\tpoint: interSegment.clone().applyMatrix4( this.matrixWorld ),\\n\\t\\t\\t\\t\\t\\t\\t\\tindex: i,\\n\\t\\t\\t\\t\\t\\t\\t\\tface: null,\\n\\t\\t\\t\\t\\t\\t\\t\\tfaceIndex: null,\\n\\t\\t\\t\\t\\t\\t\\t\\tobject: this\\n\\n\\t\\t\\t\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, l = positions.length / 3 - 1; i < l; i += step ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvStart.fromArray( positions, 3 * i );\\n\\t\\t\\t\\t\\t\\t\\tvEnd.fromArray( positions, 3 * i + 3 );\\n\\n\\t\\t\\t\\t\\t\\t\\tvar distSq = ray.distanceSqToSegment( vStart, vEnd, interRay, interSegment );\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( distSq > precisionSq ) continue;\\n\\n\\t\\t\\t\\t\\t\\t\\tinterRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation\\n\\n\\t\\t\\t\\t\\t\\t\\tvar distance = raycaster.ray.origin.distanceTo( interRay );\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( distance < raycaster.near || distance > raycaster.far ) continue;\\n\\n\\t\\t\\t\\t\\t\\t\\tintersects.push( {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tdistance: distance,\\n\\t\\t\\t\\t\\t\\t\\t\\t// What do we want? intersection point on the ray or on the segment??\\n\\t\\t\\t\\t\\t\\t\\t\\t// point: raycaster.ray.at( distance ),\\n\\t\\t\\t\\t\\t\\t\\t\\tpoint: interSegment.clone().applyMatrix4( this.matrixWorld ),\\n\\t\\t\\t\\t\\t\\t\\t\\tindex: i,\\n\\t\\t\\t\\t\\t\\t\\t\\tface: null,\\n\\t\\t\\t\\t\\t\\t\\t\\tfaceIndex: null,\\n\\t\\t\\t\\t\\t\\t\\t\\tobject: this\\n\\n\\t\\t\\t\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( geometry.isGeometry ) {\\n\\n\\t\\t\\t\\t\\tvar vertices = geometry.vertices;\\n\\t\\t\\t\\t\\tvar nbVertices = vertices.length;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < nbVertices - 1; i += step ) {\\n\\n\\t\\t\\t\\t\\t\\tvar distSq = ray.distanceSqToSegment( vertices[ i ], vertices[ i + 1 ], interRay, interSegment );\\n\\n\\t\\t\\t\\t\\t\\tif ( distSq > precisionSq ) continue;\\n\\n\\t\\t\\t\\t\\t\\tinterRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation\\n\\n\\t\\t\\t\\t\\t\\tvar distance = raycaster.ray.origin.distanceTo( interRay );\\n\\n\\t\\t\\t\\t\\t\\tif ( distance < raycaster.near || distance > raycaster.far ) continue;\\n\\n\\t\\t\\t\\t\\t\\tintersects.push( {\\n\\n\\t\\t\\t\\t\\t\\t\\tdistance: distance,\\n\\t\\t\\t\\t\\t\\t\\t// What do we want? intersection point on the ray or on the segment??\\n\\t\\t\\t\\t\\t\\t\\t// point: raycaster.ray.at( distance ),\\n\\t\\t\\t\\t\\t\\t\\tpoint: interSegment.clone().applyMatrix4( this.matrixWorld ),\\n\\t\\t\\t\\t\\t\\t\\tindex: i,\\n\\t\\t\\t\\t\\t\\t\\tface: null,\\n\\t\\t\\t\\t\\t\\t\\tfaceIndex: null,\\n\\t\\t\\t\\t\\t\\t\\tobject: this\\n\\n\\t\\t\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}() ),\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.geometry, this.material ).copy( this );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction LineSegments( geometry, material ) {\\n\\n\\t\\tLine.call( this, geometry, material );\\n\\n\\t\\tthis.type = 'LineSegments';\\n\\n\\t}\\n\\n\\tLineSegments.prototype = Object.assign( Object.create( Line.prototype ), {\\n\\n\\t\\tconstructor: LineSegments,\\n\\n\\t\\tisLineSegments: true\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mgreter / http://github.com/mgreter\\n\\t */\\n\\n\\tfunction LineLoop( geometry, material ) {\\n\\n\\t\\tLine.call( this, geometry, material );\\n\\n\\t\\tthis.type = 'LineLoop';\\n\\n\\t}\\n\\n\\tLineLoop.prototype = Object.assign( Object.create( Line.prototype ), {\\n\\n\\t\\tconstructor: LineLoop,\\n\\n\\t\\tisLineLoop: true,\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * parameters = {\\n\\t * color: ,\\n\\t * opacity: ,\\n\\t * map: new THREE.Texture( ),\\n\\t *\\n\\t * size: ,\\n\\t * sizeAttenuation: \\n\\t * }\\n\\t */\\n\\n\\tfunction PointsMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'PointsMaterial';\\n\\n\\t\\tthis.color = new Color( 0xffffff );\\n\\n\\t\\tthis.map = null;\\n\\n\\t\\tthis.size = 1;\\n\\t\\tthis.sizeAttenuation = true;\\n\\n\\t\\tthis.lights = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tPointsMaterial.prototype = Object.create( Material.prototype );\\n\\tPointsMaterial.prototype.constructor = PointsMaterial;\\n\\n\\tPointsMaterial.prototype.isPointsMaterial = true;\\n\\n\\tPointsMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.color.copy( source.color );\\n\\n\\t\\tthis.map = source.map;\\n\\n\\t\\tthis.size = source.size;\\n\\t\\tthis.sizeAttenuation = source.sizeAttenuation;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction Points( geometry, material ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Points';\\n\\n\\t\\tthis.geometry = geometry !== undefined ? geometry : new BufferGeometry();\\n\\t\\tthis.material = material !== undefined ? material : new PointsMaterial( { color: Math.random() * 0xffffff } );\\n\\n\\t}\\n\\n\\tPoints.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Points,\\n\\n\\t\\tisPoints: true,\\n\\n\\t\\traycast: ( function () {\\n\\n\\t\\t\\tvar inverseMatrix = new Matrix4();\\n\\t\\t\\tvar ray = new Ray();\\n\\t\\t\\tvar sphere = new Sphere();\\n\\n\\t\\t\\treturn function raycast( raycaster, intersects ) {\\n\\n\\t\\t\\t\\tvar object = this;\\n\\t\\t\\t\\tvar geometry = this.geometry;\\n\\t\\t\\t\\tvar matrixWorld = this.matrixWorld;\\n\\t\\t\\t\\tvar threshold = raycaster.params.Points.threshold;\\n\\n\\t\\t\\t\\t// Checking boundingSphere distance to ray\\n\\n\\t\\t\\t\\tif ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();\\n\\n\\t\\t\\t\\tsphere.copy( geometry.boundingSphere );\\n\\t\\t\\t\\tsphere.applyMatrix4( matrixWorld );\\n\\t\\t\\t\\tsphere.radius += threshold;\\n\\n\\t\\t\\t\\tif ( raycaster.ray.intersectsSphere( sphere ) === false ) return;\\n\\n\\t\\t\\t\\t//\\n\\n\\t\\t\\t\\tinverseMatrix.getInverse( matrixWorld );\\n\\t\\t\\t\\tray.copy( raycaster.ray ).applyMatrix4( inverseMatrix );\\n\\n\\t\\t\\t\\tvar localThreshold = threshold / ( ( this.scale.x + this.scale.y + this.scale.z ) / 3 );\\n\\t\\t\\t\\tvar localThresholdSq = localThreshold * localThreshold;\\n\\t\\t\\t\\tvar position = new Vector3();\\n\\n\\t\\t\\t\\tfunction testPoint( point, index ) {\\n\\n\\t\\t\\t\\t\\tvar rayPointDistanceSq = ray.distanceSqToPoint( point );\\n\\n\\t\\t\\t\\t\\tif ( rayPointDistanceSq < localThresholdSq ) {\\n\\n\\t\\t\\t\\t\\t\\tvar intersectPoint = ray.closestPointToPoint( point );\\n\\t\\t\\t\\t\\t\\tintersectPoint.applyMatrix4( matrixWorld );\\n\\n\\t\\t\\t\\t\\t\\tvar distance = raycaster.ray.origin.distanceTo( intersectPoint );\\n\\n\\t\\t\\t\\t\\t\\tif ( distance < raycaster.near || distance > raycaster.far ) return;\\n\\n\\t\\t\\t\\t\\t\\tintersects.push( {\\n\\n\\t\\t\\t\\t\\t\\t\\tdistance: distance,\\n\\t\\t\\t\\t\\t\\t\\tdistanceToRay: Math.sqrt( rayPointDistanceSq ),\\n\\t\\t\\t\\t\\t\\t\\tpoint: intersectPoint.clone(),\\n\\t\\t\\t\\t\\t\\t\\tindex: index,\\n\\t\\t\\t\\t\\t\\t\\tface: null,\\n\\t\\t\\t\\t\\t\\t\\tobject: object\\n\\n\\t\\t\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\t\\tvar index = geometry.index;\\n\\t\\t\\t\\t\\tvar attributes = geometry.attributes;\\n\\t\\t\\t\\t\\tvar positions = attributes.position.array;\\n\\n\\t\\t\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\t\\t\\tvar indices = index.array;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, il = indices.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar a = indices[ i ];\\n\\n\\t\\t\\t\\t\\t\\t\\tposition.fromArray( positions, a * 3 );\\n\\n\\t\\t\\t\\t\\t\\t\\ttestPoint( position, a );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, l = positions.length / 3; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tposition.fromArray( positions, i * 3 );\\n\\n\\t\\t\\t\\t\\t\\t\\ttestPoint( position, i );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tvar vertices = geometry.vertices;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, l = vertices.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\ttestPoint( vertices[ i ], i );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}() ),\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.geometry, this.material ).copy( this );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Group() {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Group';\\n\\n\\t}\\n\\n\\tGroup.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Group,\\n\\n\\t\\tisGroup: true\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction VideoTexture( video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) {\\n\\n\\t\\tTexture.call( this, video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );\\n\\n\\t\\tthis.generateMipmaps = false;\\n\\n\\t\\t// Set needsUpdate when first frame is ready\\n\\n\\t\\tvar scope = this;\\n\\n\\t\\tfunction onLoaded() {\\n\\n\\t\\t\\tvideo.removeEventListener( 'loadeddata', onLoaded, false );\\n\\t\\t\\tscope.needsUpdate = true;\\n\\n\\t\\t}\\n\\n\\t\\tvideo.addEventListener( 'loadeddata', onLoaded, false );\\n\\n\\t}\\n\\n\\tVideoTexture.prototype = Object.assign( Object.create( Texture.prototype ), {\\n\\n\\t\\tconstructor: VideoTexture,\\n\\n\\t\\tisVideoTexture: true,\\n\\n\\t\\tupdate: function () {\\n\\n\\t\\t\\tvar video = this.image;\\n\\n\\t\\t\\tif ( video.readyState >= video.HAVE_CURRENT_DATA ) {\\n\\n\\t\\t\\t\\tthis.needsUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction CompressedTexture( mipmaps, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, encoding ) {\\n\\n\\t\\tTexture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding );\\n\\n\\t\\tthis.image = { width: width, height: height };\\n\\t\\tthis.mipmaps = mipmaps;\\n\\n\\t\\t// no flipping for cube textures\\n\\t\\t// (also flipping doesn't work for compressed textures )\\n\\n\\t\\tthis.flipY = false;\\n\\n\\t\\t// can't generate mipmaps for compressed textures\\n\\t\\t// mips must be embedded in DDS files\\n\\n\\t\\tthis.generateMipmaps = false;\\n\\n\\t}\\n\\n\\tCompressedTexture.prototype = Object.create( Texture.prototype );\\n\\tCompressedTexture.prototype.constructor = CompressedTexture;\\n\\n\\tCompressedTexture.prototype.isCompressedTexture = true;\\n\\n\\t/**\\n\\t * @author Matt DesLauriers / @mattdesl\\n\\t * @author atix / arthursilber.de\\n\\t */\\n\\n\\tfunction DepthTexture( width, height, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, format ) {\\n\\n\\t\\tformat = format !== undefined ? format : DepthFormat;\\n\\n\\t\\tif ( format !== DepthFormat && format !== DepthStencilFormat ) {\\n\\n\\t\\t\\tthrow new Error( 'DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat' );\\n\\n\\t\\t}\\n\\n\\t\\tif ( type === undefined && format === DepthFormat ) type = UnsignedShortType;\\n\\t\\tif ( type === undefined && format === DepthStencilFormat ) type = UnsignedInt248Type;\\n\\n\\t\\tTexture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );\\n\\n\\t\\tthis.image = { width: width, height: height };\\n\\n\\t\\tthis.magFilter = magFilter !== undefined ? magFilter : NearestFilter;\\n\\t\\tthis.minFilter = minFilter !== undefined ? minFilter : NearestFilter;\\n\\n\\t\\tthis.flipY = false;\\n\\t\\tthis.generateMipmaps\\t= false;\\n\\n\\t}\\n\\n\\tDepthTexture.prototype = Object.create( Texture.prototype );\\n\\tDepthTexture.prototype.constructor = DepthTexture;\\n\\tDepthTexture.prototype.isDepthTexture = true;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\tfunction WireframeGeometry( geometry ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'WireframeGeometry';\\n\\n\\t\\t// buffer\\n\\n\\t\\tvar vertices = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar i, j, l, o, ol;\\n\\t\\tvar edge = [ 0, 0 ], edges = {}, e, edge1, edge2;\\n\\t\\tvar key, keys = [ 'a', 'b', 'c' ];\\n\\t\\tvar vertex;\\n\\n\\t\\t// different logic for Geometry and BufferGeometry\\n\\n\\t\\tif ( geometry && geometry.isGeometry ) {\\n\\n\\t\\t\\t// create a data structure that contains all edges without duplicates\\n\\n\\t\\t\\tvar faces = geometry.faces;\\n\\n\\t\\t\\tfor ( i = 0, l = faces.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar face = faces[ i ];\\n\\n\\t\\t\\t\\tfor ( j = 0; j < 3; j ++ ) {\\n\\n\\t\\t\\t\\t\\tedge1 = face[ keys[ j ] ];\\n\\t\\t\\t\\t\\tedge2 = face[ keys[ ( j + 1 ) % 3 ] ];\\n\\t\\t\\t\\t\\tedge[ 0 ] = Math.min( edge1, edge2 ); // sorting prevents duplicates\\n\\t\\t\\t\\t\\tedge[ 1 ] = Math.max( edge1, edge2 );\\n\\n\\t\\t\\t\\t\\tkey = edge[ 0 ] + ',' + edge[ 1 ];\\n\\n\\t\\t\\t\\t\\tif ( edges[ key ] === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tedges[ key ] = { index1: edge[ 0 ], index2: edge[ 1 ] };\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// generate vertices\\n\\n\\t\\t\\tfor ( key in edges ) {\\n\\n\\t\\t\\t\\te = edges[ key ];\\n\\n\\t\\t\\t\\tvertex = geometry.vertices[ e.index1 ];\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\tvertex = geometry.vertices[ e.index2 ];\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t}\\n\\n\\t\\t} else if ( geometry && geometry.isBufferGeometry ) {\\n\\n\\t\\t\\tvar position, indices, groups;\\n\\t\\t\\tvar group, start, count;\\n\\t\\t\\tvar index1, index2;\\n\\n\\t\\t\\tvertex = new Vector3();\\n\\n\\t\\t\\tif ( geometry.index !== null ) {\\n\\n\\t\\t\\t\\t// indexed BufferGeometry\\n\\n\\t\\t\\t\\tposition = geometry.attributes.position;\\n\\t\\t\\t\\tindices = geometry.index;\\n\\t\\t\\t\\tgroups = geometry.groups;\\n\\n\\t\\t\\t\\tif ( groups.length === 0 ) {\\n\\n\\t\\t\\t\\t\\tgroups = [ { start: 0, count: indices.count, materialIndex: 0 } ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// create a data structure that contains all eges without duplicates\\n\\n\\t\\t\\t\\tfor ( o = 0, ol = groups.length; o < ol; ++ o ) {\\n\\n\\t\\t\\t\\t\\tgroup = groups[ o ];\\n\\n\\t\\t\\t\\t\\tstart = group.start;\\n\\t\\t\\t\\t\\tcount = group.count;\\n\\n\\t\\t\\t\\t\\tfor ( i = start, l = ( start + count ); i < l; i += 3 ) {\\n\\n\\t\\t\\t\\t\\t\\tfor ( j = 0; j < 3; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tedge1 = indices.getX( i + j );\\n\\t\\t\\t\\t\\t\\t\\tedge2 = indices.getX( i + ( j + 1 ) % 3 );\\n\\t\\t\\t\\t\\t\\t\\tedge[ 0 ] = Math.min( edge1, edge2 ); // sorting prevents duplicates\\n\\t\\t\\t\\t\\t\\t\\tedge[ 1 ] = Math.max( edge1, edge2 );\\n\\n\\t\\t\\t\\t\\t\\t\\tkey = edge[ 0 ] + ',' + edge[ 1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( edges[ key ] === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tedges[ key ] = { index1: edge[ 0 ], index2: edge[ 1 ] };\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// generate vertices\\n\\n\\t\\t\\t\\tfor ( key in edges ) {\\n\\n\\t\\t\\t\\t\\te = edges[ key ];\\n\\n\\t\\t\\t\\t\\tvertex.fromBufferAttribute( position, e.index1 );\\n\\t\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t\\tvertex.fromBufferAttribute( position, e.index2 );\\n\\t\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// non-indexed BufferGeometry\\n\\n\\t\\t\\t\\tposition = geometry.attributes.position;\\n\\n\\t\\t\\t\\tfor ( i = 0, l = ( position.count / 3 ); i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tfor ( j = 0; j < 3; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t// three edges per triangle, an edge is represented as (index1, index2)\\n\\t\\t\\t\\t\\t\\t// e.g. the first triangle has the following edges: (0,1),(1,2),(2,0)\\n\\n\\t\\t\\t\\t\\t\\tindex1 = 3 * i + j;\\n\\t\\t\\t\\t\\t\\tvertex.fromBufferAttribute( position, index1 );\\n\\t\\t\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t\\t\\tindex2 = 3 * i + ( ( j + 1 ) % 3 );\\n\\t\\t\\t\\t\\t\\tvertex.fromBufferAttribute( position, index2 );\\n\\t\\t\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\n\\t}\\n\\n\\tWireframeGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tWireframeGeometry.prototype.constructor = WireframeGeometry;\\n\\n\\t/**\\n\\t * @author zz85 / https://github.com/zz85\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t *\\n\\t * Parametric Surfaces Geometry\\n\\t * based on the brilliant article by @prideout http://prideout.net/blog/?p=44\\n\\t */\\n\\n\\t// ParametricGeometry\\n\\n\\tfunction ParametricGeometry( func, slices, stacks ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'ParametricGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tfunc: func,\\n\\t\\t\\tslices: slices,\\n\\t\\t\\tstacks: stacks\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new ParametricBufferGeometry( func, slices, stacks ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tParametricGeometry.prototype = Object.create( Geometry.prototype );\\n\\tParametricGeometry.prototype.constructor = ParametricGeometry;\\n\\n\\t// ParametricBufferGeometry\\n\\n\\tfunction ParametricBufferGeometry( func, slices, stacks ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'ParametricBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tfunc: func,\\n\\t\\t\\tslices: slices,\\n\\t\\t\\tstacks: stacks\\n\\t\\t};\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\tvar EPS = 0.00001;\\n\\n\\t\\tvar normal = new Vector3();\\n\\n\\t\\tvar p0 = new Vector3(), p1 = new Vector3();\\n\\t\\tvar pu = new Vector3(), pv = new Vector3();\\n\\n\\t\\tvar i, j;\\n\\n\\t\\t// generate vertices, normals and uvs\\n\\n\\t\\tvar sliceCount = slices + 1;\\n\\n\\t\\tfor ( i = 0; i <= stacks; i ++ ) {\\n\\n\\t\\t\\tvar v = i / stacks;\\n\\n\\t\\t\\tfor ( j = 0; j <= slices; j ++ ) {\\n\\n\\t\\t\\t\\tvar u = j / slices;\\n\\n\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\tp0 = func( u, v, p0 );\\n\\t\\t\\t\\tvertices.push( p0.x, p0.y, p0.z );\\n\\n\\t\\t\\t\\t// normal\\n\\n\\t\\t\\t\\t// approximate tangent vectors via finite differences\\n\\n\\t\\t\\t\\tif ( u - EPS >= 0 ) {\\n\\n\\t\\t\\t\\t\\tp1 = func( u - EPS, v, p1 );\\n\\t\\t\\t\\t\\tpu.subVectors( p0, p1 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tp1 = func( u + EPS, v, p1 );\\n\\t\\t\\t\\t\\tpu.subVectors( p1, p0 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( v - EPS >= 0 ) {\\n\\n\\t\\t\\t\\t\\tp1 = func( u, v - EPS, p1 );\\n\\t\\t\\t\\t\\tpv.subVectors( p0, p1 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tp1 = func( u, v + EPS, p1 );\\n\\t\\t\\t\\t\\tpv.subVectors( p1, p0 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// cross product of tangent vectors returns surface normal\\n\\n\\t\\t\\t\\tnormal.crossVectors( pu, pv ).normalize();\\n\\t\\t\\t\\tnormals.push( normal.x, normal.y, normal.z );\\n\\n\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\tuvs.push( u, v );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// generate indices\\n\\n\\t\\tfor ( i = 0; i < stacks; i ++ ) {\\n\\n\\t\\t\\tfor ( j = 0; j < slices; j ++ ) {\\n\\n\\t\\t\\t\\tvar a = i * sliceCount + j;\\n\\t\\t\\t\\tvar b = i * sliceCount + j + 1;\\n\\t\\t\\t\\tvar c = ( i + 1 ) * sliceCount + j + 1;\\n\\t\\t\\t\\tvar d = ( i + 1 ) * sliceCount + j;\\n\\n\\t\\t\\t\\t// faces one and two\\n\\n\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t}\\n\\n\\tParametricBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tParametricBufferGeometry.prototype.constructor = ParametricBufferGeometry;\\n\\n\\t/**\\n\\t * @author clockworkgeek / https://github.com/clockworkgeek\\n\\t * @author timothypratley / https://github.com/timothypratley\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// PolyhedronGeometry\\n\\n\\tfunction PolyhedronGeometry( vertices, indices, radius, detail ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'PolyhedronGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tvertices: vertices,\\n\\t\\t\\tindices: indices,\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new PolyhedronBufferGeometry( vertices, indices, radius, detail ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tPolyhedronGeometry.prototype = Object.create( Geometry.prototype );\\n\\tPolyhedronGeometry.prototype.constructor = PolyhedronGeometry;\\n\\n\\t// PolyhedronBufferGeometry\\n\\n\\tfunction PolyhedronBufferGeometry( vertices, indices, radius, detail ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'PolyhedronBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tvertices: vertices,\\n\\t\\t\\tindices: indices,\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t\\tradius = radius || 1;\\n\\t\\tdetail = detail || 0;\\n\\n\\t\\t// default buffer data\\n\\n\\t\\tvar vertexBuffer = [];\\n\\t\\tvar uvBuffer = [];\\n\\n\\t\\t// the subdivision creates the vertex buffer data\\n\\n\\t\\tsubdivide( detail );\\n\\n\\t\\t// all vertices should lie on a conceptual sphere with a given radius\\n\\n\\t\\tappplyRadius( radius );\\n\\n\\t\\t// finally, create the uv data\\n\\n\\t\\tgenerateUVs();\\n\\n\\t\\t// build non-indexed geometry\\n\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertexBuffer, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( vertexBuffer.slice(), 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvBuffer, 2 ) );\\n\\n\\t\\tif ( detail === 0 ) {\\n\\n\\t\\t\\tthis.computeVertexNormals(); // flat normals\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tthis.normalizeNormals(); // smooth normals\\n\\n\\t\\t}\\n\\n\\t\\t// helper functions\\n\\n\\t\\tfunction subdivide( detail ) {\\n\\n\\t\\t\\tvar a = new Vector3();\\n\\t\\t\\tvar b = new Vector3();\\n\\t\\t\\tvar c = new Vector3();\\n\\n\\t\\t\\t// iterate over all faces and apply a subdivison with the given detail value\\n\\n\\t\\t\\tfor ( var i = 0; i < indices.length; i += 3 ) {\\n\\n\\t\\t\\t\\t// get the vertices of the face\\n\\n\\t\\t\\t\\tgetVertexByIndex( indices[ i + 0 ], a );\\n\\t\\t\\t\\tgetVertexByIndex( indices[ i + 1 ], b );\\n\\t\\t\\t\\tgetVertexByIndex( indices[ i + 2 ], c );\\n\\n\\t\\t\\t\\t// perform subdivision\\n\\n\\t\\t\\t\\tsubdivideFace( a, b, c, detail );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction subdivideFace( a, b, c, detail ) {\\n\\n\\t\\t\\tvar cols = Math.pow( 2, detail );\\n\\n\\t\\t\\t// we use this multidimensional array as a data structure for creating the subdivision\\n\\n\\t\\t\\tvar v = [];\\n\\n\\t\\t\\tvar i, j;\\n\\n\\t\\t\\t// construct all of the vertices for this subdivision\\n\\n\\t\\t\\tfor ( i = 0; i <= cols; i ++ ) {\\n\\n\\t\\t\\t\\tv[ i ] = [];\\n\\n\\t\\t\\t\\tvar aj = a.clone().lerp( c, i / cols );\\n\\t\\t\\t\\tvar bj = b.clone().lerp( c, i / cols );\\n\\n\\t\\t\\t\\tvar rows = cols - i;\\n\\n\\t\\t\\t\\tfor ( j = 0; j <= rows; j ++ ) {\\n\\n\\t\\t\\t\\t\\tif ( j === 0 && i === cols ) {\\n\\n\\t\\t\\t\\t\\t\\tv[ i ][ j ] = aj;\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tv[ i ][ j ] = aj.clone().lerp( bj, j / rows );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// construct all of the faces\\n\\n\\t\\t\\tfor ( i = 0; i < cols; i ++ ) {\\n\\n\\t\\t\\t\\tfor ( j = 0; j < 2 * ( cols - i ) - 1; j ++ ) {\\n\\n\\t\\t\\t\\t\\tvar k = Math.floor( j / 2 );\\n\\n\\t\\t\\t\\t\\tif ( j % 2 === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tpushVertex( v[ i ][ k + 1 ] );\\n\\t\\t\\t\\t\\t\\tpushVertex( v[ i + 1 ][ k ] );\\n\\t\\t\\t\\t\\t\\tpushVertex( v[ i ][ k ] );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tpushVertex( v[ i ][ k + 1 ] );\\n\\t\\t\\t\\t\\t\\tpushVertex( v[ i + 1 ][ k + 1 ] );\\n\\t\\t\\t\\t\\t\\tpushVertex( v[ i + 1 ][ k ] );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction appplyRadius( radius ) {\\n\\n\\t\\t\\tvar vertex = new Vector3();\\n\\n\\t\\t\\t// iterate over the entire buffer and apply the radius to each vertex\\n\\n\\t\\t\\tfor ( var i = 0; i < vertexBuffer.length; i += 3 ) {\\n\\n\\t\\t\\t\\tvertex.x = vertexBuffer[ i + 0 ];\\n\\t\\t\\t\\tvertex.y = vertexBuffer[ i + 1 ];\\n\\t\\t\\t\\tvertex.z = vertexBuffer[ i + 2 ];\\n\\n\\t\\t\\t\\tvertex.normalize().multiplyScalar( radius );\\n\\n\\t\\t\\t\\tvertexBuffer[ i + 0 ] = vertex.x;\\n\\t\\t\\t\\tvertexBuffer[ i + 1 ] = vertex.y;\\n\\t\\t\\t\\tvertexBuffer[ i + 2 ] = vertex.z;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction generateUVs() {\\n\\n\\t\\t\\tvar vertex = new Vector3();\\n\\n\\t\\t\\tfor ( var i = 0; i < vertexBuffer.length; i += 3 ) {\\n\\n\\t\\t\\t\\tvertex.x = vertexBuffer[ i + 0 ];\\n\\t\\t\\t\\tvertex.y = vertexBuffer[ i + 1 ];\\n\\t\\t\\t\\tvertex.z = vertexBuffer[ i + 2 ];\\n\\n\\t\\t\\t\\tvar u = azimuth( vertex ) / 2 / Math.PI + 0.5;\\n\\t\\t\\t\\tvar v = inclination( vertex ) / Math.PI + 0.5;\\n\\t\\t\\t\\tuvBuffer.push( u, 1 - v );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tcorrectUVs();\\n\\n\\t\\t\\tcorrectSeam();\\n\\n\\t\\t}\\n\\n\\t\\tfunction correctSeam() {\\n\\n\\t\\t\\t// handle case when face straddles the seam, see #3269\\n\\n\\t\\t\\tfor ( var i = 0; i < uvBuffer.length; i += 6 ) {\\n\\n\\t\\t\\t\\t// uv data of a single face\\n\\n\\t\\t\\t\\tvar x0 = uvBuffer[ i + 0 ];\\n\\t\\t\\t\\tvar x1 = uvBuffer[ i + 2 ];\\n\\t\\t\\t\\tvar x2 = uvBuffer[ i + 4 ];\\n\\n\\t\\t\\t\\tvar max = Math.max( x0, x1, x2 );\\n\\t\\t\\t\\tvar min = Math.min( x0, x1, x2 );\\n\\n\\t\\t\\t\\t// 0.9 is somewhat arbitrary\\n\\n\\t\\t\\t\\tif ( max > 0.9 && min < 0.1 ) {\\n\\n\\t\\t\\t\\t\\tif ( x0 < 0.2 ) uvBuffer[ i + 0 ] += 1;\\n\\t\\t\\t\\t\\tif ( x1 < 0.2 ) uvBuffer[ i + 2 ] += 1;\\n\\t\\t\\t\\t\\tif ( x2 < 0.2 ) uvBuffer[ i + 4 ] += 1;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction pushVertex( vertex ) {\\n\\n\\t\\t\\tvertexBuffer.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t}\\n\\n\\t\\tfunction getVertexByIndex( index, vertex ) {\\n\\n\\t\\t\\tvar stride = index * 3;\\n\\n\\t\\t\\tvertex.x = vertices[ stride + 0 ];\\n\\t\\t\\tvertex.y = vertices[ stride + 1 ];\\n\\t\\t\\tvertex.z = vertices[ stride + 2 ];\\n\\n\\t\\t}\\n\\n\\t\\tfunction correctUVs() {\\n\\n\\t\\t\\tvar a = new Vector3();\\n\\t\\t\\tvar b = new Vector3();\\n\\t\\t\\tvar c = new Vector3();\\n\\n\\t\\t\\tvar centroid = new Vector3();\\n\\n\\t\\t\\tvar uvA = new Vector2();\\n\\t\\t\\tvar uvB = new Vector2();\\n\\t\\t\\tvar uvC = new Vector2();\\n\\n\\t\\t\\tfor ( var i = 0, j = 0; i < vertexBuffer.length; i += 9, j += 6 ) {\\n\\n\\t\\t\\t\\ta.set( vertexBuffer[ i + 0 ], vertexBuffer[ i + 1 ], vertexBuffer[ i + 2 ] );\\n\\t\\t\\t\\tb.set( vertexBuffer[ i + 3 ], vertexBuffer[ i + 4 ], vertexBuffer[ i + 5 ] );\\n\\t\\t\\t\\tc.set( vertexBuffer[ i + 6 ], vertexBuffer[ i + 7 ], vertexBuffer[ i + 8 ] );\\n\\n\\t\\t\\t\\tuvA.set( uvBuffer[ j + 0 ], uvBuffer[ j + 1 ] );\\n\\t\\t\\t\\tuvB.set( uvBuffer[ j + 2 ], uvBuffer[ j + 3 ] );\\n\\t\\t\\t\\tuvC.set( uvBuffer[ j + 4 ], uvBuffer[ j + 5 ] );\\n\\n\\t\\t\\t\\tcentroid.copy( a ).add( b ).add( c ).divideScalar( 3 );\\n\\n\\t\\t\\t\\tvar azi = azimuth( centroid );\\n\\n\\t\\t\\t\\tcorrectUV( uvA, j + 0, a, azi );\\n\\t\\t\\t\\tcorrectUV( uvB, j + 2, b, azi );\\n\\t\\t\\t\\tcorrectUV( uvC, j + 4, c, azi );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction correctUV( uv, stride, vector, azimuth ) {\\n\\n\\t\\t\\tif ( ( azimuth < 0 ) && ( uv.x === 1 ) ) {\\n\\n\\t\\t\\t\\tuvBuffer[ stride ] = uv.x - 1;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( ( vector.x === 0 ) && ( vector.z === 0 ) ) {\\n\\n\\t\\t\\t\\tuvBuffer[ stride ] = azimuth / 2 / Math.PI + 0.5;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// Angle around the Y axis, counter-clockwise when looking from above.\\n\\n\\t\\tfunction azimuth( vector ) {\\n\\n\\t\\t\\treturn Math.atan2( vector.z, - vector.x );\\n\\n\\t\\t}\\n\\n\\n\\t\\t// Angle above the XZ plane.\\n\\n\\t\\tfunction inclination( vector ) {\\n\\n\\t\\t\\treturn Math.atan2( - vector.y, Math.sqrt( ( vector.x * vector.x ) + ( vector.z * vector.z ) ) );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tPolyhedronBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tPolyhedronBufferGeometry.prototype.constructor = PolyhedronBufferGeometry;\\n\\n\\t/**\\n\\t * @author timothypratley / https://github.com/timothypratley\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// TetrahedronGeometry\\n\\n\\tfunction TetrahedronGeometry( radius, detail ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'TetrahedronGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new TetrahedronBufferGeometry( radius, detail ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tTetrahedronGeometry.prototype = Object.create( Geometry.prototype );\\n\\tTetrahedronGeometry.prototype.constructor = TetrahedronGeometry;\\n\\n\\t// TetrahedronBufferGeometry\\n\\n\\tfunction TetrahedronBufferGeometry( radius, detail ) {\\n\\n\\t\\tvar vertices = [\\n\\t\\t\\t1, 1, 1, \\t- 1, - 1, 1, \\t- 1, 1, - 1, \\t1, - 1, - 1\\n\\t\\t];\\n\\n\\t\\tvar indices = [\\n\\t\\t\\t2, 1, 0, \\t0, 3, 2,\\t1, 3, 0,\\t2, 3, 1\\n\\t\\t];\\n\\n\\t\\tPolyhedronBufferGeometry.call( this, vertices, indices, radius, detail );\\n\\n\\t\\tthis.type = 'TetrahedronBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t}\\n\\n\\tTetrahedronBufferGeometry.prototype = Object.create( PolyhedronBufferGeometry.prototype );\\n\\tTetrahedronBufferGeometry.prototype.constructor = TetrahedronBufferGeometry;\\n\\n\\t/**\\n\\t * @author timothypratley / https://github.com/timothypratley\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// OctahedronGeometry\\n\\n\\tfunction OctahedronGeometry( radius, detail ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'OctahedronGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new OctahedronBufferGeometry( radius, detail ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tOctahedronGeometry.prototype = Object.create( Geometry.prototype );\\n\\tOctahedronGeometry.prototype.constructor = OctahedronGeometry;\\n\\n\\t// OctahedronBufferGeometry\\n\\n\\tfunction OctahedronBufferGeometry( radius, detail ) {\\n\\n\\t\\tvar vertices = [\\n\\t\\t\\t1, 0, 0, \\t- 1, 0, 0,\\t0, 1, 0,\\n\\t\\t\\t0, - 1, 0, \\t0, 0, 1,\\t0, 0, - 1\\n\\t\\t];\\n\\n\\t\\tvar indices = [\\n\\t\\t\\t0, 2, 4,\\t0, 4, 3,\\t0, 3, 5,\\n\\t\\t\\t0, 5, 2,\\t1, 2, 5,\\t1, 5, 3,\\n\\t\\t\\t1, 3, 4,\\t1, 4, 2\\n\\t\\t];\\n\\n\\t\\tPolyhedronBufferGeometry.call( this, vertices, indices, radius, detail );\\n\\n\\t\\tthis.type = 'OctahedronBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t}\\n\\n\\tOctahedronBufferGeometry.prototype = Object.create( PolyhedronBufferGeometry.prototype );\\n\\tOctahedronBufferGeometry.prototype.constructor = OctahedronBufferGeometry;\\n\\n\\t/**\\n\\t * @author timothypratley / https://github.com/timothypratley\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// IcosahedronGeometry\\n\\n\\tfunction IcosahedronGeometry( radius, detail ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'IcosahedronGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new IcosahedronBufferGeometry( radius, detail ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tIcosahedronGeometry.prototype = Object.create( Geometry.prototype );\\n\\tIcosahedronGeometry.prototype.constructor = IcosahedronGeometry;\\n\\n\\t// IcosahedronBufferGeometry\\n\\n\\tfunction IcosahedronBufferGeometry( radius, detail ) {\\n\\n\\t\\tvar t = ( 1 + Math.sqrt( 5 ) ) / 2;\\n\\n\\t\\tvar vertices = [\\n\\t\\t\\t- 1, t, 0, \\t1, t, 0, \\t- 1, - t, 0, \\t1, - t, 0,\\n\\t\\t\\t 0, - 1, t, \\t0, 1, t,\\t0, - 1, - t, \\t0, 1, - t,\\n\\t\\t\\t t, 0, - 1, \\tt, 0, 1, \\t- t, 0, - 1, \\t- t, 0, 1\\n\\t\\t];\\n\\n\\t\\tvar indices = [\\n\\t\\t\\t 0, 11, 5, \\t0, 5, 1, \\t0, 1, 7, \\t0, 7, 10, \\t0, 10, 11,\\n\\t\\t\\t 1, 5, 9, \\t5, 11, 4,\\t11, 10, 2,\\t10, 7, 6,\\t7, 1, 8,\\n\\t\\t\\t 3, 9, 4, \\t3, 4, 2,\\t3, 2, 6,\\t3, 6, 8,\\t3, 8, 9,\\n\\t\\t\\t 4, 9, 5, \\t2, 4, 11,\\t6, 2, 10,\\t8, 6, 7,\\t9, 8, 1\\n\\t\\t];\\n\\n\\t\\tPolyhedronBufferGeometry.call( this, vertices, indices, radius, detail );\\n\\n\\t\\tthis.type = 'IcosahedronBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t}\\n\\n\\tIcosahedronBufferGeometry.prototype = Object.create( PolyhedronBufferGeometry.prototype );\\n\\tIcosahedronBufferGeometry.prototype.constructor = IcosahedronBufferGeometry;\\n\\n\\t/**\\n\\t * @author Abe Pazos / https://hamoid.com\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// DodecahedronGeometry\\n\\n\\tfunction DodecahedronGeometry( radius, detail ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'DodecahedronGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new DodecahedronBufferGeometry( radius, detail ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tDodecahedronGeometry.prototype = Object.create( Geometry.prototype );\\n\\tDodecahedronGeometry.prototype.constructor = DodecahedronGeometry;\\n\\n\\t// DodecahedronBufferGeometry\\n\\n\\tfunction DodecahedronBufferGeometry( radius, detail ) {\\n\\n\\t\\tvar t = ( 1 + Math.sqrt( 5 ) ) / 2;\\n\\t\\tvar r = 1 / t;\\n\\n\\t\\tvar vertices = [\\n\\n\\t\\t\\t// (±1, ±1, ±1)\\n\\t\\t\\t- 1, - 1, - 1,\\t- 1, - 1, 1,\\n\\t\\t\\t- 1, 1, - 1, - 1, 1, 1,\\n\\t\\t\\t1, - 1, - 1, 1, - 1, 1,\\n\\t\\t\\t1, 1, - 1, 1, 1, 1,\\n\\n\\t\\t\\t// (0, ±1/φ, ±φ)\\n\\t\\t\\t 0, - r, - t, 0, - r, t,\\n\\t\\t\\t 0, r, - t, 0, r, t,\\n\\n\\t\\t\\t// (±1/φ, ±φ, 0)\\n\\t\\t\\t- r, - t, 0, - r, t, 0,\\n\\t\\t\\t r, - t, 0, r, t, 0,\\n\\n\\t\\t\\t// (±φ, 0, ±1/φ)\\n\\t\\t\\t- t, 0, - r, t, 0, - r,\\n\\t\\t\\t- t, 0, r, t, 0, r\\n\\t\\t];\\n\\n\\t\\tvar indices = [\\n\\t\\t\\t3, 11, 7, \\t3, 7, 15, \\t3, 15, 13,\\n\\t\\t\\t7, 19, 17, \\t7, 17, 6, \\t7, 6, 15,\\n\\t\\t\\t17, 4, 8, \\t17, 8, 10, \\t17, 10, 6,\\n\\t\\t\\t8, 0, 16, \\t8, 16, 2, \\t8, 2, 10,\\n\\t\\t\\t0, 12, 1, \\t0, 1, 18, \\t0, 18, 16,\\n\\t\\t\\t6, 10, 2, \\t6, 2, 13, \\t6, 13, 15,\\n\\t\\t\\t2, 16, 18, \\t2, 18, 3, \\t2, 3, 13,\\n\\t\\t\\t18, 1, 9, \\t18, 9, 11, \\t18, 11, 3,\\n\\t\\t\\t4, 14, 12, \\t4, 12, 0, \\t4, 0, 8,\\n\\t\\t\\t11, 9, 5, \\t11, 5, 19, \\t11, 19, 7,\\n\\t\\t\\t19, 5, 14, \\t19, 14, 4, \\t19, 4, 17,\\n\\t\\t\\t1, 12, 14, \\t1, 14, 5, \\t1, 5, 9\\n\\t\\t];\\n\\n\\t\\tPolyhedronBufferGeometry.call( this, vertices, indices, radius, detail );\\n\\n\\t\\tthis.type = 'DodecahedronBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t}\\n\\n\\tDodecahedronBufferGeometry.prototype = Object.create( PolyhedronBufferGeometry.prototype );\\n\\tDodecahedronBufferGeometry.prototype.constructor = DodecahedronBufferGeometry;\\n\\n\\t/**\\n\\t * @author oosmoxiecode / https://github.com/oosmoxiecode\\n\\t * @author WestLangley / https://github.com/WestLangley\\n\\t * @author zz85 / https://github.com/zz85\\n\\t * @author miningold / https://github.com/miningold\\n\\t * @author jonobr1 / https://github.com/jonobr1\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t *\\n\\t */\\n\\n\\t// TubeGeometry\\n\\n\\tfunction TubeGeometry( path, tubularSegments, radius, radialSegments, closed, taper ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'TubeGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tpath: path,\\n\\t\\t\\ttubularSegments: tubularSegments,\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\tclosed: closed\\n\\t\\t};\\n\\n\\t\\tif ( taper !== undefined ) console.warn( 'THREE.TubeGeometry: taper has been removed.' );\\n\\n\\t\\tvar bufferGeometry = new TubeBufferGeometry( path, tubularSegments, radius, radialSegments, closed );\\n\\n\\t\\t// expose internals\\n\\n\\t\\tthis.tangents = bufferGeometry.tangents;\\n\\t\\tthis.normals = bufferGeometry.normals;\\n\\t\\tthis.binormals = bufferGeometry.binormals;\\n\\n\\t\\t// create geometry\\n\\n\\t\\tthis.fromBufferGeometry( bufferGeometry );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tTubeGeometry.prototype = Object.create( Geometry.prototype );\\n\\tTubeGeometry.prototype.constructor = TubeGeometry;\\n\\n\\t// TubeBufferGeometry\\n\\n\\tfunction TubeBufferGeometry( path, tubularSegments, radius, radialSegments, closed ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'TubeBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tpath: path,\\n\\t\\t\\ttubularSegments: tubularSegments,\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\tclosed: closed\\n\\t\\t};\\n\\n\\t\\ttubularSegments = tubularSegments || 64;\\n\\t\\tradius = radius || 1;\\n\\t\\tradialSegments = radialSegments || 8;\\n\\t\\tclosed = closed || false;\\n\\n\\t\\tvar frames = path.computeFrenetFrames( tubularSegments, closed );\\n\\n\\t\\t// expose internals\\n\\n\\t\\tthis.tangents = frames.tangents;\\n\\t\\tthis.normals = frames.normals;\\n\\t\\tthis.binormals = frames.binormals;\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar vertex = new Vector3();\\n\\t\\tvar normal = new Vector3();\\n\\t\\tvar uv = new Vector2();\\n\\t\\tvar P = new Vector3();\\n\\n\\t\\tvar i, j;\\n\\n\\t\\t// buffer\\n\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\t\\tvar indices = [];\\n\\n\\t\\t// create buffer data\\n\\n\\t\\tgenerateBufferData();\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t\\t// functions\\n\\n\\t\\tfunction generateBufferData() {\\n\\n\\t\\t\\tfor ( i = 0; i < tubularSegments; i ++ ) {\\n\\n\\t\\t\\t\\tgenerateSegment( i );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// if the geometry is not closed, generate the last row of vertices and normals\\n\\t\\t\\t// at the regular position on the given path\\n\\t\\t\\t//\\n\\t\\t\\t// if the geometry is closed, duplicate the first row of vertices and normals (uvs will differ)\\n\\n\\t\\t\\tgenerateSegment( ( closed === false ) ? tubularSegments : 0 );\\n\\n\\t\\t\\t// uvs are generated in a separate function.\\n\\t\\t\\t// this makes it easy compute correct values for closed geometries\\n\\n\\t\\t\\tgenerateUVs();\\n\\n\\t\\t\\t// finally create faces\\n\\n\\t\\t\\tgenerateIndices();\\n\\n\\t\\t}\\n\\n\\t\\tfunction generateSegment( i ) {\\n\\n\\t\\t\\t// we use getPointAt to sample evenly distributed points from the given path\\n\\n\\t\\t\\tP = path.getPointAt( i / tubularSegments, P );\\n\\n\\t\\t\\t// retrieve corresponding normal and binormal\\n\\n\\t\\t\\tvar N = frames.normals[ i ];\\n\\t\\t\\tvar B = frames.binormals[ i ];\\n\\n\\t\\t\\t// generate normals and vertices for the current segment\\n\\n\\t\\t\\tfor ( j = 0; j <= radialSegments; j ++ ) {\\n\\n\\t\\t\\t\\tvar v = j / radialSegments * Math.PI * 2;\\n\\n\\t\\t\\t\\tvar sin = Math.sin( v );\\n\\t\\t\\t\\tvar cos = - Math.cos( v );\\n\\n\\t\\t\\t\\t// normal\\n\\n\\t\\t\\t\\tnormal.x = ( cos * N.x + sin * B.x );\\n\\t\\t\\t\\tnormal.y = ( cos * N.y + sin * B.y );\\n\\t\\t\\t\\tnormal.z = ( cos * N.z + sin * B.z );\\n\\t\\t\\t\\tnormal.normalize();\\n\\n\\t\\t\\t\\tnormals.push( normal.x, normal.y, normal.z );\\n\\n\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\tvertex.x = P.x + radius * normal.x;\\n\\t\\t\\t\\tvertex.y = P.y + radius * normal.y;\\n\\t\\t\\t\\tvertex.z = P.z + radius * normal.z;\\n\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction generateIndices() {\\n\\n\\t\\t\\tfor ( j = 1; j <= tubularSegments; j ++ ) {\\n\\n\\t\\t\\t\\tfor ( i = 1; i <= radialSegments; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar a = ( radialSegments + 1 ) * ( j - 1 ) + ( i - 1 );\\n\\t\\t\\t\\t\\tvar b = ( radialSegments + 1 ) * j + ( i - 1 );\\n\\t\\t\\t\\t\\tvar c = ( radialSegments + 1 ) * j + i;\\n\\t\\t\\t\\t\\tvar d = ( radialSegments + 1 ) * ( j - 1 ) + i;\\n\\n\\t\\t\\t\\t\\t// faces\\n\\n\\t\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction generateUVs() {\\n\\n\\t\\t\\tfor ( i = 0; i <= tubularSegments; i ++ ) {\\n\\n\\t\\t\\t\\tfor ( j = 0; j <= radialSegments; j ++ ) {\\n\\n\\t\\t\\t\\t\\tuv.x = i / tubularSegments;\\n\\t\\t\\t\\t\\tuv.y = j / radialSegments;\\n\\n\\t\\t\\t\\t\\tuvs.push( uv.x, uv.y );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tTubeBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tTubeBufferGeometry.prototype.constructor = TubeBufferGeometry;\\n\\n\\t/**\\n\\t * @author oosmoxiecode\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t *\\n\\t * based on http://www.blackpawn.com/texts/pqtorus/\\n\\t */\\n\\n\\t// TorusKnotGeometry\\n\\n\\tfunction TorusKnotGeometry( radius, tube, tubularSegments, radialSegments, p, q, heightScale ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'TorusKnotGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\ttube: tube,\\n\\t\\t\\ttubularSegments: tubularSegments,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\tp: p,\\n\\t\\t\\tq: q\\n\\t\\t};\\n\\n\\t\\tif ( heightScale !== undefined ) console.warn( 'THREE.TorusKnotGeometry: heightScale has been deprecated. Use .scale( x, y, z ) instead.' );\\n\\n\\t\\tthis.fromBufferGeometry( new TorusKnotBufferGeometry( radius, tube, tubularSegments, radialSegments, p, q ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tTorusKnotGeometry.prototype = Object.create( Geometry.prototype );\\n\\tTorusKnotGeometry.prototype.constructor = TorusKnotGeometry;\\n\\n\\t// TorusKnotBufferGeometry\\n\\n\\tfunction TorusKnotBufferGeometry( radius, tube, tubularSegments, radialSegments, p, q ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'TorusKnotBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\ttube: tube,\\n\\t\\t\\ttubularSegments: tubularSegments,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\tp: p,\\n\\t\\t\\tq: q\\n\\t\\t};\\n\\n\\t\\tradius = radius || 1;\\n\\t\\ttube = tube || 0.4;\\n\\t\\ttubularSegments = Math.floor( tubularSegments ) || 64;\\n\\t\\tradialSegments = Math.floor( radialSegments ) || 8;\\n\\t\\tp = p || 2;\\n\\t\\tq = q || 3;\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar i, j;\\n\\n\\t\\tvar vertex = new Vector3();\\n\\t\\tvar normal = new Vector3();\\n\\n\\t\\tvar P1 = new Vector3();\\n\\t\\tvar P2 = new Vector3();\\n\\n\\t\\tvar B = new Vector3();\\n\\t\\tvar T = new Vector3();\\n\\t\\tvar N = new Vector3();\\n\\n\\t\\t// generate vertices, normals and uvs\\n\\n\\t\\tfor ( i = 0; i <= tubularSegments; ++ i ) {\\n\\n\\t\\t\\t// the radian \\\"u\\\" is used to calculate the position on the torus curve of the current tubular segement\\n\\n\\t\\t\\tvar u = i / tubularSegments * p * Math.PI * 2;\\n\\n\\t\\t\\t// now we calculate two points. P1 is our current position on the curve, P2 is a little farther ahead.\\n\\t\\t\\t// these points are used to create a special \\\"coordinate space\\\", which is necessary to calculate the correct vertex positions\\n\\n\\t\\t\\tcalculatePositionOnCurve( u, p, q, radius, P1 );\\n\\t\\t\\tcalculatePositionOnCurve( u + 0.01, p, q, radius, P2 );\\n\\n\\t\\t\\t// calculate orthonormal basis\\n\\n\\t\\t\\tT.subVectors( P2, P1 );\\n\\t\\t\\tN.addVectors( P2, P1 );\\n\\t\\t\\tB.crossVectors( T, N );\\n\\t\\t\\tN.crossVectors( B, T );\\n\\n\\t\\t\\t// normalize B, N. T can be ignored, we don't use it\\n\\n\\t\\t\\tB.normalize();\\n\\t\\t\\tN.normalize();\\n\\n\\t\\t\\tfor ( j = 0; j <= radialSegments; ++ j ) {\\n\\n\\t\\t\\t\\t// now calculate the vertices. they are nothing more than an extrusion of the torus curve.\\n\\t\\t\\t\\t// because we extrude a shape in the xy-plane, there is no need to calculate a z-value.\\n\\n\\t\\t\\t\\tvar v = j / radialSegments * Math.PI * 2;\\n\\t\\t\\t\\tvar cx = - tube * Math.cos( v );\\n\\t\\t\\t\\tvar cy = tube * Math.sin( v );\\n\\n\\t\\t\\t\\t// now calculate the final vertex position.\\n\\t\\t\\t\\t// first we orient the extrusion with our basis vectos, then we add it to the current position on the curve\\n\\n\\t\\t\\t\\tvertex.x = P1.x + ( cx * N.x + cy * B.x );\\n\\t\\t\\t\\tvertex.y = P1.y + ( cx * N.y + cy * B.y );\\n\\t\\t\\t\\tvertex.z = P1.z + ( cx * N.z + cy * B.z );\\n\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t// normal (P1 is always the center/origin of the extrusion, thus we can use it to calculate the normal)\\n\\n\\t\\t\\t\\tnormal.subVectors( vertex, P1 ).normalize();\\n\\n\\t\\t\\t\\tnormals.push( normal.x, normal.y, normal.z );\\n\\n\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\tuvs.push( i / tubularSegments );\\n\\t\\t\\t\\tuvs.push( j / radialSegments );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// generate indices\\n\\n\\t\\tfor ( j = 1; j <= tubularSegments; j ++ ) {\\n\\n\\t\\t\\tfor ( i = 1; i <= radialSegments; i ++ ) {\\n\\n\\t\\t\\t\\t// indices\\n\\n\\t\\t\\t\\tvar a = ( radialSegments + 1 ) * ( j - 1 ) + ( i - 1 );\\n\\t\\t\\t\\tvar b = ( radialSegments + 1 ) * j + ( i - 1 );\\n\\t\\t\\t\\tvar c = ( radialSegments + 1 ) * j + i;\\n\\t\\t\\t\\tvar d = ( radialSegments + 1 ) * ( j - 1 ) + i;\\n\\n\\t\\t\\t\\t// faces\\n\\n\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t\\t// this function calculates the current position on the torus curve\\n\\n\\t\\tfunction calculatePositionOnCurve( u, p, q, radius, position ) {\\n\\n\\t\\t\\tvar cu = Math.cos( u );\\n\\t\\t\\tvar su = Math.sin( u );\\n\\t\\t\\tvar quOverP = q / p * u;\\n\\t\\t\\tvar cs = Math.cos( quOverP );\\n\\n\\t\\t\\tposition.x = radius * ( 2 + cs ) * 0.5 * cu;\\n\\t\\t\\tposition.y = radius * ( 2 + cs ) * su * 0.5;\\n\\t\\t\\tposition.z = radius * Math.sin( quOverP ) * 0.5;\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tTorusKnotBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tTorusKnotBufferGeometry.prototype.constructor = TorusKnotBufferGeometry;\\n\\n\\t/**\\n\\t * @author oosmoxiecode\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// TorusGeometry\\n\\n\\tfunction TorusGeometry( radius, tube, radialSegments, tubularSegments, arc ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'TorusGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\ttube: tube,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\ttubularSegments: tubularSegments,\\n\\t\\t\\tarc: arc\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new TorusBufferGeometry( radius, tube, radialSegments, tubularSegments, arc ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tTorusGeometry.prototype = Object.create( Geometry.prototype );\\n\\tTorusGeometry.prototype.constructor = TorusGeometry;\\n\\n\\t// TorusBufferGeometry\\n\\n\\tfunction TorusBufferGeometry( radius, tube, radialSegments, tubularSegments, arc ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'TorusBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\ttube: tube,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\ttubularSegments: tubularSegments,\\n\\t\\t\\tarc: arc\\n\\t\\t};\\n\\n\\t\\tradius = radius || 1;\\n\\t\\ttube = tube || 0.4;\\n\\t\\tradialSegments = Math.floor( radialSegments ) || 8;\\n\\t\\ttubularSegments = Math.floor( tubularSegments ) || 6;\\n\\t\\tarc = arc || Math.PI * 2;\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar center = new Vector3();\\n\\t\\tvar vertex = new Vector3();\\n\\t\\tvar normal = new Vector3();\\n\\n\\t\\tvar j, i;\\n\\n\\t\\t// generate vertices, normals and uvs\\n\\n\\t\\tfor ( j = 0; j <= radialSegments; j ++ ) {\\n\\n\\t\\t\\tfor ( i = 0; i <= tubularSegments; i ++ ) {\\n\\n\\t\\t\\t\\tvar u = i / tubularSegments * arc;\\n\\t\\t\\t\\tvar v = j / radialSegments * Math.PI * 2;\\n\\n\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\tvertex.x = ( radius + tube * Math.cos( v ) ) * Math.cos( u );\\n\\t\\t\\t\\tvertex.y = ( radius + tube * Math.cos( v ) ) * Math.sin( u );\\n\\t\\t\\t\\tvertex.z = tube * Math.sin( v );\\n\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t// normal\\n\\n\\t\\t\\t\\tcenter.x = radius * Math.cos( u );\\n\\t\\t\\t\\tcenter.y = radius * Math.sin( u );\\n\\t\\t\\t\\tnormal.subVectors( vertex, center ).normalize();\\n\\n\\t\\t\\t\\tnormals.push( normal.x, normal.y, normal.z );\\n\\n\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\tuvs.push( i / tubularSegments );\\n\\t\\t\\t\\tuvs.push( j / radialSegments );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// generate indices\\n\\n\\t\\tfor ( j = 1; j <= radialSegments; j ++ ) {\\n\\n\\t\\t\\tfor ( i = 1; i <= tubularSegments; i ++ ) {\\n\\n\\t\\t\\t\\t// indices\\n\\n\\t\\t\\t\\tvar a = ( tubularSegments + 1 ) * j + i - 1;\\n\\t\\t\\t\\tvar b = ( tubularSegments + 1 ) * ( j - 1 ) + i - 1;\\n\\t\\t\\t\\tvar c = ( tubularSegments + 1 ) * ( j - 1 ) + i;\\n\\t\\t\\t\\tvar d = ( tubularSegments + 1 ) * j + i;\\n\\n\\t\\t\\t\\t// faces\\n\\n\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t}\\n\\n\\tTorusBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tTorusBufferGeometry.prototype.constructor = TorusBufferGeometry;\\n\\n\\t/**\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t * Port from https://github.com/mapbox/earcut (v2.1.2)\\n\\t */\\n\\n\\tvar Earcut = {\\n\\n\\t\\ttriangulate: function ( data, holeIndices, dim ) {\\n\\n\\t\\t\\tdim = dim || 2;\\n\\n\\t\\t\\tvar hasHoles = holeIndices && holeIndices.length,\\n\\t\\t\\t\\touterLen = hasHoles ? holeIndices[ 0 ] * dim : data.length,\\n\\t\\t\\t\\touterNode = linkedList( data, 0, outerLen, dim, true ),\\n\\t\\t\\t\\ttriangles = [];\\n\\n\\t\\t\\tif ( ! outerNode ) return triangles;\\n\\n\\t\\t\\tvar minX, minY, maxX, maxY, x, y, invSize;\\n\\n\\t\\t\\tif ( hasHoles ) outerNode = eliminateHoles( data, holeIndices, outerNode, dim );\\n\\n\\t\\t\\t// if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox\\n\\n\\t\\t\\tif ( data.length > 80 * dim ) {\\n\\n\\t\\t\\t\\tminX = maxX = data[ 0 ];\\n\\t\\t\\t\\tminY = maxY = data[ 1 ];\\n\\n\\t\\t\\t\\tfor ( var i = dim; i < outerLen; i += dim ) {\\n\\n\\t\\t\\t\\t\\tx = data[ i ];\\n\\t\\t\\t\\t\\ty = data[ i + 1 ];\\n\\t\\t\\t\\t\\tif ( x < minX ) minX = x;\\n\\t\\t\\t\\t\\tif ( y < minY ) minY = y;\\n\\t\\t\\t\\t\\tif ( x > maxX ) maxX = x;\\n\\t\\t\\t\\t\\tif ( y > maxY ) maxY = y;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// minX, minY and invSize are later used to transform coords into integers for z-order calculation\\n\\n\\t\\t\\t\\tinvSize = Math.max( maxX - minX, maxY - minY );\\n\\t\\t\\t\\tinvSize = invSize !== 0 ? 1 / invSize : 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tearcutLinked( outerNode, triangles, dim, minX, minY, invSize );\\n\\n\\t\\t\\treturn triangles;\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t// create a circular doubly linked list from polygon points in the specified winding order\\n\\n\\tfunction linkedList( data, start, end, dim, clockwise ) {\\n\\n\\t\\tvar i, last;\\n\\n\\t\\tif ( clockwise === ( signedArea( data, start, end, dim ) > 0 ) ) {\\n\\n\\t\\t\\tfor ( i = start; i < end; i += dim ) last = insertNode( i, data[ i ], data[ i + 1 ], last );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tfor ( i = end - dim; i >= start; i -= dim ) last = insertNode( i, data[ i ], data[ i + 1 ], last );\\n\\n\\t\\t}\\n\\n\\t\\tif ( last && equals( last, last.next ) ) {\\n\\n\\t\\t\\tremoveNode( last );\\n\\t\\t\\tlast = last.next;\\n\\n\\t\\t}\\n\\n\\t\\treturn last;\\n\\n\\t}\\n\\n\\t// eliminate colinear or duplicate points\\n\\n\\tfunction filterPoints( start, end ) {\\n\\n\\t\\tif ( ! start ) return start;\\n\\t\\tif ( ! end ) end = start;\\n\\n\\t\\tvar p = start, again;\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tagain = false;\\n\\n\\t\\t\\tif ( ! p.steiner && ( equals( p, p.next ) || area( p.prev, p, p.next ) === 0 ) ) {\\n\\n\\t\\t\\t\\tremoveNode( p );\\n\\t\\t\\t\\tp = end = p.prev;\\n\\t\\t\\t\\tif ( p === p.next ) break;\\n\\t\\t\\t\\tagain = true;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tp = p.next;\\n\\n\\t\\t\\t}\\n\\n\\t\\t} while ( again || p !== end );\\n\\n\\t\\treturn end;\\n\\n\\t}\\n\\n\\t// main ear slicing loop which triangulates a polygon (given as a linked list)\\n\\n\\tfunction earcutLinked( ear, triangles, dim, minX, minY, invSize, pass ) {\\n\\n\\t\\tif ( ! ear ) return;\\n\\n\\t\\t// interlink polygon nodes in z-order\\n\\n\\t\\tif ( ! pass && invSize ) indexCurve( ear, minX, minY, invSize );\\n\\n\\t\\tvar stop = ear, prev, next;\\n\\n\\t\\t// iterate through ears, slicing them one by one\\n\\n\\t\\twhile ( ear.prev !== ear.next ) {\\n\\n\\t\\t\\tprev = ear.prev;\\n\\t\\t\\tnext = ear.next;\\n\\n\\t\\t\\tif ( invSize ? isEarHashed( ear, minX, minY, invSize ) : isEar( ear ) ) {\\n\\n\\t\\t\\t\\t// cut off the triangle\\n\\t\\t\\t\\ttriangles.push( prev.i / dim );\\n\\t\\t\\t\\ttriangles.push( ear.i / dim );\\n\\t\\t\\t\\ttriangles.push( next.i / dim );\\n\\n\\t\\t\\t\\tremoveNode( ear );\\n\\n\\t\\t\\t\\t// skipping the next vertice leads to less sliver triangles\\n\\t\\t\\t\\tear = next.next;\\n\\t\\t\\t\\tstop = next.next;\\n\\n\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tear = next;\\n\\n\\t\\t\\t// if we looped through the whole remaining polygon and can't find any more ears\\n\\n\\t\\t\\tif ( ear === stop ) {\\n\\n\\t\\t\\t\\t// try filtering points and slicing again\\n\\n\\t\\t\\t\\tif ( ! pass ) {\\n\\n\\t\\t\\t\\t\\tearcutLinked( filterPoints( ear ), triangles, dim, minX, minY, invSize, 1 );\\n\\n\\t\\t\\t\\t\\t// if this didn't work, try curing all small self-intersections locally\\n\\n\\t\\t\\t\\t} else if ( pass === 1 ) {\\n\\n\\t\\t\\t\\t\\tear = cureLocalIntersections( ear, triangles, dim );\\n\\t\\t\\t\\t\\tearcutLinked( ear, triangles, dim, minX, minY, invSize, 2 );\\n\\n\\t\\t\\t\\t// as a last resort, try splitting the remaining polygon into two\\n\\n\\t\\t\\t\\t} else if ( pass === 2 ) {\\n\\n\\t\\t\\t\\t\\tsplitEarcut( ear, triangles, dim, minX, minY, invSize );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t// check whether a polygon node forms a valid ear with adjacent nodes\\n\\n\\tfunction isEar( ear ) {\\n\\n\\t\\tvar a = ear.prev,\\n\\t\\t\\tb = ear,\\n\\t\\t\\tc = ear.next;\\n\\n\\t\\tif ( area( a, b, c ) >= 0 ) return false; // reflex, can't be an ear\\n\\n\\t\\t// now make sure we don't have other points inside the potential ear\\n\\t\\tvar p = ear.next.next;\\n\\n\\t\\twhile ( p !== ear.prev ) {\\n\\n\\t\\t\\tif ( pointInTriangle( a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y ) && area( p.prev, p, p.next ) >= 0 ) {\\n\\n\\t\\t\\t\\treturn false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tp = p.next;\\n\\n\\t\\t}\\n\\n\\t\\treturn true;\\n\\n\\t}\\n\\n\\tfunction isEarHashed( ear, minX, minY, invSize ) {\\n\\n\\t\\tvar a = ear.prev,\\n\\t\\t\\tb = ear,\\n\\t\\t\\tc = ear.next;\\n\\n\\t\\tif ( area( a, b, c ) >= 0 ) return false; // reflex, can't be an ear\\n\\n\\t\\t// triangle bbox; min & max are calculated like this for speed\\n\\n\\t\\tvar minTX = a.x < b.x ? ( a.x < c.x ? a.x : c.x ) : ( b.x < c.x ? b.x : c.x ),\\n\\t\\t\\tminTY = a.y < b.y ? ( a.y < c.y ? a.y : c.y ) : ( b.y < c.y ? b.y : c.y ),\\n\\t\\t\\tmaxTX = a.x > b.x ? ( a.x > c.x ? a.x : c.x ) : ( b.x > c.x ? b.x : c.x ),\\n\\t\\t\\tmaxTY = a.y > b.y ? ( a.y > c.y ? a.y : c.y ) : ( b.y > c.y ? b.y : c.y );\\n\\n\\t\\t// z-order range for the current triangle bbox;\\n\\n\\t\\tvar minZ = zOrder( minTX, minTY, minX, minY, invSize ),\\n\\t\\t\\tmaxZ = zOrder( maxTX, maxTY, minX, minY, invSize );\\n\\n\\t\\t// first look for points inside the triangle in increasing z-order\\n\\n\\t\\tvar p = ear.nextZ;\\n\\n\\t\\twhile ( p && p.z <= maxZ ) {\\n\\n\\t\\t\\tif ( p !== ear.prev && p !== ear.next &&\\n\\t\\t\\t\\t\\tpointInTriangle( a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y ) &&\\n\\t\\t\\t\\t\\tarea( p.prev, p, p.next ) >= 0 ) return false;\\n\\t\\t\\tp = p.nextZ;\\n\\n\\t\\t}\\n\\n\\t\\t// then look for points in decreasing z-order\\n\\n\\t\\tp = ear.prevZ;\\n\\n\\t\\twhile ( p && p.z >= minZ ) {\\n\\n\\t\\t\\tif ( p !== ear.prev && p !== ear.next &&\\n\\t\\t\\t\\t\\tpointInTriangle( a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y ) &&\\n\\t\\t\\t\\t\\tarea( p.prev, p, p.next ) >= 0 ) return false;\\n\\n\\t\\t\\tp = p.prevZ;\\n\\n\\t\\t}\\n\\n\\t\\treturn true;\\n\\n\\t}\\n\\n\\t// go through all polygon nodes and cure small local self-intersections\\n\\n\\tfunction cureLocalIntersections( start, triangles, dim ) {\\n\\n\\t\\tvar p = start;\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tvar a = p.prev, b = p.next.next;\\n\\n\\t\\t\\tif ( ! equals( a, b ) && intersects( a, p, p.next, b ) && locallyInside( a, b ) && locallyInside( b, a ) ) {\\n\\n\\t\\t\\t\\ttriangles.push( a.i / dim );\\n\\t\\t\\t\\ttriangles.push( p.i / dim );\\n\\t\\t\\t\\ttriangles.push( b.i / dim );\\n\\n\\t\\t\\t\\t// remove two nodes involved\\n\\n\\t\\t\\t\\tremoveNode( p );\\n\\t\\t\\t\\tremoveNode( p.next );\\n\\n\\t\\t\\t\\tp = start = b;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tp = p.next;\\n\\n\\t\\t} while ( p !== start );\\n\\n\\t\\treturn p;\\n\\n\\t}\\n\\n\\t// try splitting polygon into two and triangulate them independently\\n\\n\\tfunction splitEarcut( start, triangles, dim, minX, minY, invSize ) {\\n\\n\\t\\t// look for a valid diagonal that divides the polygon into two\\n\\n\\t\\tvar a = start;\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tvar b = a.next.next;\\n\\n\\t\\t\\twhile ( b !== a.prev ) {\\n\\n\\t\\t\\t\\tif ( a.i !== b.i && isValidDiagonal( a, b ) ) {\\n\\n\\t\\t\\t\\t\\t// split the polygon in two by the diagonal\\n\\n\\t\\t\\t\\t\\tvar c = splitPolygon( a, b );\\n\\n\\t\\t\\t\\t\\t// filter colinear points around the cuts\\n\\n\\t\\t\\t\\t\\ta = filterPoints( a, a.next );\\n\\t\\t\\t\\t\\tc = filterPoints( c, c.next );\\n\\n\\t\\t\\t\\t\\t// run earcut on each half\\n\\n\\t\\t\\t\\t\\tearcutLinked( a, triangles, dim, minX, minY, invSize );\\n\\t\\t\\t\\t\\tearcutLinked( c, triangles, dim, minX, minY, invSize );\\n\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tb = b.next;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\ta = a.next;\\n\\n\\t\\t} while ( a !== start );\\n\\n\\t}\\n\\n\\t// link every hole into the outer loop, producing a single-ring polygon without holes\\n\\n\\tfunction eliminateHoles( data, holeIndices, outerNode, dim ) {\\n\\n\\t\\tvar queue = [], i, len, start, end, list;\\n\\n\\t\\tfor ( i = 0, len = holeIndices.length; i < len; i ++ ) {\\n\\n\\t\\t\\tstart = holeIndices[ i ] * dim;\\n\\t\\t\\tend = i < len - 1 ? holeIndices[ i + 1 ] * dim : data.length;\\n\\t\\t\\tlist = linkedList( data, start, end, dim, false );\\n\\t\\t\\tif ( list === list.next ) list.steiner = true;\\n\\t\\t\\tqueue.push( getLeftmost( list ) );\\n\\n\\t\\t}\\n\\n\\t\\tqueue.sort( compareX );\\n\\n\\t\\t// process holes from left to right\\n\\n\\t\\tfor ( i = 0; i < queue.length; i ++ ) {\\n\\n\\t\\t\\teliminateHole( queue[ i ], outerNode );\\n\\t\\t\\touterNode = filterPoints( outerNode, outerNode.next );\\n\\n\\t\\t}\\n\\n\\t\\treturn outerNode;\\n\\n\\t}\\n\\n\\tfunction compareX( a, b ) {\\n\\n\\t\\treturn a.x - b.x;\\n\\n\\t}\\n\\n\\t// find a bridge between vertices that connects hole with an outer ring and and link it\\n\\n\\tfunction eliminateHole( hole, outerNode ) {\\n\\n\\t\\touterNode = findHoleBridge( hole, outerNode );\\n\\n\\t\\tif ( outerNode ) {\\n\\n\\t\\t\\tvar b = splitPolygon( outerNode, hole );\\n\\n\\t\\t\\tfilterPoints( b, b.next );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t// David Eberly's algorithm for finding a bridge between hole and outer polygon\\n\\n\\tfunction findHoleBridge( hole, outerNode ) {\\n\\n\\t\\tvar p = outerNode,\\n\\t\\t\\thx = hole.x,\\n\\t\\t\\thy = hole.y,\\n\\t\\t\\tqx = - Infinity,\\n\\t\\t\\tm;\\n\\n\\t\\t// find a segment intersected by a ray from the hole's leftmost point to the left;\\n\\t\\t// segment's endpoint with lesser x will be potential connection point\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tif ( hy <= p.y && hy >= p.next.y && p.next.y !== p.y ) {\\n\\n\\t\\t\\t\\tvar x = p.x + ( hy - p.y ) * ( p.next.x - p.x ) / ( p.next.y - p.y );\\n\\n\\t\\t\\t\\tif ( x <= hx && x > qx ) {\\n\\n\\t\\t\\t\\t\\tqx = x;\\n\\n\\t\\t\\t\\t\\tif ( x === hx ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( hy === p.y ) return p;\\n\\t\\t\\t\\t\\t\\tif ( hy === p.next.y ) return p.next;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tm = p.x < p.next.x ? p : p.next;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tp = p.next;\\n\\n\\t\\t} while ( p !== outerNode );\\n\\n\\t\\tif ( ! m ) return null;\\n\\n\\t\\tif ( hx === qx ) return m.prev; // hole touches outer segment; pick lower endpoint\\n\\n\\t\\t// look for points inside the triangle of hole point, segment intersection and endpoint;\\n\\t\\t// if there are no points found, we have a valid connection;\\n\\t\\t// otherwise choose the point of the minimum angle with the ray as connection point\\n\\n\\t\\tvar stop = m,\\n\\t\\t\\tmx = m.x,\\n\\t\\t\\tmy = m.y,\\n\\t\\t\\ttanMin = Infinity,\\n\\t\\t\\ttan;\\n\\n\\t\\tp = m.next;\\n\\n\\t\\twhile ( p !== stop ) {\\n\\n\\t\\t\\tif ( hx >= p.x && p.x >= mx && hx !== p.x &&\\n\\t\\t\\t\\t\\t\\t\\tpointInTriangle( hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y ) ) {\\n\\n\\t\\t\\t\\ttan = Math.abs( hy - p.y ) / ( hx - p.x ); // tangential\\n\\n\\t\\t\\t\\tif ( ( tan < tanMin || ( tan === tanMin && p.x > m.x ) ) && locallyInside( p, hole ) ) {\\n\\n\\t\\t\\t\\t\\tm = p;\\n\\t\\t\\t\\t\\ttanMin = tan;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tp = p.next;\\n\\n\\t\\t}\\n\\n\\t\\treturn m;\\n\\n\\t}\\n\\n\\t// interlink polygon nodes in z-order\\n\\n\\tfunction indexCurve( start, minX, minY, invSize ) {\\n\\n\\t\\tvar p = start;\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tif ( p.z === null ) p.z = zOrder( p.x, p.y, minX, minY, invSize );\\n\\t\\t\\tp.prevZ = p.prev;\\n\\t\\t\\tp.nextZ = p.next;\\n\\t\\t\\tp = p.next;\\n\\n\\t\\t} while ( p !== start );\\n\\n\\t\\tp.prevZ.nextZ = null;\\n\\t\\tp.prevZ = null;\\n\\n\\t\\tsortLinked( p );\\n\\n\\t}\\n\\n\\t// Simon Tatham's linked list merge sort algorithm\\n\\t// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html\\n\\n\\tfunction sortLinked( list ) {\\n\\n\\t\\tvar i, p, q, e, tail, numMerges, pSize, qSize, inSize = 1;\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tp = list;\\n\\t\\t\\tlist = null;\\n\\t\\t\\ttail = null;\\n\\t\\t\\tnumMerges = 0;\\n\\n\\t\\t\\twhile ( p ) {\\n\\n\\t\\t\\t\\tnumMerges ++;\\n\\t\\t\\t\\tq = p;\\n\\t\\t\\t\\tpSize = 0;\\n\\n\\t\\t\\t\\tfor ( i = 0; i < inSize; i ++ ) {\\n\\n\\t\\t\\t\\t\\tpSize ++;\\n\\t\\t\\t\\t\\tq = q.nextZ;\\n\\t\\t\\t\\t\\tif ( ! q ) break;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tqSize = inSize;\\n\\n\\t\\t\\t\\twhile ( pSize > 0 || ( qSize > 0 && q ) ) {\\n\\n\\t\\t\\t\\t\\tif ( pSize !== 0 && ( qSize === 0 || ! q || p.z <= q.z ) ) {\\n\\n\\t\\t\\t\\t\\t\\te = p;\\n\\t\\t\\t\\t\\t\\tp = p.nextZ;\\n\\t\\t\\t\\t\\t\\tpSize --;\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\te = q;\\n\\t\\t\\t\\t\\t\\tq = q.nextZ;\\n\\t\\t\\t\\t\\t\\tqSize --;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( tail ) tail.nextZ = e;\\n\\t\\t\\t\\t\\telse list = e;\\n\\n\\t\\t\\t\\t\\te.prevZ = tail;\\n\\t\\t\\t\\t\\ttail = e;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tp = q;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\ttail.nextZ = null;\\n\\t\\t\\tinSize *= 2;\\n\\n\\t\\t} while ( numMerges > 1 );\\n\\n\\t\\treturn list;\\n\\n\\t}\\n\\n\\t// z-order of a point given coords and inverse of the longer side of data bbox\\n\\n\\tfunction zOrder( x, y, minX, minY, invSize ) {\\n\\n\\t\\t// coords are transformed into non-negative 15-bit integer range\\n\\n\\t\\tx = 32767 * ( x - minX ) * invSize;\\n\\t\\ty = 32767 * ( y - minY ) * invSize;\\n\\n\\t\\tx = ( x | ( x << 8 ) ) & 0x00FF00FF;\\n\\t\\tx = ( x | ( x << 4 ) ) & 0x0F0F0F0F;\\n\\t\\tx = ( x | ( x << 2 ) ) & 0x33333333;\\n\\t\\tx = ( x | ( x << 1 ) ) & 0x55555555;\\n\\n\\t\\ty = ( y | ( y << 8 ) ) & 0x00FF00FF;\\n\\t\\ty = ( y | ( y << 4 ) ) & 0x0F0F0F0F;\\n\\t\\ty = ( y | ( y << 2 ) ) & 0x33333333;\\n\\t\\ty = ( y | ( y << 1 ) ) & 0x55555555;\\n\\n\\t\\treturn x | ( y << 1 );\\n\\n\\t}\\n\\n\\t// find the leftmost node of a polygon ring\\n\\n\\tfunction getLeftmost( start ) {\\n\\n\\t\\tvar p = start, leftmost = start;\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tif ( p.x < leftmost.x ) leftmost = p;\\n\\t\\t\\tp = p.next;\\n\\n\\t\\t} while ( p !== start );\\n\\n\\t\\treturn leftmost;\\n\\n\\t}\\n\\n\\t// check if a point lies within a convex triangle\\n\\n\\tfunction pointInTriangle( ax, ay, bx, by, cx, cy, px, py ) {\\n\\n\\t\\treturn ( cx - px ) * ( ay - py ) - ( ax - px ) * ( cy - py ) >= 0 &&\\n\\t\\t ( ax - px ) * ( by - py ) - ( bx - px ) * ( ay - py ) >= 0 &&\\n\\t\\t ( bx - px ) * ( cy - py ) - ( cx - px ) * ( by - py ) >= 0;\\n\\n\\t}\\n\\n\\t// check if a diagonal between two polygon nodes is valid (lies in polygon interior)\\n\\n\\tfunction isValidDiagonal( a, b ) {\\n\\n\\t\\treturn a.next.i !== b.i && a.prev.i !== b.i && ! intersectsPolygon( a, b ) &&\\n\\t\\t\\tlocallyInside( a, b ) && locallyInside( b, a ) && middleInside( a, b );\\n\\n\\t}\\n\\n\\t// signed area of a triangle\\n\\n\\tfunction area( p, q, r ) {\\n\\n\\t\\treturn ( q.y - p.y ) * ( r.x - q.x ) - ( q.x - p.x ) * ( r.y - q.y );\\n\\n\\t}\\n\\n\\t// check if two points are equal\\n\\n\\tfunction equals( p1, p2 ) {\\n\\n\\t\\treturn p1.x === p2.x && p1.y === p2.y;\\n\\n\\t}\\n\\n\\t// check if two segments intersect\\n\\n\\tfunction intersects( p1, q1, p2, q2 ) {\\n\\n\\t\\tif ( ( equals( p1, q1 ) && equals( p2, q2 ) ) ||\\n\\t\\t\\t\\t( equals( p1, q2 ) && equals( p2, q1 ) ) ) return true;\\n\\n\\t\\treturn area( p1, q1, p2 ) > 0 !== area( p1, q1, q2 ) > 0 &&\\n\\t\\t\\t\\t\\t area( p2, q2, p1 ) > 0 !== area( p2, q2, q1 ) > 0;\\n\\n\\t}\\n\\n\\t// check if a polygon diagonal intersects any polygon segments\\n\\n\\tfunction intersectsPolygon( a, b ) {\\n\\n\\t\\tvar p = a;\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tif ( p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&\\n\\t\\t\\t\\t\\t\\t\\tintersects( p, p.next, a, b ) ) {\\n\\n\\t\\t\\t\\treturn true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tp = p.next;\\n\\n\\t\\t} while ( p !== a );\\n\\n\\t\\treturn false;\\n\\n\\t}\\n\\n\\t// check if a polygon diagonal is locally inside the polygon\\n\\n\\tfunction locallyInside( a, b ) {\\n\\n\\t\\treturn area( a.prev, a, a.next ) < 0 ?\\n\\t\\t\\tarea( a, b, a.next ) >= 0 && area( a, a.prev, b ) >= 0 :\\n\\t\\t\\tarea( a, b, a.prev ) < 0 || area( a, a.next, b ) < 0;\\n\\n\\t}\\n\\n\\t// check if the middle point of a polygon diagonal is inside the polygon\\n\\n\\tfunction middleInside( a, b ) {\\n\\n\\t\\tvar p = a,\\n\\t\\t\\tinside = false,\\n\\t\\t\\tpx = ( a.x + b.x ) / 2,\\n\\t\\t\\tpy = ( a.y + b.y ) / 2;\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tif ( ( ( p.y > py ) !== ( p.next.y > py ) ) && p.next.y !== p.y &&\\n\\t\\t\\t\\t\\t\\t\\t( px < ( p.next.x - p.x ) * ( py - p.y ) / ( p.next.y - p.y ) + p.x ) ) {\\n\\n\\t\\t\\t\\tinside = ! inside;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tp = p.next;\\n\\n\\t\\t} while ( p !== a );\\n\\n\\t\\treturn inside;\\n\\n\\t}\\n\\n\\t// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;\\n\\t// if one belongs to the outer ring and another to a hole, it merges it into a single ring\\n\\n\\tfunction splitPolygon( a, b ) {\\n\\n\\t\\tvar a2 = new Node( a.i, a.x, a.y ),\\n\\t\\t\\tb2 = new Node( b.i, b.x, b.y ),\\n\\t\\t\\tan = a.next,\\n\\t\\t\\tbp = b.prev;\\n\\n\\t\\ta.next = b;\\n\\t\\tb.prev = a;\\n\\n\\t\\ta2.next = an;\\n\\t\\tan.prev = a2;\\n\\n\\t\\tb2.next = a2;\\n\\t\\ta2.prev = b2;\\n\\n\\t\\tbp.next = b2;\\n\\t\\tb2.prev = bp;\\n\\n\\t\\treturn b2;\\n\\n\\t}\\n\\n\\t// create a node and optionally link it with previous one (in a circular doubly linked list)\\n\\n\\tfunction insertNode( i, x, y, last ) {\\n\\n\\t\\tvar p = new Node( i, x, y );\\n\\n\\t\\tif ( ! last ) {\\n\\n\\t\\t\\tp.prev = p;\\n\\t\\t\\tp.next = p;\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tp.next = last.next;\\n\\t\\t\\tp.prev = last;\\n\\t\\t\\tlast.next.prev = p;\\n\\t\\t\\tlast.next = p;\\n\\n\\t\\t}\\n\\n\\t\\treturn p;\\n\\n\\t}\\n\\n\\tfunction removeNode( p ) {\\n\\n\\t\\tp.next.prev = p.prev;\\n\\t\\tp.prev.next = p.next;\\n\\n\\t\\tif ( p.prevZ ) p.prevZ.nextZ = p.nextZ;\\n\\t\\tif ( p.nextZ ) p.nextZ.prevZ = p.prevZ;\\n\\n\\t}\\n\\n\\tfunction Node( i, x, y ) {\\n\\n\\t\\t// vertice index in coordinates array\\n\\t\\tthis.i = i;\\n\\n\\t\\t// vertex coordinates\\n\\t\\tthis.x = x;\\n\\t\\tthis.y = y;\\n\\n\\t\\t// previous and next vertice nodes in a polygon ring\\n\\t\\tthis.prev = null;\\n\\t\\tthis.next = null;\\n\\n\\t\\t// z-order curve value\\n\\t\\tthis.z = null;\\n\\n\\t\\t// previous and next nodes in z-order\\n\\t\\tthis.prevZ = null;\\n\\t\\tthis.nextZ = null;\\n\\n\\t\\t// indicates whether this is a steiner point\\n\\t\\tthis.steiner = false;\\n\\n\\t}\\n\\n\\tfunction signedArea( data, start, end, dim ) {\\n\\n\\t\\tvar sum = 0;\\n\\n\\t\\tfor ( var i = start, j = end - dim; i < end; i += dim ) {\\n\\n\\t\\t\\tsum += ( data[ j ] - data[ i ] ) * ( data[ i + 1 ] + data[ j + 1 ] );\\n\\t\\t\\tj = i;\\n\\n\\t\\t}\\n\\n\\t\\treturn sum;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t */\\n\\n\\tvar ShapeUtils = {\\n\\n\\t\\t// calculate area of the contour polygon\\n\\n\\t\\tarea: function ( contour ) {\\n\\n\\t\\t\\tvar n = contour.length;\\n\\t\\t\\tvar a = 0.0;\\n\\n\\t\\t\\tfor ( var p = n - 1, q = 0; q < n; p = q ++ ) {\\n\\n\\t\\t\\t\\ta += contour[ p ].x * contour[ q ].y - contour[ q ].x * contour[ p ].y;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn a * 0.5;\\n\\n\\t\\t},\\n\\n\\t\\tisClockWise: function ( pts ) {\\n\\n\\t\\t\\treturn ShapeUtils.area( pts ) < 0;\\n\\n\\t\\t},\\n\\n\\t\\ttriangulateShape: function ( contour, holes ) {\\n\\n\\t\\t\\tfunction removeDupEndPts( points ) {\\n\\n\\t\\t\\t\\tvar l = points.length;\\n\\n\\t\\t\\t\\tif ( l > 2 && points[ l - 1 ].equals( points[ 0 ] ) ) {\\n\\n\\t\\t\\t\\t\\tpoints.pop();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction addContour( vertices, contour ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < contour.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvertices.push( contour[ i ].x );\\n\\t\\t\\t\\t\\tvertices.push( contour[ i ].y );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar vertices = []; // flat array of vertices like [ x0,y0, x1,y1, x2,y2, ... ]\\n\\t\\t\\tvar holeIndices = []; // array of hole indices\\n\\t\\t\\tvar faces = []; // final array of vertex indices like [ [ a,b,d ], [ b,c,d ] ]\\n\\n\\t\\t\\tremoveDupEndPts( contour );\\n\\t\\t\\taddContour( vertices, contour );\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar holeIndex = contour.length;\\n\\t\\t\\tholes.forEach( removeDupEndPts );\\n\\n\\t\\t\\tfor ( i = 0; i < holes.length; i ++ ) {\\n\\n\\t\\t\\t\\tholeIndices.push( holeIndex );\\n\\t\\t\\t\\tholeIndex += holes[ i ].length;\\n\\t\\t\\t\\taddContour( vertices, holes[ i ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar triangles = Earcut.triangulate( vertices, holeIndices );\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tfor ( var i = 0; i < triangles.length; i += 3 ) {\\n\\n\\t\\t\\t\\tfaces.push( triangles.slice( i, i + 3 ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn faces;\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t *\\n\\t * Creates extruded geometry from a path shape.\\n\\t *\\n\\t * parameters = {\\n\\t *\\n\\t * curveSegments: , // number of points on the curves\\n\\t * steps: , // number of points for z-side extrusions / used for subdividing segments of extrude spline too\\n\\t * amount: , // Depth to extrude the shape\\n\\t *\\n\\t * bevelEnabled: , // turn on bevel\\n\\t * bevelThickness: , // how deep into the original shape bevel goes\\n\\t * bevelSize: , // how far from shape outline is bevel\\n\\t * bevelSegments: , // number of bevel layers\\n\\t *\\n\\t * extrudePath: // curve to extrude shape along\\n\\t * frames: // containing arrays of tangents, normals, binormals\\n\\t *\\n\\t * UVGenerator: // object that provides UV generator functions\\n\\t *\\n\\t * }\\n\\t */\\n\\n\\t// ExtrudeGeometry\\n\\n\\tfunction ExtrudeGeometry( shapes, options ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'ExtrudeGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tshapes: shapes,\\n\\t\\t\\toptions: options\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new ExtrudeBufferGeometry( shapes, options ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tExtrudeGeometry.prototype = Object.create( Geometry.prototype );\\n\\tExtrudeGeometry.prototype.constructor = ExtrudeGeometry;\\n\\n\\t// ExtrudeBufferGeometry\\n\\n\\tfunction ExtrudeBufferGeometry( shapes, options ) {\\n\\n\\t\\tif ( typeof ( shapes ) === \\\"undefined\\\" ) {\\n\\n\\t\\t\\treturn;\\n\\n\\t\\t}\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'ExtrudeBufferGeometry';\\n\\n\\t\\tshapes = Array.isArray( shapes ) ? shapes : [ shapes ];\\n\\n\\t\\tthis.addShapeList( shapes, options );\\n\\n\\t\\tthis.computeVertexNormals();\\n\\n\\t\\t// can't really use automatic vertex normals\\n\\t\\t// as then front and back sides get smoothed too\\n\\t\\t// should do separate smoothing just for sides\\n\\n\\t\\t//this.computeVertexNormals();\\n\\n\\t\\t//console.log( \\\"took\\\", ( Date.now() - startTime ) );\\n\\n\\t}\\n\\n\\tExtrudeBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tExtrudeBufferGeometry.prototype.constructor = ExtrudeBufferGeometry;\\n\\n\\tExtrudeBufferGeometry.prototype.getArrays = function () {\\n\\n\\t\\tvar positionAttribute = this.getAttribute( \\\"position\\\" );\\n\\t\\tvar verticesArray = positionAttribute ? Array.prototype.slice.call( positionAttribute.array ) : [];\\n\\n\\t\\tvar uvAttribute = this.getAttribute( \\\"uv\\\" );\\n\\t\\tvar uvArray = uvAttribute ? Array.prototype.slice.call( uvAttribute.array ) : [];\\n\\n\\t\\tvar IndexAttribute = this.index;\\n\\t\\tvar indicesArray = IndexAttribute ? Array.prototype.slice.call( IndexAttribute.array ) : [];\\n\\n\\t\\treturn {\\n\\t\\t\\tposition: verticesArray,\\n\\t\\t\\tuv: uvArray,\\n\\t\\t\\tindex: indicesArray\\n\\t\\t};\\n\\n\\t};\\n\\n\\tExtrudeBufferGeometry.prototype.addShapeList = function ( shapes, options ) {\\n\\n\\t\\tvar sl = shapes.length;\\n\\t\\toptions.arrays = this.getArrays();\\n\\n\\t\\tfor ( var s = 0; s < sl; s ++ ) {\\n\\n\\t\\t\\tvar shape = shapes[ s ];\\n\\t\\t\\tthis.addShape( shape, options );\\n\\n\\t\\t}\\n\\n\\t\\tthis.setIndex( options.arrays.index );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( options.arrays.position, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( options.arrays.uv, 2 ) );\\n\\n\\t};\\n\\n\\tExtrudeBufferGeometry.prototype.addShape = function ( shape, options ) {\\n\\n\\t\\tvar arrays = options.arrays ? options.arrays : this.getArrays();\\n\\t\\tvar verticesArray = arrays.position;\\n\\t\\tvar indicesArray = arrays.index;\\n\\t\\tvar uvArray = arrays.uv;\\n\\n\\t\\tvar placeholder = [];\\n\\n\\n\\t\\tvar amount = options.amount !== undefined ? options.amount : 100;\\n\\n\\t\\tvar bevelThickness = options.bevelThickness !== undefined ? options.bevelThickness : 6; // 10\\n\\t\\tvar bevelSize = options.bevelSize !== undefined ? options.bevelSize : bevelThickness - 2; // 8\\n\\t\\tvar bevelSegments = options.bevelSegments !== undefined ? options.bevelSegments : 3;\\n\\n\\t\\tvar bevelEnabled = options.bevelEnabled !== undefined ? options.bevelEnabled : true; // false\\n\\n\\t\\tvar curveSegments = options.curveSegments !== undefined ? options.curveSegments : 12;\\n\\n\\t\\tvar steps = options.steps !== undefined ? options.steps : 1;\\n\\n\\t\\tvar extrudePath = options.extrudePath;\\n\\t\\tvar extrudePts, extrudeByPath = false;\\n\\n\\t\\t// Use default WorldUVGenerator if no UV generators are specified.\\n\\t\\tvar uvgen = options.UVGenerator !== undefined ? options.UVGenerator : ExtrudeGeometry.WorldUVGenerator;\\n\\n\\t\\tvar splineTube, binormal, normal, position2;\\n\\t\\tif ( extrudePath ) {\\n\\n\\t\\t\\textrudePts = extrudePath.getSpacedPoints( steps );\\n\\n\\t\\t\\textrudeByPath = true;\\n\\t\\t\\tbevelEnabled = false; // bevels not supported for path extrusion\\n\\n\\t\\t\\t// SETUP TNB variables\\n\\n\\t\\t\\t// TODO1 - have a .isClosed in spline?\\n\\n\\t\\t\\tsplineTube = options.frames !== undefined ? options.frames : extrudePath.computeFrenetFrames( steps, false );\\n\\n\\t\\t\\t// console.log(splineTube, 'splineTube', splineTube.normals.length, 'steps', steps, 'extrudePts', extrudePts.length);\\n\\n\\t\\t\\tbinormal = new Vector3();\\n\\t\\t\\tnormal = new Vector3();\\n\\t\\t\\tposition2 = new Vector3();\\n\\n\\t\\t}\\n\\n\\t\\t// Safeguards if bevels are not enabled\\n\\n\\t\\tif ( ! bevelEnabled ) {\\n\\n\\t\\t\\tbevelSegments = 0;\\n\\t\\t\\tbevelThickness = 0;\\n\\t\\t\\tbevelSize = 0;\\n\\n\\t\\t}\\n\\n\\t\\t// Variables initialization\\n\\n\\t\\tvar ahole, h, hl; // looping of holes\\n\\t\\tvar scope = this;\\n\\n\\t\\tvar shapePoints = shape.extractPoints( curveSegments );\\n\\n\\t\\tvar vertices = shapePoints.shape;\\n\\t\\tvar holes = shapePoints.holes;\\n\\n\\t\\tvar reverse = ! ShapeUtils.isClockWise( vertices );\\n\\n\\t\\tif ( reverse ) {\\n\\n\\t\\t\\tvertices = vertices.reverse();\\n\\n\\t\\t\\t// Maybe we should also check if holes are in the opposite direction, just to be safe ...\\n\\n\\t\\t\\tfor ( h = 0, hl = holes.length; h < hl; h ++ ) {\\n\\n\\t\\t\\t\\tahole = holes[ h ];\\n\\n\\t\\t\\t\\tif ( ShapeUtils.isClockWise( ahole ) ) {\\n\\n\\t\\t\\t\\t\\tholes[ h ] = ahole.reverse();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\n\\t\\tvar faces = ShapeUtils.triangulateShape( vertices, holes );\\n\\n\\t\\t/* Vertices */\\n\\n\\t\\tvar contour = vertices; // vertices has all points but contour has only points of circumference\\n\\n\\t\\tfor ( h = 0, hl = holes.length; h < hl; h ++ ) {\\n\\n\\t\\t\\tahole = holes[ h ];\\n\\n\\t\\t\\tvertices = vertices.concat( ahole );\\n\\n\\t\\t}\\n\\n\\n\\t\\tfunction scalePt2( pt, vec, size ) {\\n\\n\\t\\t\\tif ( ! vec ) console.error( \\\"THREE.ExtrudeGeometry: vec does not exist\\\" );\\n\\n\\t\\t\\treturn vec.clone().multiplyScalar( size ).add( pt );\\n\\n\\t\\t}\\n\\n\\t\\tvar b, bs, t, z,\\n\\t\\t\\tvert, vlen = vertices.length,\\n\\t\\t\\tface, flen = faces.length;\\n\\n\\n\\t\\t// Find directions for point movement\\n\\n\\n\\t\\tfunction getBevelVec( inPt, inPrev, inNext ) {\\n\\n\\t\\t\\t// computes for inPt the corresponding point inPt' on a new contour\\n\\t\\t\\t// shifted by 1 unit (length of normalized vector) to the left\\n\\t\\t\\t// if we walk along contour clockwise, this new contour is outside the old one\\n\\t\\t\\t//\\n\\t\\t\\t// inPt' is the intersection of the two lines parallel to the two\\n\\t\\t\\t// adjacent edges of inPt at a distance of 1 unit on the left side.\\n\\n\\t\\t\\tvar v_trans_x, v_trans_y, shrink_by; // resulting translation vector for inPt\\n\\n\\t\\t\\t// good reading for geometry algorithms (here: line-line intersection)\\n\\t\\t\\t// http://geomalgorithms.com/a05-_intersect-1.html\\n\\n\\t\\t\\tvar v_prev_x = inPt.x - inPrev.x,\\n\\t\\t\\t\\tv_prev_y = inPt.y - inPrev.y;\\n\\t\\t\\tvar v_next_x = inNext.x - inPt.x,\\n\\t\\t\\t\\tv_next_y = inNext.y - inPt.y;\\n\\n\\t\\t\\tvar v_prev_lensq = ( v_prev_x * v_prev_x + v_prev_y * v_prev_y );\\n\\n\\t\\t\\t// check for collinear edges\\n\\t\\t\\tvar collinear0 = ( v_prev_x * v_next_y - v_prev_y * v_next_x );\\n\\n\\t\\t\\tif ( Math.abs( collinear0 ) > Number.EPSILON ) {\\n\\n\\t\\t\\t\\t// not collinear\\n\\n\\t\\t\\t\\t// length of vectors for normalizing\\n\\n\\t\\t\\t\\tvar v_prev_len = Math.sqrt( v_prev_lensq );\\n\\t\\t\\t\\tvar v_next_len = Math.sqrt( v_next_x * v_next_x + v_next_y * v_next_y );\\n\\n\\t\\t\\t\\t// shift adjacent points by unit vectors to the left\\n\\n\\t\\t\\t\\tvar ptPrevShift_x = ( inPrev.x - v_prev_y / v_prev_len );\\n\\t\\t\\t\\tvar ptPrevShift_y = ( inPrev.y + v_prev_x / v_prev_len );\\n\\n\\t\\t\\t\\tvar ptNextShift_x = ( inNext.x - v_next_y / v_next_len );\\n\\t\\t\\t\\tvar ptNextShift_y = ( inNext.y + v_next_x / v_next_len );\\n\\n\\t\\t\\t\\t// scaling factor for v_prev to intersection point\\n\\n\\t\\t\\t\\tvar sf = ( ( ptNextShift_x - ptPrevShift_x ) * v_next_y -\\n\\t\\t\\t\\t\\t\\t( ptNextShift_y - ptPrevShift_y ) * v_next_x ) /\\n\\t\\t\\t\\t\\t( v_prev_x * v_next_y - v_prev_y * v_next_x );\\n\\n\\t\\t\\t\\t// vector from inPt to intersection point\\n\\n\\t\\t\\t\\tv_trans_x = ( ptPrevShift_x + v_prev_x * sf - inPt.x );\\n\\t\\t\\t\\tv_trans_y = ( ptPrevShift_y + v_prev_y * sf - inPt.y );\\n\\n\\t\\t\\t\\t// Don't normalize!, otherwise sharp corners become ugly\\n\\t\\t\\t\\t// but prevent crazy spikes\\n\\t\\t\\t\\tvar v_trans_lensq = ( v_trans_x * v_trans_x + v_trans_y * v_trans_y );\\n\\t\\t\\t\\tif ( v_trans_lensq <= 2 ) {\\n\\n\\t\\t\\t\\t\\treturn new Vector2( v_trans_x, v_trans_y );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tshrink_by = Math.sqrt( v_trans_lensq / 2 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// handle special case of collinear edges\\n\\n\\t\\t\\t\\tvar direction_eq = false; // assumes: opposite\\n\\t\\t\\t\\tif ( v_prev_x > Number.EPSILON ) {\\n\\n\\t\\t\\t\\t\\tif ( v_next_x > Number.EPSILON ) {\\n\\n\\t\\t\\t\\t\\t\\tdirection_eq = true;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tif ( v_prev_x < - Number.EPSILON ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( v_next_x < - Number.EPSILON ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tdirection_eq = true;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tif ( Math.sign( v_prev_y ) === Math.sign( v_next_y ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tdirection_eq = true;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( direction_eq ) {\\n\\n\\t\\t\\t\\t\\t// console.log(\\\"Warning: lines are a straight sequence\\\");\\n\\t\\t\\t\\t\\tv_trans_x = - v_prev_y;\\n\\t\\t\\t\\t\\tv_trans_y = v_prev_x;\\n\\t\\t\\t\\t\\tshrink_by = Math.sqrt( v_prev_lensq );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// console.log(\\\"Warning: lines are a straight spike\\\");\\n\\t\\t\\t\\t\\tv_trans_x = v_prev_x;\\n\\t\\t\\t\\t\\tv_trans_y = v_prev_y;\\n\\t\\t\\t\\t\\tshrink_by = Math.sqrt( v_prev_lensq / 2 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn new Vector2( v_trans_x / shrink_by, v_trans_y / shrink_by );\\n\\n\\t\\t}\\n\\n\\n\\t\\tvar contourMovements = [];\\n\\n\\t\\tfor ( var i = 0, il = contour.length, j = il - 1, k = i + 1; i < il; i ++, j ++, k ++ ) {\\n\\n\\t\\t\\tif ( j === il ) j = 0;\\n\\t\\t\\tif ( k === il ) k = 0;\\n\\n\\t\\t\\t// (j)---(i)---(k)\\n\\t\\t\\t// console.log('i,j,k', i, j , k)\\n\\n\\t\\t\\tcontourMovements[ i ] = getBevelVec( contour[ i ], contour[ j ], contour[ k ] );\\n\\n\\t\\t}\\n\\n\\t\\tvar holesMovements = [],\\n\\t\\t\\toneHoleMovements, verticesMovements = contourMovements.concat();\\n\\n\\t\\tfor ( h = 0, hl = holes.length; h < hl; h ++ ) {\\n\\n\\t\\t\\tahole = holes[ h ];\\n\\n\\t\\t\\toneHoleMovements = [];\\n\\n\\t\\t\\tfor ( i = 0, il = ahole.length, j = il - 1, k = i + 1; i < il; i ++, j ++, k ++ ) {\\n\\n\\t\\t\\t\\tif ( j === il ) j = 0;\\n\\t\\t\\t\\tif ( k === il ) k = 0;\\n\\n\\t\\t\\t\\t// (j)---(i)---(k)\\n\\t\\t\\t\\toneHoleMovements[ i ] = getBevelVec( ahole[ i ], ahole[ j ], ahole[ k ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tholesMovements.push( oneHoleMovements );\\n\\t\\t\\tverticesMovements = verticesMovements.concat( oneHoleMovements );\\n\\n\\t\\t}\\n\\n\\n\\t\\t// Loop bevelSegments, 1 for the front, 1 for the back\\n\\n\\t\\tfor ( b = 0; b < bevelSegments; b ++ ) {\\n\\n\\t\\t\\t//for ( b = bevelSegments; b > 0; b -- ) {\\n\\n\\t\\t\\tt = b / bevelSegments;\\n\\t\\t\\tz = bevelThickness * Math.cos( t * Math.PI / 2 );\\n\\t\\t\\tbs = bevelSize * Math.sin( t * Math.PI / 2 );\\n\\n\\t\\t\\t// contract shape\\n\\n\\t\\t\\tfor ( i = 0, il = contour.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvert = scalePt2( contour[ i ], contourMovements[ i ], bs );\\n\\n\\t\\t\\t\\tv( vert.x, vert.y, - z );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// expand holes\\n\\n\\t\\t\\tfor ( h = 0, hl = holes.length; h < hl; h ++ ) {\\n\\n\\t\\t\\t\\tahole = holes[ h ];\\n\\t\\t\\t\\toneHoleMovements = holesMovements[ h ];\\n\\n\\t\\t\\t\\tfor ( i = 0, il = ahole.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs );\\n\\n\\t\\t\\t\\t\\tv( vert.x, vert.y, - z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tbs = bevelSize;\\n\\n\\t\\t// Back facing vertices\\n\\n\\t\\tfor ( i = 0; i < vlen; i ++ ) {\\n\\n\\t\\t\\tvert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ];\\n\\n\\t\\t\\tif ( ! extrudeByPath ) {\\n\\n\\t\\t\\t\\tv( vert.x, vert.y, 0 );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// v( vert.x, vert.y + extrudePts[ 0 ].y, extrudePts[ 0 ].x );\\n\\n\\t\\t\\t\\tnormal.copy( splineTube.normals[ 0 ] ).multiplyScalar( vert.x );\\n\\t\\t\\t\\tbinormal.copy( splineTube.binormals[ 0 ] ).multiplyScalar( vert.y );\\n\\n\\t\\t\\t\\tposition2.copy( extrudePts[ 0 ] ).add( normal ).add( binormal );\\n\\n\\t\\t\\t\\tv( position2.x, position2.y, position2.z );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// Add stepped vertices...\\n\\t\\t// Including front facing vertices\\n\\n\\t\\tvar s;\\n\\n\\t\\tfor ( s = 1; s <= steps; s ++ ) {\\n\\n\\t\\t\\tfor ( i = 0; i < vlen; i ++ ) {\\n\\n\\t\\t\\t\\tvert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ];\\n\\n\\t\\t\\t\\tif ( ! extrudeByPath ) {\\n\\n\\t\\t\\t\\t\\tv( vert.x, vert.y, amount / steps * s );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// v( vert.x, vert.y + extrudePts[ s - 1 ].y, extrudePts[ s - 1 ].x );\\n\\n\\t\\t\\t\\t\\tnormal.copy( splineTube.normals[ s ] ).multiplyScalar( vert.x );\\n\\t\\t\\t\\t\\tbinormal.copy( splineTube.binormals[ s ] ).multiplyScalar( vert.y );\\n\\n\\t\\t\\t\\t\\tposition2.copy( extrudePts[ s ] ).add( normal ).add( binormal );\\n\\n\\t\\t\\t\\t\\tv( position2.x, position2.y, position2.z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\n\\t\\t// Add bevel segments planes\\n\\n\\t\\t//for ( b = 1; b <= bevelSegments; b ++ ) {\\n\\t\\tfor ( b = bevelSegments - 1; b >= 0; b -- ) {\\n\\n\\t\\t\\tt = b / bevelSegments;\\n\\t\\t\\tz = bevelThickness * Math.cos( t * Math.PI / 2 );\\n\\t\\t\\tbs = bevelSize * Math.sin( t * Math.PI / 2 );\\n\\n\\t\\t\\t// contract shape\\n\\n\\t\\t\\tfor ( i = 0, il = contour.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvert = scalePt2( contour[ i ], contourMovements[ i ], bs );\\n\\t\\t\\t\\tv( vert.x, vert.y, amount + z );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// expand holes\\n\\n\\t\\t\\tfor ( h = 0, hl = holes.length; h < hl; h ++ ) {\\n\\n\\t\\t\\t\\tahole = holes[ h ];\\n\\t\\t\\t\\toneHoleMovements = holesMovements[ h ];\\n\\n\\t\\t\\t\\tfor ( i = 0, il = ahole.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs );\\n\\n\\t\\t\\t\\t\\tif ( ! extrudeByPath ) {\\n\\n\\t\\t\\t\\t\\t\\tv( vert.x, vert.y, amount + z );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tv( vert.x, vert.y + extrudePts[ steps - 1 ].y, extrudePts[ steps - 1 ].x + z );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t/* Faces */\\n\\n\\t\\t// Top and bottom faces\\n\\n\\t\\tbuildLidFaces();\\n\\n\\t\\t// Sides faces\\n\\n\\t\\tbuildSideFaces();\\n\\n\\n\\t\\t///// Internal functions\\n\\n\\t\\tfunction buildLidFaces() {\\n\\n\\t\\t\\tvar start = verticesArray.length / 3;\\n\\n\\t\\t\\tif ( bevelEnabled ) {\\n\\n\\t\\t\\t\\tvar layer = 0; // steps + 1\\n\\t\\t\\t\\tvar offset = vlen * layer;\\n\\n\\t\\t\\t\\t// Bottom faces\\n\\n\\t\\t\\t\\tfor ( i = 0; i < flen; i ++ ) {\\n\\n\\t\\t\\t\\t\\tface = faces[ i ];\\n\\t\\t\\t\\t\\tf3( face[ 2 ] + offset, face[ 1 ] + offset, face[ 0 ] + offset );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tlayer = steps + bevelSegments * 2;\\n\\t\\t\\t\\toffset = vlen * layer;\\n\\n\\t\\t\\t\\t// Top faces\\n\\n\\t\\t\\t\\tfor ( i = 0; i < flen; i ++ ) {\\n\\n\\t\\t\\t\\t\\tface = faces[ i ];\\n\\t\\t\\t\\t\\tf3( face[ 0 ] + offset, face[ 1 ] + offset, face[ 2 ] + offset );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// Bottom faces\\n\\n\\t\\t\\t\\tfor ( i = 0; i < flen; i ++ ) {\\n\\n\\t\\t\\t\\t\\tface = faces[ i ];\\n\\t\\t\\t\\t\\tf3( face[ 2 ], face[ 1 ], face[ 0 ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// Top faces\\n\\n\\t\\t\\t\\tfor ( i = 0; i < flen; i ++ ) {\\n\\n\\t\\t\\t\\t\\tface = faces[ i ];\\n\\t\\t\\t\\t\\tf3( face[ 0 ] + vlen * steps, face[ 1 ] + vlen * steps, face[ 2 ] + vlen * steps );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tscope.addGroup( start, verticesArray.length / 3 - start, options.material !== undefined ? options.material : 0 );\\n\\n\\t\\t}\\n\\n\\t\\t// Create faces for the z-sides of the shape\\n\\n\\t\\tfunction buildSideFaces() {\\n\\n\\t\\t\\tvar start = verticesArray.length / 3;\\n\\t\\t\\tvar layeroffset = 0;\\n\\t\\t\\tsidewalls( contour, layeroffset );\\n\\t\\t\\tlayeroffset += contour.length;\\n\\n\\t\\t\\tfor ( h = 0, hl = holes.length; h < hl; h ++ ) {\\n\\n\\t\\t\\t\\tahole = holes[ h ];\\n\\t\\t\\t\\tsidewalls( ahole, layeroffset );\\n\\n\\t\\t\\t\\t//, true\\n\\t\\t\\t\\tlayeroffset += ahole.length;\\n\\n\\t\\t\\t}\\n\\n\\n\\t\\t\\tscope.addGroup( start, verticesArray.length / 3 - start, options.extrudeMaterial !== undefined ? options.extrudeMaterial : 1 );\\n\\n\\n\\t\\t}\\n\\n\\t\\tfunction sidewalls( contour, layeroffset ) {\\n\\n\\t\\t\\tvar j, k;\\n\\t\\t\\ti = contour.length;\\n\\n\\t\\t\\twhile ( -- i >= 0 ) {\\n\\n\\t\\t\\t\\tj = i;\\n\\t\\t\\t\\tk = i - 1;\\n\\t\\t\\t\\tif ( k < 0 ) k = contour.length - 1;\\n\\n\\t\\t\\t\\t//console.log('b', i,j, i-1, k,vertices.length);\\n\\n\\t\\t\\t\\tvar s = 0,\\n\\t\\t\\t\\t\\tsl = steps + bevelSegments * 2;\\n\\n\\t\\t\\t\\tfor ( s = 0; s < sl; s ++ ) {\\n\\n\\t\\t\\t\\t\\tvar slen1 = vlen * s;\\n\\t\\t\\t\\t\\tvar slen2 = vlen * ( s + 1 );\\n\\n\\t\\t\\t\\t\\tvar a = layeroffset + j + slen1,\\n\\t\\t\\t\\t\\t\\tb = layeroffset + k + slen1,\\n\\t\\t\\t\\t\\t\\tc = layeroffset + k + slen2,\\n\\t\\t\\t\\t\\t\\td = layeroffset + j + slen2;\\n\\n\\t\\t\\t\\t\\tf4( a, b, c, d );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction v( x, y, z ) {\\n\\n\\t\\t\\tplaceholder.push( x );\\n\\t\\t\\tplaceholder.push( y );\\n\\t\\t\\tplaceholder.push( z );\\n\\n\\t\\t}\\n\\n\\n\\t\\tfunction f3( a, b, c ) {\\n\\n\\t\\t\\taddVertex( a );\\n\\t\\t\\taddVertex( b );\\n\\t\\t\\taddVertex( c );\\n\\n\\t\\t\\tvar nextIndex = verticesArray.length / 3;\\n\\t\\t\\tvar uvs = uvgen.generateTopUV( scope, verticesArray, nextIndex - 3, nextIndex - 2, nextIndex - 1 );\\n\\n\\t\\t\\taddUV( uvs[ 0 ] );\\n\\t\\t\\taddUV( uvs[ 1 ] );\\n\\t\\t\\taddUV( uvs[ 2 ] );\\n\\n\\t\\t}\\n\\n\\t\\tfunction f4( a, b, c, d ) {\\n\\n\\t\\t\\taddVertex( a );\\n\\t\\t\\taddVertex( b );\\n\\t\\t\\taddVertex( d );\\n\\n\\t\\t\\taddVertex( b );\\n\\t\\t\\taddVertex( c );\\n\\t\\t\\taddVertex( d );\\n\\n\\n\\t\\t\\tvar nextIndex = verticesArray.length / 3;\\n\\t\\t\\tvar uvs = uvgen.generateSideWallUV( scope, verticesArray, nextIndex - 6, nextIndex - 3, nextIndex - 2, nextIndex - 1 );\\n\\n\\t\\t\\taddUV( uvs[ 0 ] );\\n\\t\\t\\taddUV( uvs[ 1 ] );\\n\\t\\t\\taddUV( uvs[ 3 ] );\\n\\n\\t\\t\\taddUV( uvs[ 1 ] );\\n\\t\\t\\taddUV( uvs[ 2 ] );\\n\\t\\t\\taddUV( uvs[ 3 ] );\\n\\n\\t\\t}\\n\\n\\t\\tfunction addVertex( index ) {\\n\\n\\t\\t\\tindicesArray.push( verticesArray.length / 3 );\\n\\t\\t\\tverticesArray.push( placeholder[ index * 3 + 0 ] );\\n\\t\\t\\tverticesArray.push( placeholder[ index * 3 + 1 ] );\\n\\t\\t\\tverticesArray.push( placeholder[ index * 3 + 2 ] );\\n\\n\\t\\t}\\n\\n\\n\\t\\tfunction addUV( vector2 ) {\\n\\n\\t\\t\\tuvArray.push( vector2.x );\\n\\t\\t\\tuvArray.push( vector2.y );\\n\\n\\t\\t}\\n\\n\\t\\tif ( ! options.arrays ) {\\n\\n\\t\\t\\tthis.setIndex( indicesArray );\\n\\t\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( verticesArray, 3 ) );\\n\\t\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvArray, 2 ) );\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\tExtrudeGeometry.WorldUVGenerator = {\\n\\n\\t\\tgenerateTopUV: function ( geometry, vertices, indexA, indexB, indexC ) {\\n\\n\\t\\t\\tvar a_x = vertices[ indexA * 3 ];\\n\\t\\t\\tvar a_y = vertices[ indexA * 3 + 1 ];\\n\\t\\t\\tvar b_x = vertices[ indexB * 3 ];\\n\\t\\t\\tvar b_y = vertices[ indexB * 3 + 1 ];\\n\\t\\t\\tvar c_x = vertices[ indexC * 3 ];\\n\\t\\t\\tvar c_y = vertices[ indexC * 3 + 1 ];\\n\\n\\t\\t\\treturn [\\n\\t\\t\\t\\tnew Vector2( a_x, a_y ),\\n\\t\\t\\t\\tnew Vector2( b_x, b_y ),\\n\\t\\t\\t\\tnew Vector2( c_x, c_y )\\n\\t\\t\\t];\\n\\n\\t\\t},\\n\\n\\t\\tgenerateSideWallUV: function ( geometry, vertices, indexA, indexB, indexC, indexD ) {\\n\\n\\t\\t\\tvar a_x = vertices[ indexA * 3 ];\\n\\t\\t\\tvar a_y = vertices[ indexA * 3 + 1 ];\\n\\t\\t\\tvar a_z = vertices[ indexA * 3 + 2 ];\\n\\t\\t\\tvar b_x = vertices[ indexB * 3 ];\\n\\t\\t\\tvar b_y = vertices[ indexB * 3 + 1 ];\\n\\t\\t\\tvar b_z = vertices[ indexB * 3 + 2 ];\\n\\t\\t\\tvar c_x = vertices[ indexC * 3 ];\\n\\t\\t\\tvar c_y = vertices[ indexC * 3 + 1 ];\\n\\t\\t\\tvar c_z = vertices[ indexC * 3 + 2 ];\\n\\t\\t\\tvar d_x = vertices[ indexD * 3 ];\\n\\t\\t\\tvar d_y = vertices[ indexD * 3 + 1 ];\\n\\t\\t\\tvar d_z = vertices[ indexD * 3 + 2 ];\\n\\n\\t\\t\\tif ( Math.abs( a_y - b_y ) < 0.01 ) {\\n\\n\\t\\t\\t\\treturn [\\n\\t\\t\\t\\t\\tnew Vector2( a_x, 1 - a_z ),\\n\\t\\t\\t\\t\\tnew Vector2( b_x, 1 - b_z ),\\n\\t\\t\\t\\t\\tnew Vector2( c_x, 1 - c_z ),\\n\\t\\t\\t\\t\\tnew Vector2( d_x, 1 - d_z )\\n\\t\\t\\t\\t];\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\treturn [\\n\\t\\t\\t\\t\\tnew Vector2( a_y, 1 - a_z ),\\n\\t\\t\\t\\t\\tnew Vector2( b_y, 1 - b_z ),\\n\\t\\t\\t\\t\\tnew Vector2( c_y, 1 - c_z ),\\n\\t\\t\\t\\t\\tnew Vector2( d_y, 1 - d_z )\\n\\t\\t\\t\\t];\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\t};\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * Text = 3D Text\\n\\t *\\n\\t * parameters = {\\n\\t * font: , // font\\n\\t *\\n\\t * size: , // size of the text\\n\\t * height: , // thickness to extrude text\\n\\t * curveSegments: , // number of points on the curves\\n\\t *\\n\\t * bevelEnabled: , // turn on bevel\\n\\t * bevelThickness: , // how deep into text bevel goes\\n\\t * bevelSize: // how far from text outline is bevel\\n\\t * }\\n\\t */\\n\\n\\t// TextGeometry\\n\\n\\tfunction TextGeometry( text, parameters ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'TextGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\ttext: text,\\n\\t\\t\\tparameters: parameters\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new TextBufferGeometry( text, parameters ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tTextGeometry.prototype = Object.create( Geometry.prototype );\\n\\tTextGeometry.prototype.constructor = TextGeometry;\\n\\n\\t// TextBufferGeometry\\n\\n\\tfunction TextBufferGeometry( text, parameters ) {\\n\\n\\t\\tparameters = parameters || {};\\n\\n\\t\\tvar font = parameters.font;\\n\\n\\t\\tif ( ! ( font && font.isFont ) ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.TextGeometry: font parameter is not an instance of THREE.Font.' );\\n\\t\\t\\treturn new Geometry();\\n\\n\\t\\t}\\n\\n\\t\\tvar shapes = font.generateShapes( text, parameters.size, parameters.curveSegments );\\n\\n\\t\\t// translate parameters to ExtrudeGeometry API\\n\\n\\t\\tparameters.amount = parameters.height !== undefined ? parameters.height : 50;\\n\\n\\t\\t// defaults\\n\\n\\t\\tif ( parameters.bevelThickness === undefined ) parameters.bevelThickness = 10;\\n\\t\\tif ( parameters.bevelSize === undefined ) parameters.bevelSize = 8;\\n\\t\\tif ( parameters.bevelEnabled === undefined ) parameters.bevelEnabled = false;\\n\\n\\t\\tExtrudeBufferGeometry.call( this, shapes, parameters );\\n\\n\\t\\tthis.type = 'TextBufferGeometry';\\n\\n\\t}\\n\\n\\tTextBufferGeometry.prototype = Object.create( ExtrudeBufferGeometry.prototype );\\n\\tTextBufferGeometry.prototype.constructor = TextBufferGeometry;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author benaadams / https://twitter.com/ben_a_adams\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// SphereGeometry\\n\\n\\tfunction SphereGeometry( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'SphereGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\twidthSegments: widthSegments,\\n\\t\\t\\theightSegments: heightSegments,\\n\\t\\t\\tphiStart: phiStart,\\n\\t\\t\\tphiLength: phiLength,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new SphereBufferGeometry( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tSphereGeometry.prototype = Object.create( Geometry.prototype );\\n\\tSphereGeometry.prototype.constructor = SphereGeometry;\\n\\n\\t// SphereBufferGeometry\\n\\n\\tfunction SphereBufferGeometry( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'SphereBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\twidthSegments: widthSegments,\\n\\t\\t\\theightSegments: heightSegments,\\n\\t\\t\\tphiStart: phiStart,\\n\\t\\t\\tphiLength: phiLength,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t\\tradius = radius || 1;\\n\\n\\t\\twidthSegments = Math.max( 3, Math.floor( widthSegments ) || 8 );\\n\\t\\theightSegments = Math.max( 2, Math.floor( heightSegments ) || 6 );\\n\\n\\t\\tphiStart = phiStart !== undefined ? phiStart : 0;\\n\\t\\tphiLength = phiLength !== undefined ? phiLength : Math.PI * 2;\\n\\n\\t\\tthetaStart = thetaStart !== undefined ? thetaStart : 0;\\n\\t\\tthetaLength = thetaLength !== undefined ? thetaLength : Math.PI;\\n\\n\\t\\tvar thetaEnd = thetaStart + thetaLength;\\n\\n\\t\\tvar ix, iy;\\n\\n\\t\\tvar index = 0;\\n\\t\\tvar grid = [];\\n\\n\\t\\tvar vertex = new Vector3();\\n\\t\\tvar normal = new Vector3();\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// generate vertices, normals and uvs\\n\\n\\t\\tfor ( iy = 0; iy <= heightSegments; iy ++ ) {\\n\\n\\t\\t\\tvar verticesRow = [];\\n\\n\\t\\t\\tvar v = iy / heightSegments;\\n\\n\\t\\t\\tfor ( ix = 0; ix <= widthSegments; ix ++ ) {\\n\\n\\t\\t\\t\\tvar u = ix / widthSegments;\\n\\n\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\tvertex.x = - radius * Math.cos( phiStart + u * phiLength ) * Math.sin( thetaStart + v * thetaLength );\\n\\t\\t\\t\\tvertex.y = radius * Math.cos( thetaStart + v * thetaLength );\\n\\t\\t\\t\\tvertex.z = radius * Math.sin( phiStart + u * phiLength ) * Math.sin( thetaStart + v * thetaLength );\\n\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t// normal\\n\\n\\t\\t\\t\\tnormal.set( vertex.x, vertex.y, vertex.z ).normalize();\\n\\t\\t\\t\\tnormals.push( normal.x, normal.y, normal.z );\\n\\n\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\tuvs.push( u, 1 - v );\\n\\n\\t\\t\\t\\tverticesRow.push( index ++ );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tgrid.push( verticesRow );\\n\\n\\t\\t}\\n\\n\\t\\t// indices\\n\\n\\t\\tfor ( iy = 0; iy < heightSegments; iy ++ ) {\\n\\n\\t\\t\\tfor ( ix = 0; ix < widthSegments; ix ++ ) {\\n\\n\\t\\t\\t\\tvar a = grid[ iy ][ ix + 1 ];\\n\\t\\t\\t\\tvar b = grid[ iy ][ ix ];\\n\\t\\t\\t\\tvar c = grid[ iy + 1 ][ ix ];\\n\\t\\t\\t\\tvar d = grid[ iy + 1 ][ ix + 1 ];\\n\\n\\t\\t\\t\\tif ( iy !== 0 || thetaStart > 0 ) indices.push( a, b, d );\\n\\t\\t\\t\\tif ( iy !== heightSegments - 1 || thetaEnd < Math.PI ) indices.push( b, c, d );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t}\\n\\n\\tSphereBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tSphereBufferGeometry.prototype.constructor = SphereBufferGeometry;\\n\\n\\t/**\\n\\t * @author Kaleb Murphy\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// RingGeometry\\n\\n\\tfunction RingGeometry( innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'RingGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tinnerRadius: innerRadius,\\n\\t\\t\\touterRadius: outerRadius,\\n\\t\\t\\tthetaSegments: thetaSegments,\\n\\t\\t\\tphiSegments: phiSegments,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new RingBufferGeometry( innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tRingGeometry.prototype = Object.create( Geometry.prototype );\\n\\tRingGeometry.prototype.constructor = RingGeometry;\\n\\n\\t// RingBufferGeometry\\n\\n\\tfunction RingBufferGeometry( innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'RingBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tinnerRadius: innerRadius,\\n\\t\\t\\touterRadius: outerRadius,\\n\\t\\t\\tthetaSegments: thetaSegments,\\n\\t\\t\\tphiSegments: phiSegments,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t\\tinnerRadius = innerRadius || 0.5;\\n\\t\\touterRadius = outerRadius || 1;\\n\\n\\t\\tthetaStart = thetaStart !== undefined ? thetaStart : 0;\\n\\t\\tthetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2;\\n\\n\\t\\tthetaSegments = thetaSegments !== undefined ? Math.max( 3, thetaSegments ) : 8;\\n\\t\\tphiSegments = phiSegments !== undefined ? Math.max( 1, phiSegments ) : 1;\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// some helper variables\\n\\n\\t\\tvar segment;\\n\\t\\tvar radius = innerRadius;\\n\\t\\tvar radiusStep = ( ( outerRadius - innerRadius ) / phiSegments );\\n\\t\\tvar vertex = new Vector3();\\n\\t\\tvar uv = new Vector2();\\n\\t\\tvar j, i;\\n\\n\\t\\t// generate vertices, normals and uvs\\n\\n\\t\\tfor ( j = 0; j <= phiSegments; j ++ ) {\\n\\n\\t\\t\\tfor ( i = 0; i <= thetaSegments; i ++ ) {\\n\\n\\t\\t\\t\\t// values are generate from the inside of the ring to the outside\\n\\n\\t\\t\\t\\tsegment = thetaStart + i / thetaSegments * thetaLength;\\n\\n\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\tvertex.x = radius * Math.cos( segment );\\n\\t\\t\\t\\tvertex.y = radius * Math.sin( segment );\\n\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t// normal\\n\\n\\t\\t\\t\\tnormals.push( 0, 0, 1 );\\n\\n\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\tuv.x = ( vertex.x / outerRadius + 1 ) / 2;\\n\\t\\t\\t\\tuv.y = ( vertex.y / outerRadius + 1 ) / 2;\\n\\n\\t\\t\\t\\tuvs.push( uv.x, uv.y );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// increase the radius for next row of vertices\\n\\n\\t\\t\\tradius += radiusStep;\\n\\n\\t\\t}\\n\\n\\t\\t// indices\\n\\n\\t\\tfor ( j = 0; j < phiSegments; j ++ ) {\\n\\n\\t\\t\\tvar thetaSegmentLevel = j * ( thetaSegments + 1 );\\n\\n\\t\\t\\tfor ( i = 0; i < thetaSegments; i ++ ) {\\n\\n\\t\\t\\t\\tsegment = i + thetaSegmentLevel;\\n\\n\\t\\t\\t\\tvar a = segment;\\n\\t\\t\\t\\tvar b = segment + thetaSegments + 1;\\n\\t\\t\\t\\tvar c = segment + thetaSegments + 2;\\n\\t\\t\\t\\tvar d = segment + 1;\\n\\n\\t\\t\\t\\t// faces\\n\\n\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t}\\n\\n\\tRingBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tRingBufferGeometry.prototype.constructor = RingBufferGeometry;\\n\\n\\t/**\\n\\t * @author astrodud / http://astrodud.isgreat.org/\\n\\t * @author zz85 / https://github.com/zz85\\n\\t * @author bhouston / http://clara.io\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// LatheGeometry\\n\\n\\tfunction LatheGeometry( points, segments, phiStart, phiLength ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'LatheGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tpoints: points,\\n\\t\\t\\tsegments: segments,\\n\\t\\t\\tphiStart: phiStart,\\n\\t\\t\\tphiLength: phiLength\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new LatheBufferGeometry( points, segments, phiStart, phiLength ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tLatheGeometry.prototype = Object.create( Geometry.prototype );\\n\\tLatheGeometry.prototype.constructor = LatheGeometry;\\n\\n\\t// LatheBufferGeometry\\n\\n\\tfunction LatheBufferGeometry( points, segments, phiStart, phiLength ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'LatheBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tpoints: points,\\n\\t\\t\\tsegments: segments,\\n\\t\\t\\tphiStart: phiStart,\\n\\t\\t\\tphiLength: phiLength\\n\\t\\t};\\n\\n\\t\\tsegments = Math.floor( segments ) || 12;\\n\\t\\tphiStart = phiStart || 0;\\n\\t\\tphiLength = phiLength || Math.PI * 2;\\n\\n\\t\\t// clamp phiLength so it's in range of [ 0, 2PI ]\\n\\n\\t\\tphiLength = _Math.clamp( phiLength, 0, Math.PI * 2 );\\n\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar base;\\n\\t\\tvar inverseSegments = 1.0 / segments;\\n\\t\\tvar vertex = new Vector3();\\n\\t\\tvar uv = new Vector2();\\n\\t\\tvar i, j;\\n\\n\\t\\t// generate vertices and uvs\\n\\n\\t\\tfor ( i = 0; i <= segments; i ++ ) {\\n\\n\\t\\t\\tvar phi = phiStart + i * inverseSegments * phiLength;\\n\\n\\t\\t\\tvar sin = Math.sin( phi );\\n\\t\\t\\tvar cos = Math.cos( phi );\\n\\n\\t\\t\\tfor ( j = 0; j <= ( points.length - 1 ); j ++ ) {\\n\\n\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\tvertex.x = points[ j ].x * sin;\\n\\t\\t\\t\\tvertex.y = points[ j ].y;\\n\\t\\t\\t\\tvertex.z = points[ j ].x * cos;\\n\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\tuv.x = i / segments;\\n\\t\\t\\t\\tuv.y = j / ( points.length - 1 );\\n\\n\\t\\t\\t\\tuvs.push( uv.x, uv.y );\\n\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// indices\\n\\n\\t\\tfor ( i = 0; i < segments; i ++ ) {\\n\\n\\t\\t\\tfor ( j = 0; j < ( points.length - 1 ); j ++ ) {\\n\\n\\t\\t\\t\\tbase = j + i * points.length;\\n\\n\\t\\t\\t\\tvar a = base;\\n\\t\\t\\t\\tvar b = base + points.length;\\n\\t\\t\\t\\tvar c = base + points.length + 1;\\n\\t\\t\\t\\tvar d = base + 1;\\n\\n\\t\\t\\t\\t// faces\\n\\n\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t\\t// generate normals\\n\\n\\t\\tthis.computeVertexNormals();\\n\\n\\t\\t// if the geometry is closed, we need to average the normals along the seam.\\n\\t\\t// because the corresponding vertices are identical (but still have different UVs).\\n\\n\\t\\tif ( phiLength === Math.PI * 2 ) {\\n\\n\\t\\t\\tvar normals = this.attributes.normal.array;\\n\\t\\t\\tvar n1 = new Vector3();\\n\\t\\t\\tvar n2 = new Vector3();\\n\\t\\t\\tvar n = new Vector3();\\n\\n\\t\\t\\t// this is the buffer offset for the last line of vertices\\n\\n\\t\\t\\tbase = segments * points.length * 3;\\n\\n\\t\\t\\tfor ( i = 0, j = 0; i < points.length; i ++, j += 3 ) {\\n\\n\\t\\t\\t\\t// select the normal of the vertex in the first line\\n\\n\\t\\t\\t\\tn1.x = normals[ j + 0 ];\\n\\t\\t\\t\\tn1.y = normals[ j + 1 ];\\n\\t\\t\\t\\tn1.z = normals[ j + 2 ];\\n\\n\\t\\t\\t\\t// select the normal of the vertex in the last line\\n\\n\\t\\t\\t\\tn2.x = normals[ base + j + 0 ];\\n\\t\\t\\t\\tn2.y = normals[ base + j + 1 ];\\n\\t\\t\\t\\tn2.z = normals[ base + j + 2 ];\\n\\n\\t\\t\\t\\t// average normals\\n\\n\\t\\t\\t\\tn.addVectors( n1, n2 ).normalize();\\n\\n\\t\\t\\t\\t// assign the new values to both normals\\n\\n\\t\\t\\t\\tnormals[ j + 0 ] = normals[ base + j + 0 ] = n.x;\\n\\t\\t\\t\\tnormals[ j + 1 ] = normals[ base + j + 1 ] = n.y;\\n\\t\\t\\t\\tnormals[ j + 2 ] = normals[ base + j + 2 ] = n.z;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tLatheBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tLatheBufferGeometry.prototype.constructor = LatheBufferGeometry;\\n\\n\\t/**\\n\\t * @author jonobr1 / http://jonobr1.com\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// ShapeGeometry\\n\\n\\tfunction ShapeGeometry( shapes, curveSegments ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'ShapeGeometry';\\n\\n\\t\\tif ( typeof curveSegments === 'object' ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.ShapeGeometry: Options parameter has been removed.' );\\n\\n\\t\\t\\tcurveSegments = curveSegments.curveSegments;\\n\\n\\t\\t}\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tshapes: shapes,\\n\\t\\t\\tcurveSegments: curveSegments\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new ShapeBufferGeometry( shapes, curveSegments ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tShapeGeometry.prototype = Object.create( Geometry.prototype );\\n\\tShapeGeometry.prototype.constructor = ShapeGeometry;\\n\\n\\tShapeGeometry.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Geometry.prototype.toJSON.call( this );\\n\\n\\t\\tvar shapes = this.parameters.shapes;\\n\\n\\t\\treturn toJSON( shapes, data );\\n\\n\\t};\\n\\n\\t// ShapeBufferGeometry\\n\\n\\tfunction ShapeBufferGeometry( shapes, curveSegments ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'ShapeBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tshapes: shapes,\\n\\t\\t\\tcurveSegments: curveSegments\\n\\t\\t};\\n\\n\\t\\tcurveSegments = curveSegments || 12;\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar groupStart = 0;\\n\\t\\tvar groupCount = 0;\\n\\n\\t\\t// allow single and array values for \\\"shapes\\\" parameter\\n\\n\\t\\tif ( Array.isArray( shapes ) === false ) {\\n\\n\\t\\t\\taddShape( shapes );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tfor ( var i = 0; i < shapes.length; i ++ ) {\\n\\n\\t\\t\\t\\taddShape( shapes[ i ] );\\n\\n\\t\\t\\t\\tthis.addGroup( groupStart, groupCount, i ); // enables MultiMaterial support\\n\\n\\t\\t\\t\\tgroupStart += groupCount;\\n\\t\\t\\t\\tgroupCount = 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\n\\t\\t// helper functions\\n\\n\\t\\tfunction addShape( shape ) {\\n\\n\\t\\t\\tvar i, l, shapeHole;\\n\\n\\t\\t\\tvar indexOffset = vertices.length / 3;\\n\\t\\t\\tvar points = shape.extractPoints( curveSegments );\\n\\n\\t\\t\\tvar shapeVertices = points.shape;\\n\\t\\t\\tvar shapeHoles = points.holes;\\n\\n\\t\\t\\t// check direction of vertices\\n\\n\\t\\t\\tif ( ShapeUtils.isClockWise( shapeVertices ) === false ) {\\n\\n\\t\\t\\t\\tshapeVertices = shapeVertices.reverse();\\n\\n\\t\\t\\t\\t// also check if holes are in the opposite direction\\n\\n\\t\\t\\t\\tfor ( i = 0, l = shapeHoles.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tshapeHole = shapeHoles[ i ];\\n\\n\\t\\t\\t\\t\\tif ( ShapeUtils.isClockWise( shapeHole ) === true ) {\\n\\n\\t\\t\\t\\t\\t\\tshapeHoles[ i ] = shapeHole.reverse();\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar faces = ShapeUtils.triangulateShape( shapeVertices, shapeHoles );\\n\\n\\t\\t\\t// join vertices of inner and outer paths to a single array\\n\\n\\t\\t\\tfor ( i = 0, l = shapeHoles.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tshapeHole = shapeHoles[ i ];\\n\\t\\t\\t\\tshapeVertices = shapeVertices.concat( shapeHole );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// vertices, normals, uvs\\n\\n\\t\\t\\tfor ( i = 0, l = shapeVertices.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar vertex = shapeVertices[ i ];\\n\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, 0 );\\n\\t\\t\\t\\tnormals.push( 0, 0, 1 );\\n\\t\\t\\t\\tuvs.push( vertex.x, vertex.y ); // world uvs\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// incides\\n\\n\\t\\t\\tfor ( i = 0, l = faces.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar face = faces[ i ];\\n\\n\\t\\t\\t\\tvar a = face[ 0 ] + indexOffset;\\n\\t\\t\\t\\tvar b = face[ 1 ] + indexOffset;\\n\\t\\t\\t\\tvar c = face[ 2 ] + indexOffset;\\n\\n\\t\\t\\t\\tindices.push( a, b, c );\\n\\t\\t\\t\\tgroupCount += 3;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tShapeBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tShapeBufferGeometry.prototype.constructor = ShapeBufferGeometry;\\n\\n\\tShapeBufferGeometry.prototype.toJSON = function () {\\n\\n\\t\\tvar data = BufferGeometry.prototype.toJSON.call( this );\\n\\n\\t\\tvar shapes = this.parameters.shapes;\\n\\n\\t\\treturn toJSON( shapes, data );\\n\\n\\t};\\n\\n\\t//\\n\\n\\tfunction toJSON( shapes, data ) {\\n\\n\\t\\tdata.shapes = [];\\n\\n\\t\\tif ( Array.isArray( shapes ) ) {\\n\\n\\t\\t\\tfor ( var i = 0, l = shapes.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar shape = shapes[ i ];\\n\\n\\t\\t\\t\\tdata.shapes.push( shape.uuid );\\n\\n\\t\\t\\t}\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tdata.shapes.push( shapes.uuid );\\n\\n\\t\\t}\\n\\n\\t\\treturn data;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\tfunction EdgesGeometry( geometry, thresholdAngle ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'EdgesGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tthresholdAngle: thresholdAngle\\n\\t\\t};\\n\\n\\t\\tthresholdAngle = ( thresholdAngle !== undefined ) ? thresholdAngle : 1;\\n\\n\\t\\t// buffer\\n\\n\\t\\tvar vertices = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar thresholdDot = Math.cos( _Math.DEG2RAD * thresholdAngle );\\n\\t\\tvar edge = [ 0, 0 ], edges = {}, edge1, edge2;\\n\\t\\tvar key, keys = [ 'a', 'b', 'c' ];\\n\\n\\t\\t// prepare source geometry\\n\\n\\t\\tvar geometry2;\\n\\n\\t\\tif ( geometry.isBufferGeometry ) {\\n\\n\\t\\t\\tgeometry2 = new Geometry();\\n\\t\\t\\tgeometry2.fromBufferGeometry( geometry );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tgeometry2 = geometry.clone();\\n\\n\\t\\t}\\n\\n\\t\\tgeometry2.mergeVertices();\\n\\t\\tgeometry2.computeFaceNormals();\\n\\n\\t\\tvar sourceVertices = geometry2.vertices;\\n\\t\\tvar faces = geometry2.faces;\\n\\n\\t\\t// now create a data structure where each entry represents an edge with its adjoining faces\\n\\n\\t\\tfor ( var i = 0, l = faces.length; i < l; i ++ ) {\\n\\n\\t\\t\\tvar face = faces[ i ];\\n\\n\\t\\t\\tfor ( var j = 0; j < 3; j ++ ) {\\n\\n\\t\\t\\t\\tedge1 = face[ keys[ j ] ];\\n\\t\\t\\t\\tedge2 = face[ keys[ ( j + 1 ) % 3 ] ];\\n\\t\\t\\t\\tedge[ 0 ] = Math.min( edge1, edge2 );\\n\\t\\t\\t\\tedge[ 1 ] = Math.max( edge1, edge2 );\\n\\n\\t\\t\\t\\tkey = edge[ 0 ] + ',' + edge[ 1 ];\\n\\n\\t\\t\\t\\tif ( edges[ key ] === undefined ) {\\n\\n\\t\\t\\t\\t\\tedges[ key ] = { index1: edge[ 0 ], index2: edge[ 1 ], face1: i, face2: undefined };\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tedges[ key ].face2 = i;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// generate vertices\\n\\n\\t\\tfor ( key in edges ) {\\n\\n\\t\\t\\tvar e = edges[ key ];\\n\\n\\t\\t\\t// an edge is only rendered if the angle (in degrees) between the face normals of the adjoining faces exceeds this value. default = 1 degree.\\n\\n\\t\\t\\tif ( e.face2 === undefined || faces[ e.face1 ].normal.dot( faces[ e.face2 ].normal ) <= thresholdDot ) {\\n\\n\\t\\t\\t\\tvar vertex = sourceVertices[ e.index1 ];\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\tvertex = sourceVertices[ e.index2 ];\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\n\\t}\\n\\n\\tEdgesGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tEdgesGeometry.prototype.constructor = EdgesGeometry;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// CylinderGeometry\\n\\n\\tfunction CylinderGeometry( radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'CylinderGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradiusTop: radiusTop,\\n\\t\\t\\tradiusBottom: radiusBottom,\\n\\t\\t\\theight: height,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\theightSegments: heightSegments,\\n\\t\\t\\topenEnded: openEnded,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new CylinderBufferGeometry( radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tCylinderGeometry.prototype = Object.create( Geometry.prototype );\\n\\tCylinderGeometry.prototype.constructor = CylinderGeometry;\\n\\n\\t// CylinderBufferGeometry\\n\\n\\tfunction CylinderBufferGeometry( radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'CylinderBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradiusTop: radiusTop,\\n\\t\\t\\tradiusBottom: radiusBottom,\\n\\t\\t\\theight: height,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\theightSegments: heightSegments,\\n\\t\\t\\topenEnded: openEnded,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t\\tvar scope = this;\\n\\n\\t\\tradiusTop = radiusTop !== undefined ? radiusTop : 1;\\n\\t\\tradiusBottom = radiusBottom !== undefined ? radiusBottom : 1;\\n\\t\\theight = height || 1;\\n\\n\\t\\tradialSegments = Math.floor( radialSegments ) || 8;\\n\\t\\theightSegments = Math.floor( heightSegments ) || 1;\\n\\n\\t\\topenEnded = openEnded !== undefined ? openEnded : false;\\n\\t\\tthetaStart = thetaStart !== undefined ? thetaStart : 0.0;\\n\\t\\tthetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2;\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar index = 0;\\n\\t\\tvar indexArray = [];\\n\\t\\tvar halfHeight = height / 2;\\n\\t\\tvar groupStart = 0;\\n\\n\\t\\t// generate geometry\\n\\n\\t\\tgenerateTorso();\\n\\n\\t\\tif ( openEnded === false ) {\\n\\n\\t\\t\\tif ( radiusTop > 0 ) generateCap( true );\\n\\t\\t\\tif ( radiusBottom > 0 ) generateCap( false );\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t\\tfunction generateTorso() {\\n\\n\\t\\t\\tvar x, y;\\n\\t\\t\\tvar normal = new Vector3();\\n\\t\\t\\tvar vertex = new Vector3();\\n\\n\\t\\t\\tvar groupCount = 0;\\n\\n\\t\\t\\t// this will be used to calculate the normal\\n\\t\\t\\tvar slope = ( radiusBottom - radiusTop ) / height;\\n\\n\\t\\t\\t// generate vertices, normals and uvs\\n\\n\\t\\t\\tfor ( y = 0; y <= heightSegments; y ++ ) {\\n\\n\\t\\t\\t\\tvar indexRow = [];\\n\\n\\t\\t\\t\\tvar v = y / heightSegments;\\n\\n\\t\\t\\t\\t// calculate the radius of the current row\\n\\n\\t\\t\\t\\tvar radius = v * ( radiusBottom - radiusTop ) + radiusTop;\\n\\n\\t\\t\\t\\tfor ( x = 0; x <= radialSegments; x ++ ) {\\n\\n\\t\\t\\t\\t\\tvar u = x / radialSegments;\\n\\n\\t\\t\\t\\t\\tvar theta = u * thetaLength + thetaStart;\\n\\n\\t\\t\\t\\t\\tvar sinTheta = Math.sin( theta );\\n\\t\\t\\t\\t\\tvar cosTheta = Math.cos( theta );\\n\\n\\t\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\t\\tvertex.x = radius * sinTheta;\\n\\t\\t\\t\\t\\tvertex.y = - v * height + halfHeight;\\n\\t\\t\\t\\t\\tvertex.z = radius * cosTheta;\\n\\t\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t\\t// normal\\n\\n\\t\\t\\t\\t\\tnormal.set( sinTheta, slope, cosTheta ).normalize();\\n\\t\\t\\t\\t\\tnormals.push( normal.x, normal.y, normal.z );\\n\\n\\t\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\t\\tuvs.push( u, 1 - v );\\n\\n\\t\\t\\t\\t\\t// save index of vertex in respective row\\n\\n\\t\\t\\t\\t\\tindexRow.push( index ++ );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// now save vertices of the row in our index array\\n\\n\\t\\t\\t\\tindexArray.push( indexRow );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// generate indices\\n\\n\\t\\t\\tfor ( x = 0; x < radialSegments; x ++ ) {\\n\\n\\t\\t\\t\\tfor ( y = 0; y < heightSegments; y ++ ) {\\n\\n\\t\\t\\t\\t\\t// we use the index array to access the correct indices\\n\\n\\t\\t\\t\\t\\tvar a = indexArray[ y ][ x ];\\n\\t\\t\\t\\t\\tvar b = indexArray[ y + 1 ][ x ];\\n\\t\\t\\t\\t\\tvar c = indexArray[ y + 1 ][ x + 1 ];\\n\\t\\t\\t\\t\\tvar d = indexArray[ y ][ x + 1 ];\\n\\n\\t\\t\\t\\t\\t// faces\\n\\n\\t\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t\\t\\t// update group counter\\n\\n\\t\\t\\t\\t\\tgroupCount += 6;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// add a group to the geometry. this will ensure multi material support\\n\\n\\t\\t\\tscope.addGroup( groupStart, groupCount, 0 );\\n\\n\\t\\t\\t// calculate new start value for groups\\n\\n\\t\\t\\tgroupStart += groupCount;\\n\\n\\t\\t}\\n\\n\\t\\tfunction generateCap( top ) {\\n\\n\\t\\t\\tvar x, centerIndexStart, centerIndexEnd;\\n\\n\\t\\t\\tvar uv = new Vector2();\\n\\t\\t\\tvar vertex = new Vector3();\\n\\n\\t\\t\\tvar groupCount = 0;\\n\\n\\t\\t\\tvar radius = ( top === true ) ? radiusTop : radiusBottom;\\n\\t\\t\\tvar sign = ( top === true ) ? 1 : - 1;\\n\\n\\t\\t\\t// save the index of the first center vertex\\n\\t\\t\\tcenterIndexStart = index;\\n\\n\\t\\t\\t// first we generate the center vertex data of the cap.\\n\\t\\t\\t// because the geometry needs one set of uvs per face,\\n\\t\\t\\t// we must generate a center vertex per face/segment\\n\\n\\t\\t\\tfor ( x = 1; x <= radialSegments; x ++ ) {\\n\\n\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\tvertices.push( 0, halfHeight * sign, 0 );\\n\\n\\t\\t\\t\\t// normal\\n\\n\\t\\t\\t\\tnormals.push( 0, sign, 0 );\\n\\n\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\tuvs.push( 0.5, 0.5 );\\n\\n\\t\\t\\t\\t// increase index\\n\\n\\t\\t\\t\\tindex ++;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// save the index of the last center vertex\\n\\n\\t\\t\\tcenterIndexEnd = index;\\n\\n\\t\\t\\t// now we generate the surrounding vertices, normals and uvs\\n\\n\\t\\t\\tfor ( x = 0; x <= radialSegments; x ++ ) {\\n\\n\\t\\t\\t\\tvar u = x / radialSegments;\\n\\t\\t\\t\\tvar theta = u * thetaLength + thetaStart;\\n\\n\\t\\t\\t\\tvar cosTheta = Math.cos( theta );\\n\\t\\t\\t\\tvar sinTheta = Math.sin( theta );\\n\\n\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\tvertex.x = radius * sinTheta;\\n\\t\\t\\t\\tvertex.y = halfHeight * sign;\\n\\t\\t\\t\\tvertex.z = radius * cosTheta;\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t// normal\\n\\n\\t\\t\\t\\tnormals.push( 0, sign, 0 );\\n\\n\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\tuv.x = ( cosTheta * 0.5 ) + 0.5;\\n\\t\\t\\t\\tuv.y = ( sinTheta * 0.5 * sign ) + 0.5;\\n\\t\\t\\t\\tuvs.push( uv.x, uv.y );\\n\\n\\t\\t\\t\\t// increase index\\n\\n\\t\\t\\t\\tindex ++;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// generate indices\\n\\n\\t\\t\\tfor ( x = 0; x < radialSegments; x ++ ) {\\n\\n\\t\\t\\t\\tvar c = centerIndexStart + x;\\n\\t\\t\\t\\tvar i = centerIndexEnd + x;\\n\\n\\t\\t\\t\\tif ( top === true ) {\\n\\n\\t\\t\\t\\t\\t// face top\\n\\n\\t\\t\\t\\t\\tindices.push( i, i + 1, c );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// face bottom\\n\\n\\t\\t\\t\\t\\tindices.push( i + 1, i, c );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgroupCount += 3;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// add a group to the geometry. this will ensure multi material support\\n\\n\\t\\t\\tscope.addGroup( groupStart, groupCount, top === true ? 1 : 2 );\\n\\n\\t\\t\\t// calculate new start value for groups\\n\\n\\t\\t\\tgroupStart += groupCount;\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tCylinderBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tCylinderBufferGeometry.prototype.constructor = CylinderBufferGeometry;\\n\\n\\t/**\\n\\t * @author abelnation / http://github.com/abelnation\\n\\t */\\n\\n\\t// ConeGeometry\\n\\n\\tfunction ConeGeometry( radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) {\\n\\n\\t\\tCylinderGeometry.call( this, 0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength );\\n\\n\\t\\tthis.type = 'ConeGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\theight: height,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\theightSegments: heightSegments,\\n\\t\\t\\topenEnded: openEnded,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t}\\n\\n\\tConeGeometry.prototype = Object.create( CylinderGeometry.prototype );\\n\\tConeGeometry.prototype.constructor = ConeGeometry;\\n\\n\\t// ConeBufferGeometry\\n\\n\\tfunction ConeBufferGeometry( radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) {\\n\\n\\t\\tCylinderBufferGeometry.call( this, 0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength );\\n\\n\\t\\tthis.type = 'ConeBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\theight: height,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\theightSegments: heightSegments,\\n\\t\\t\\topenEnded: openEnded,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t}\\n\\n\\tConeBufferGeometry.prototype = Object.create( CylinderBufferGeometry.prototype );\\n\\tConeBufferGeometry.prototype.constructor = ConeBufferGeometry;\\n\\n\\t/**\\n\\t * @author benaadams / https://twitter.com/ben_a_adams\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t * @author hughes\\n\\t */\\n\\n\\t// CircleGeometry\\n\\n\\tfunction CircleGeometry( radius, segments, thetaStart, thetaLength ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'CircleGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tsegments: segments,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new CircleBufferGeometry( radius, segments, thetaStart, thetaLength ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tCircleGeometry.prototype = Object.create( Geometry.prototype );\\n\\tCircleGeometry.prototype.constructor = CircleGeometry;\\n\\n\\t// CircleBufferGeometry\\n\\n\\tfunction CircleBufferGeometry( radius, segments, thetaStart, thetaLength ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'CircleBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tsegments: segments,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t\\tradius = radius || 1;\\n\\t\\tsegments = segments !== undefined ? Math.max( 3, segments ) : 8;\\n\\n\\t\\tthetaStart = thetaStart !== undefined ? thetaStart : 0;\\n\\t\\tthetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2;\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar i, s;\\n\\t\\tvar vertex = new Vector3();\\n\\t\\tvar uv = new Vector2();\\n\\n\\t\\t// center point\\n\\n\\t\\tvertices.push( 0, 0, 0 );\\n\\t\\tnormals.push( 0, 0, 1 );\\n\\t\\tuvs.push( 0.5, 0.5 );\\n\\n\\t\\tfor ( s = 0, i = 3; s <= segments; s ++, i += 3 ) {\\n\\n\\t\\t\\tvar segment = thetaStart + s / segments * thetaLength;\\n\\n\\t\\t\\t// vertex\\n\\n\\t\\t\\tvertex.x = radius * Math.cos( segment );\\n\\t\\t\\tvertex.y = radius * Math.sin( segment );\\n\\n\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t// normal\\n\\n\\t\\t\\tnormals.push( 0, 0, 1 );\\n\\n\\t\\t\\t// uvs\\n\\n\\t\\t\\tuv.x = ( vertices[ i ] / radius + 1 ) / 2;\\n\\t\\t\\tuv.y = ( vertices[ i + 1 ] / radius + 1 ) / 2;\\n\\n\\t\\t\\tuvs.push( uv.x, uv.y );\\n\\n\\t\\t}\\n\\n\\t\\t// indices\\n\\n\\t\\tfor ( i = 1; i <= segments; i ++ ) {\\n\\n\\t\\t\\tindices.push( i, i + 1, 0 );\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t}\\n\\n\\tCircleBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tCircleBufferGeometry.prototype.constructor = CircleBufferGeometry;\\n\\n\\n\\n\\tvar Geometries = Object.freeze({\\n\\t\\tWireframeGeometry: WireframeGeometry,\\n\\t\\tParametricGeometry: ParametricGeometry,\\n\\t\\tParametricBufferGeometry: ParametricBufferGeometry,\\n\\t\\tTetrahedronGeometry: TetrahedronGeometry,\\n\\t\\tTetrahedronBufferGeometry: TetrahedronBufferGeometry,\\n\\t\\tOctahedronGeometry: OctahedronGeometry,\\n\\t\\tOctahedronBufferGeometry: OctahedronBufferGeometry,\\n\\t\\tIcosahedronGeometry: IcosahedronGeometry,\\n\\t\\tIcosahedronBufferGeometry: IcosahedronBufferGeometry,\\n\\t\\tDodecahedronGeometry: DodecahedronGeometry,\\n\\t\\tDodecahedronBufferGeometry: DodecahedronBufferGeometry,\\n\\t\\tPolyhedronGeometry: PolyhedronGeometry,\\n\\t\\tPolyhedronBufferGeometry: PolyhedronBufferGeometry,\\n\\t\\tTubeGeometry: TubeGeometry,\\n\\t\\tTubeBufferGeometry: TubeBufferGeometry,\\n\\t\\tTorusKnotGeometry: TorusKnotGeometry,\\n\\t\\tTorusKnotBufferGeometry: TorusKnotBufferGeometry,\\n\\t\\tTorusGeometry: TorusGeometry,\\n\\t\\tTorusBufferGeometry: TorusBufferGeometry,\\n\\t\\tTextGeometry: TextGeometry,\\n\\t\\tTextBufferGeometry: TextBufferGeometry,\\n\\t\\tSphereGeometry: SphereGeometry,\\n\\t\\tSphereBufferGeometry: SphereBufferGeometry,\\n\\t\\tRingGeometry: RingGeometry,\\n\\t\\tRingBufferGeometry: RingBufferGeometry,\\n\\t\\tPlaneGeometry: PlaneGeometry,\\n\\t\\tPlaneBufferGeometry: PlaneBufferGeometry,\\n\\t\\tLatheGeometry: LatheGeometry,\\n\\t\\tLatheBufferGeometry: LatheBufferGeometry,\\n\\t\\tShapeGeometry: ShapeGeometry,\\n\\t\\tShapeBufferGeometry: ShapeBufferGeometry,\\n\\t\\tExtrudeGeometry: ExtrudeGeometry,\\n\\t\\tExtrudeBufferGeometry: ExtrudeBufferGeometry,\\n\\t\\tEdgesGeometry: EdgesGeometry,\\n\\t\\tConeGeometry: ConeGeometry,\\n\\t\\tConeBufferGeometry: ConeBufferGeometry,\\n\\t\\tCylinderGeometry: CylinderGeometry,\\n\\t\\tCylinderBufferGeometry: CylinderBufferGeometry,\\n\\t\\tCircleGeometry: CircleGeometry,\\n\\t\\tCircleBufferGeometry: CircleBufferGeometry,\\n\\t\\tBoxGeometry: BoxGeometry,\\n\\t\\tBoxBufferGeometry: BoxBufferGeometry\\n\\t});\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t *\\n\\t * parameters = {\\n\\t * color: ,\\n\\t * opacity: \\n\\t * }\\n\\t */\\n\\n\\tfunction ShadowMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'ShadowMaterial';\\n\\n\\t\\tthis.color = new Color( 0x000000 );\\n\\t\\tthis.opacity = 1.0;\\n\\n\\t\\tthis.lights = true;\\n\\t\\tthis.transparent = true;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tShadowMaterial.prototype = Object.create( Material.prototype );\\n\\tShadowMaterial.prototype.constructor = ShadowMaterial;\\n\\n\\tShadowMaterial.prototype.isShadowMaterial = true;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction RawShaderMaterial( parameters ) {\\n\\n\\t\\tShaderMaterial.call( this, parameters );\\n\\n\\t\\tthis.type = 'RawShaderMaterial';\\n\\n\\t}\\n\\n\\tRawShaderMaterial.prototype = Object.create( ShaderMaterial.prototype );\\n\\tRawShaderMaterial.prototype.constructor = RawShaderMaterial;\\n\\n\\tRawShaderMaterial.prototype.isRawShaderMaterial = true;\\n\\n\\t/**\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t *\\n\\t * parameters = {\\n\\t * color: ,\\n\\t * roughness: ,\\n\\t * metalness: ,\\n\\t * opacity: ,\\n\\t *\\n\\t * map: new THREE.Texture( ),\\n\\t *\\n\\t * lightMap: new THREE.Texture( ),\\n\\t * lightMapIntensity: \\n\\t *\\n\\t * aoMap: new THREE.Texture( ),\\n\\t * aoMapIntensity: \\n\\t *\\n\\t * emissive: ,\\n\\t * emissiveIntensity: \\n\\t * emissiveMap: new THREE.Texture( ),\\n\\t *\\n\\t * bumpMap: new THREE.Texture( ),\\n\\t * bumpScale: ,\\n\\t *\\n\\t * normalMap: new THREE.Texture( ),\\n\\t * normalScale: ,\\n\\t *\\n\\t * displacementMap: new THREE.Texture( ),\\n\\t * displacementScale: ,\\n\\t * displacementBias: ,\\n\\t *\\n\\t * roughnessMap: new THREE.Texture( ),\\n\\t *\\n\\t * metalnessMap: new THREE.Texture( ),\\n\\t *\\n\\t * alphaMap: new THREE.Texture( ),\\n\\t *\\n\\t * envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ),\\n\\t * envMapIntensity: \\n\\t *\\n\\t * refractionRatio: ,\\n\\t *\\n\\t * wireframe: ,\\n\\t * wireframeLinewidth: ,\\n\\t *\\n\\t * skinning: ,\\n\\t * morphTargets: ,\\n\\t * morphNormals: \\n\\t * }\\n\\t */\\n\\n\\tfunction MeshStandardMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.defines = { 'STANDARD': '' };\\n\\n\\t\\tthis.type = 'MeshStandardMaterial';\\n\\n\\t\\tthis.color = new Color( 0xffffff ); // diffuse\\n\\t\\tthis.roughness = 0.5;\\n\\t\\tthis.metalness = 0.5;\\n\\n\\t\\tthis.map = null;\\n\\n\\t\\tthis.lightMap = null;\\n\\t\\tthis.lightMapIntensity = 1.0;\\n\\n\\t\\tthis.aoMap = null;\\n\\t\\tthis.aoMapIntensity = 1.0;\\n\\n\\t\\tthis.emissive = new Color( 0x000000 );\\n\\t\\tthis.emissiveIntensity = 1.0;\\n\\t\\tthis.emissiveMap = null;\\n\\n\\t\\tthis.bumpMap = null;\\n\\t\\tthis.bumpScale = 1;\\n\\n\\t\\tthis.normalMap = null;\\n\\t\\tthis.normalScale = new Vector2( 1, 1 );\\n\\n\\t\\tthis.displacementMap = null;\\n\\t\\tthis.displacementScale = 1;\\n\\t\\tthis.displacementBias = 0;\\n\\n\\t\\tthis.roughnessMap = null;\\n\\n\\t\\tthis.metalnessMap = null;\\n\\n\\t\\tthis.alphaMap = null;\\n\\n\\t\\tthis.envMap = null;\\n\\t\\tthis.envMapIntensity = 1.0;\\n\\n\\t\\tthis.refractionRatio = 0.98;\\n\\n\\t\\tthis.wireframe = false;\\n\\t\\tthis.wireframeLinewidth = 1;\\n\\t\\tthis.wireframeLinecap = 'round';\\n\\t\\tthis.wireframeLinejoin = 'round';\\n\\n\\t\\tthis.skinning = false;\\n\\t\\tthis.morphTargets = false;\\n\\t\\tthis.morphNormals = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshStandardMaterial.prototype = Object.create( Material.prototype );\\n\\tMeshStandardMaterial.prototype.constructor = MeshStandardMaterial;\\n\\n\\tMeshStandardMaterial.prototype.isMeshStandardMaterial = true;\\n\\n\\tMeshStandardMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.defines = { 'STANDARD': '' };\\n\\n\\t\\tthis.color.copy( source.color );\\n\\t\\tthis.roughness = source.roughness;\\n\\t\\tthis.metalness = source.metalness;\\n\\n\\t\\tthis.map = source.map;\\n\\n\\t\\tthis.lightMap = source.lightMap;\\n\\t\\tthis.lightMapIntensity = source.lightMapIntensity;\\n\\n\\t\\tthis.aoMap = source.aoMap;\\n\\t\\tthis.aoMapIntensity = source.aoMapIntensity;\\n\\n\\t\\tthis.emissive.copy( source.emissive );\\n\\t\\tthis.emissiveMap = source.emissiveMap;\\n\\t\\tthis.emissiveIntensity = source.emissiveIntensity;\\n\\n\\t\\tthis.bumpMap = source.bumpMap;\\n\\t\\tthis.bumpScale = source.bumpScale;\\n\\n\\t\\tthis.normalMap = source.normalMap;\\n\\t\\tthis.normalScale.copy( source.normalScale );\\n\\n\\t\\tthis.displacementMap = source.displacementMap;\\n\\t\\tthis.displacementScale = source.displacementScale;\\n\\t\\tthis.displacementBias = source.displacementBias;\\n\\n\\t\\tthis.roughnessMap = source.roughnessMap;\\n\\n\\t\\tthis.metalnessMap = source.metalnessMap;\\n\\n\\t\\tthis.alphaMap = source.alphaMap;\\n\\n\\t\\tthis.envMap = source.envMap;\\n\\t\\tthis.envMapIntensity = source.envMapIntensity;\\n\\n\\t\\tthis.refractionRatio = source.refractionRatio;\\n\\n\\t\\tthis.wireframe = source.wireframe;\\n\\t\\tthis.wireframeLinewidth = source.wireframeLinewidth;\\n\\t\\tthis.wireframeLinecap = source.wireframeLinecap;\\n\\t\\tthis.wireframeLinejoin = source.wireframeLinejoin;\\n\\n\\t\\tthis.skinning = source.skinning;\\n\\t\\tthis.morphTargets = source.morphTargets;\\n\\t\\tthis.morphNormals = source.morphNormals;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t *\\n\\t * parameters = {\\n\\t * reflectivity: \\n\\t * }\\n\\t */\\n\\n\\tfunction MeshPhysicalMaterial( parameters ) {\\n\\n\\t\\tMeshStandardMaterial.call( this );\\n\\n\\t\\tthis.defines = { 'PHYSICAL': '' };\\n\\n\\t\\tthis.type = 'MeshPhysicalMaterial';\\n\\n\\t\\tthis.reflectivity = 0.5; // maps to F0 = 0.04\\n\\n\\t\\tthis.clearCoat = 0.0;\\n\\t\\tthis.clearCoatRoughness = 0.0;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshPhysicalMaterial.prototype = Object.create( MeshStandardMaterial.prototype );\\n\\tMeshPhysicalMaterial.prototype.constructor = MeshPhysicalMaterial;\\n\\n\\tMeshPhysicalMaterial.prototype.isMeshPhysicalMaterial = true;\\n\\n\\tMeshPhysicalMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMeshStandardMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.defines = { 'PHYSICAL': '' };\\n\\n\\t\\tthis.reflectivity = source.reflectivity;\\n\\n\\t\\tthis.clearCoat = source.clearCoat;\\n\\t\\tthis.clearCoatRoughness = source.clearCoatRoughness;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * parameters = {\\n\\t * color: ,\\n\\t * specular: ,\\n\\t * shininess: ,\\n\\t * opacity: ,\\n\\t *\\n\\t * map: new THREE.Texture( ),\\n\\t *\\n\\t * lightMap: new THREE.Texture( ),\\n\\t * lightMapIntensity: \\n\\t *\\n\\t * aoMap: new THREE.Texture( ),\\n\\t * aoMapIntensity: \\n\\t *\\n\\t * emissive: ,\\n\\t * emissiveIntensity: \\n\\t * emissiveMap: new THREE.Texture( ),\\n\\t *\\n\\t * bumpMap: new THREE.Texture( ),\\n\\t * bumpScale: ,\\n\\t *\\n\\t * normalMap: new THREE.Texture( ),\\n\\t * normalScale: ,\\n\\t *\\n\\t * displacementMap: new THREE.Texture( ),\\n\\t * displacementScale: ,\\n\\t * displacementBias: ,\\n\\t *\\n\\t * specularMap: new THREE.Texture( ),\\n\\t *\\n\\t * alphaMap: new THREE.Texture( ),\\n\\t *\\n\\t * envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ),\\n\\t * combine: THREE.Multiply,\\n\\t * reflectivity: ,\\n\\t * refractionRatio: ,\\n\\t *\\n\\t * wireframe: ,\\n\\t * wireframeLinewidth: ,\\n\\t *\\n\\t * skinning: ,\\n\\t * morphTargets: ,\\n\\t * morphNormals: \\n\\t * }\\n\\t */\\n\\n\\tfunction MeshPhongMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'MeshPhongMaterial';\\n\\n\\t\\tthis.color = new Color( 0xffffff ); // diffuse\\n\\t\\tthis.specular = new Color( 0x111111 );\\n\\t\\tthis.shininess = 30;\\n\\n\\t\\tthis.map = null;\\n\\n\\t\\tthis.lightMap = null;\\n\\t\\tthis.lightMapIntensity = 1.0;\\n\\n\\t\\tthis.aoMap = null;\\n\\t\\tthis.aoMapIntensity = 1.0;\\n\\n\\t\\tthis.emissive = new Color( 0x000000 );\\n\\t\\tthis.emissiveIntensity = 1.0;\\n\\t\\tthis.emissiveMap = null;\\n\\n\\t\\tthis.bumpMap = null;\\n\\t\\tthis.bumpScale = 1;\\n\\n\\t\\tthis.normalMap = null;\\n\\t\\tthis.normalScale = new Vector2( 1, 1 );\\n\\n\\t\\tthis.displacementMap = null;\\n\\t\\tthis.displacementScale = 1;\\n\\t\\tthis.displacementBias = 0;\\n\\n\\t\\tthis.specularMap = null;\\n\\n\\t\\tthis.alphaMap = null;\\n\\n\\t\\tthis.envMap = null;\\n\\t\\tthis.combine = MultiplyOperation;\\n\\t\\tthis.reflectivity = 1;\\n\\t\\tthis.refractionRatio = 0.98;\\n\\n\\t\\tthis.wireframe = false;\\n\\t\\tthis.wireframeLinewidth = 1;\\n\\t\\tthis.wireframeLinecap = 'round';\\n\\t\\tthis.wireframeLinejoin = 'round';\\n\\n\\t\\tthis.skinning = false;\\n\\t\\tthis.morphTargets = false;\\n\\t\\tthis.morphNormals = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshPhongMaterial.prototype = Object.create( Material.prototype );\\n\\tMeshPhongMaterial.prototype.constructor = MeshPhongMaterial;\\n\\n\\tMeshPhongMaterial.prototype.isMeshPhongMaterial = true;\\n\\n\\tMeshPhongMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.color.copy( source.color );\\n\\t\\tthis.specular.copy( source.specular );\\n\\t\\tthis.shininess = source.shininess;\\n\\n\\t\\tthis.map = source.map;\\n\\n\\t\\tthis.lightMap = source.lightMap;\\n\\t\\tthis.lightMapIntensity = source.lightMapIntensity;\\n\\n\\t\\tthis.aoMap = source.aoMap;\\n\\t\\tthis.aoMapIntensity = source.aoMapIntensity;\\n\\n\\t\\tthis.emissive.copy( source.emissive );\\n\\t\\tthis.emissiveMap = source.emissiveMap;\\n\\t\\tthis.emissiveIntensity = source.emissiveIntensity;\\n\\n\\t\\tthis.bumpMap = source.bumpMap;\\n\\t\\tthis.bumpScale = source.bumpScale;\\n\\n\\t\\tthis.normalMap = source.normalMap;\\n\\t\\tthis.normalScale.copy( source.normalScale );\\n\\n\\t\\tthis.displacementMap = source.displacementMap;\\n\\t\\tthis.displacementScale = source.displacementScale;\\n\\t\\tthis.displacementBias = source.displacementBias;\\n\\n\\t\\tthis.specularMap = source.specularMap;\\n\\n\\t\\tthis.alphaMap = source.alphaMap;\\n\\n\\t\\tthis.envMap = source.envMap;\\n\\t\\tthis.combine = source.combine;\\n\\t\\tthis.reflectivity = source.reflectivity;\\n\\t\\tthis.refractionRatio = source.refractionRatio;\\n\\n\\t\\tthis.wireframe = source.wireframe;\\n\\t\\tthis.wireframeLinewidth = source.wireframeLinewidth;\\n\\t\\tthis.wireframeLinecap = source.wireframeLinecap;\\n\\t\\tthis.wireframeLinejoin = source.wireframeLinejoin;\\n\\n\\t\\tthis.skinning = source.skinning;\\n\\t\\tthis.morphTargets = source.morphTargets;\\n\\t\\tthis.morphNormals = source.morphNormals;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author takahirox / http://github.com/takahirox\\n\\t *\\n\\t * parameters = {\\n\\t * gradientMap: new THREE.Texture( )\\n\\t * }\\n\\t */\\n\\n\\tfunction MeshToonMaterial( parameters ) {\\n\\n\\t\\tMeshPhongMaterial.call( this );\\n\\n\\t\\tthis.defines = { 'TOON': '' };\\n\\n\\t\\tthis.type = 'MeshToonMaterial';\\n\\n\\t\\tthis.gradientMap = null;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshToonMaterial.prototype = Object.create( MeshPhongMaterial.prototype );\\n\\tMeshToonMaterial.prototype.constructor = MeshToonMaterial;\\n\\n\\tMeshToonMaterial.prototype.isMeshToonMaterial = true;\\n\\n\\tMeshToonMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMeshPhongMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.gradientMap = source.gradientMap;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t *\\n\\t * parameters = {\\n\\t * opacity: ,\\n\\t *\\n\\t * bumpMap: new THREE.Texture( ),\\n\\t * bumpScale: ,\\n\\t *\\n\\t * normalMap: new THREE.Texture( ),\\n\\t * normalScale: ,\\n\\t *\\n\\t * displacementMap: new THREE.Texture( ),\\n\\t * displacementScale: ,\\n\\t * displacementBias: ,\\n\\t *\\n\\t * wireframe: ,\\n\\t * wireframeLinewidth: \\n\\t *\\n\\t * skinning: ,\\n\\t * morphTargets: ,\\n\\t * morphNormals: \\n\\t * }\\n\\t */\\n\\n\\tfunction MeshNormalMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'MeshNormalMaterial';\\n\\n\\t\\tthis.bumpMap = null;\\n\\t\\tthis.bumpScale = 1;\\n\\n\\t\\tthis.normalMap = null;\\n\\t\\tthis.normalScale = new Vector2( 1, 1 );\\n\\n\\t\\tthis.displacementMap = null;\\n\\t\\tthis.displacementScale = 1;\\n\\t\\tthis.displacementBias = 0;\\n\\n\\t\\tthis.wireframe = false;\\n\\t\\tthis.wireframeLinewidth = 1;\\n\\n\\t\\tthis.fog = false;\\n\\t\\tthis.lights = false;\\n\\n\\t\\tthis.skinning = false;\\n\\t\\tthis.morphTargets = false;\\n\\t\\tthis.morphNormals = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshNormalMaterial.prototype = Object.create( Material.prototype );\\n\\tMeshNormalMaterial.prototype.constructor = MeshNormalMaterial;\\n\\n\\tMeshNormalMaterial.prototype.isMeshNormalMaterial = true;\\n\\n\\tMeshNormalMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.bumpMap = source.bumpMap;\\n\\t\\tthis.bumpScale = source.bumpScale;\\n\\n\\t\\tthis.normalMap = source.normalMap;\\n\\t\\tthis.normalScale.copy( source.normalScale );\\n\\n\\t\\tthis.displacementMap = source.displacementMap;\\n\\t\\tthis.displacementScale = source.displacementScale;\\n\\t\\tthis.displacementBias = source.displacementBias;\\n\\n\\t\\tthis.wireframe = source.wireframe;\\n\\t\\tthis.wireframeLinewidth = source.wireframeLinewidth;\\n\\n\\t\\tthis.skinning = source.skinning;\\n\\t\\tthis.morphTargets = source.morphTargets;\\n\\t\\tthis.morphNormals = source.morphNormals;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * parameters = {\\n\\t * color: ,\\n\\t * opacity: ,\\n\\t *\\n\\t * map: new THREE.Texture( ),\\n\\t *\\n\\t * lightMap: new THREE.Texture( ),\\n\\t * lightMapIntensity: \\n\\t *\\n\\t * aoMap: new THREE.Texture( ),\\n\\t * aoMapIntensity: \\n\\t *\\n\\t * emissive: ,\\n\\t * emissiveIntensity: \\n\\t * emissiveMap: new THREE.Texture( ),\\n\\t *\\n\\t * specularMap: new THREE.Texture( ),\\n\\t *\\n\\t * alphaMap: new THREE.Texture( ),\\n\\t *\\n\\t * envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ),\\n\\t * combine: THREE.Multiply,\\n\\t * reflectivity: ,\\n\\t * refractionRatio: ,\\n\\t *\\n\\t * wireframe: ,\\n\\t * wireframeLinewidth: ,\\n\\t *\\n\\t * skinning: ,\\n\\t * morphTargets: ,\\n\\t * morphNormals: \\n\\t * }\\n\\t */\\n\\n\\tfunction MeshLambertMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'MeshLambertMaterial';\\n\\n\\t\\tthis.color = new Color( 0xffffff ); // diffuse\\n\\n\\t\\tthis.map = null;\\n\\n\\t\\tthis.lightMap = null;\\n\\t\\tthis.lightMapIntensity = 1.0;\\n\\n\\t\\tthis.aoMap = null;\\n\\t\\tthis.aoMapIntensity = 1.0;\\n\\n\\t\\tthis.emissive = new Color( 0x000000 );\\n\\t\\tthis.emissiveIntensity = 1.0;\\n\\t\\tthis.emissiveMap = null;\\n\\n\\t\\tthis.specularMap = null;\\n\\n\\t\\tthis.alphaMap = null;\\n\\n\\t\\tthis.envMap = null;\\n\\t\\tthis.combine = MultiplyOperation;\\n\\t\\tthis.reflectivity = 1;\\n\\t\\tthis.refractionRatio = 0.98;\\n\\n\\t\\tthis.wireframe = false;\\n\\t\\tthis.wireframeLinewidth = 1;\\n\\t\\tthis.wireframeLinecap = 'round';\\n\\t\\tthis.wireframeLinejoin = 'round';\\n\\n\\t\\tthis.skinning = false;\\n\\t\\tthis.morphTargets = false;\\n\\t\\tthis.morphNormals = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshLambertMaterial.prototype = Object.create( Material.prototype );\\n\\tMeshLambertMaterial.prototype.constructor = MeshLambertMaterial;\\n\\n\\tMeshLambertMaterial.prototype.isMeshLambertMaterial = true;\\n\\n\\tMeshLambertMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.color.copy( source.color );\\n\\n\\t\\tthis.map = source.map;\\n\\n\\t\\tthis.lightMap = source.lightMap;\\n\\t\\tthis.lightMapIntensity = source.lightMapIntensity;\\n\\n\\t\\tthis.aoMap = source.aoMap;\\n\\t\\tthis.aoMapIntensity = source.aoMapIntensity;\\n\\n\\t\\tthis.emissive.copy( source.emissive );\\n\\t\\tthis.emissiveMap = source.emissiveMap;\\n\\t\\tthis.emissiveIntensity = source.emissiveIntensity;\\n\\n\\t\\tthis.specularMap = source.specularMap;\\n\\n\\t\\tthis.alphaMap = source.alphaMap;\\n\\n\\t\\tthis.envMap = source.envMap;\\n\\t\\tthis.combine = source.combine;\\n\\t\\tthis.reflectivity = source.reflectivity;\\n\\t\\tthis.refractionRatio = source.refractionRatio;\\n\\n\\t\\tthis.wireframe = source.wireframe;\\n\\t\\tthis.wireframeLinewidth = source.wireframeLinewidth;\\n\\t\\tthis.wireframeLinecap = source.wireframeLinecap;\\n\\t\\tthis.wireframeLinejoin = source.wireframeLinejoin;\\n\\n\\t\\tthis.skinning = source.skinning;\\n\\t\\tthis.morphTargets = source.morphTargets;\\n\\t\\tthis.morphNormals = source.morphNormals;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * parameters = {\\n\\t * color: ,\\n\\t * opacity: ,\\n\\t *\\n\\t * linewidth: ,\\n\\t *\\n\\t * scale: ,\\n\\t * dashSize: ,\\n\\t * gapSize: \\n\\t * }\\n\\t */\\n\\n\\tfunction LineDashedMaterial( parameters ) {\\n\\n\\t\\tLineBasicMaterial.call( this );\\n\\n\\t\\tthis.type = 'LineDashedMaterial';\\n\\n\\t\\tthis.scale = 1;\\n\\t\\tthis.dashSize = 3;\\n\\t\\tthis.gapSize = 1;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tLineDashedMaterial.prototype = Object.create( LineBasicMaterial.prototype );\\n\\tLineDashedMaterial.prototype.constructor = LineDashedMaterial;\\n\\n\\tLineDashedMaterial.prototype.isLineDashedMaterial = true;\\n\\n\\tLineDashedMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tLineBasicMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.scale = source.scale;\\n\\t\\tthis.dashSize = source.dashSize;\\n\\t\\tthis.gapSize = source.gapSize;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\n\\n\\tvar Materials = Object.freeze({\\n\\t\\tShadowMaterial: ShadowMaterial,\\n\\t\\tSpriteMaterial: SpriteMaterial,\\n\\t\\tRawShaderMaterial: RawShaderMaterial,\\n\\t\\tShaderMaterial: ShaderMaterial,\\n\\t\\tPointsMaterial: PointsMaterial,\\n\\t\\tMeshPhysicalMaterial: MeshPhysicalMaterial,\\n\\t\\tMeshStandardMaterial: MeshStandardMaterial,\\n\\t\\tMeshPhongMaterial: MeshPhongMaterial,\\n\\t\\tMeshToonMaterial: MeshToonMaterial,\\n\\t\\tMeshNormalMaterial: MeshNormalMaterial,\\n\\t\\tMeshLambertMaterial: MeshLambertMaterial,\\n\\t\\tMeshDepthMaterial: MeshDepthMaterial,\\n\\t\\tMeshDistanceMaterial: MeshDistanceMaterial,\\n\\t\\tMeshBasicMaterial: MeshBasicMaterial,\\n\\t\\tLineDashedMaterial: LineDashedMaterial,\\n\\t\\tLineBasicMaterial: LineBasicMaterial,\\n\\t\\tMaterial: Material\\n\\t});\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tvar Cache = {\\n\\n\\t\\tenabled: false,\\n\\n\\t\\tfiles: {},\\n\\n\\t\\tadd: function ( key, file ) {\\n\\n\\t\\t\\tif ( this.enabled === false ) return;\\n\\n\\t\\t\\t// console.log( 'THREE.Cache', 'Adding key:', key );\\n\\n\\t\\t\\tthis.files[ key ] = file;\\n\\n\\t\\t},\\n\\n\\t\\tget: function ( key ) {\\n\\n\\t\\t\\tif ( this.enabled === false ) return;\\n\\n\\t\\t\\t// console.log( 'THREE.Cache', 'Checking key:', key );\\n\\n\\t\\t\\treturn this.files[ key ];\\n\\n\\t\\t},\\n\\n\\t\\tremove: function ( key ) {\\n\\n\\t\\t\\tdelete this.files[ key ];\\n\\n\\t\\t},\\n\\n\\t\\tclear: function () {\\n\\n\\t\\t\\tthis.files = {};\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction LoadingManager( onLoad, onProgress, onError ) {\\n\\n\\t\\tvar scope = this;\\n\\n\\t\\tvar isLoading = false;\\n\\t\\tvar itemsLoaded = 0;\\n\\t\\tvar itemsTotal = 0;\\n\\t\\tvar urlModifier = undefined;\\n\\n\\t\\tthis.onStart = undefined;\\n\\t\\tthis.onLoad = onLoad;\\n\\t\\tthis.onProgress = onProgress;\\n\\t\\tthis.onError = onError;\\n\\n\\t\\tthis.itemStart = function ( url ) {\\n\\n\\t\\t\\titemsTotal ++;\\n\\n\\t\\t\\tif ( isLoading === false ) {\\n\\n\\t\\t\\t\\tif ( scope.onStart !== undefined ) {\\n\\n\\t\\t\\t\\t\\tscope.onStart( url, itemsLoaded, itemsTotal );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tisLoading = true;\\n\\n\\t\\t};\\n\\n\\t\\tthis.itemEnd = function ( url ) {\\n\\n\\t\\t\\titemsLoaded ++;\\n\\n\\t\\t\\tif ( scope.onProgress !== undefined ) {\\n\\n\\t\\t\\t\\tscope.onProgress( url, itemsLoaded, itemsTotal );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( itemsLoaded === itemsTotal ) {\\n\\n\\t\\t\\t\\tisLoading = false;\\n\\n\\t\\t\\t\\tif ( scope.onLoad !== undefined ) {\\n\\n\\t\\t\\t\\t\\tscope.onLoad();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t\\tthis.itemError = function ( url ) {\\n\\n\\t\\t\\tif ( scope.onError !== undefined ) {\\n\\n\\t\\t\\t\\tscope.onError( url );\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t\\tthis.resolveURL = function ( url ) {\\n\\n\\t\\t\\tif ( urlModifier ) {\\n\\n\\t\\t\\t\\treturn urlModifier( url );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn url;\\n\\n\\t\\t};\\n\\n\\t\\tthis.setURLModifier = function ( transform ) {\\n\\n\\t\\t\\turlModifier = transform;\\n\\t\\t\\treturn this;\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\tvar DefaultLoadingManager = new LoadingManager();\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tvar loading = {};\\n\\n\\tfunction FileLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t}\\n\\n\\tObject.assign( FileLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tif ( url === undefined ) url = '';\\n\\n\\t\\t\\tif ( this.path !== undefined ) url = this.path + url;\\n\\n\\t\\t\\turl = this.manager.resolveURL( url );\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar cached = Cache.get( url );\\n\\n\\t\\t\\tif ( cached !== undefined ) {\\n\\n\\t\\t\\t\\tscope.manager.itemStart( url );\\n\\n\\t\\t\\t\\tsetTimeout( function () {\\n\\n\\t\\t\\t\\t\\tif ( onLoad ) onLoad( cached );\\n\\n\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t\\t}, 0 );\\n\\n\\t\\t\\t\\treturn cached;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Check if request is duplicate\\n\\n\\t\\t\\tif ( loading[ url ] !== undefined ) {\\n\\n\\t\\t\\t\\tloading[ url ].push( {\\n\\n\\t\\t\\t\\t\\tonLoad: onLoad,\\n\\t\\t\\t\\t\\tonProgress: onProgress,\\n\\t\\t\\t\\t\\tonError: onError\\n\\n\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Check for data: URI\\n\\t\\t\\tvar dataUriRegex = /^data:(.*?)(;base64)?,(.*)$/;\\n\\t\\t\\tvar dataUriRegexResult = url.match( dataUriRegex );\\n\\n\\t\\t\\t// Safari can not handle Data URIs through XMLHttpRequest so process manually\\n\\t\\t\\tif ( dataUriRegexResult ) {\\n\\n\\t\\t\\t\\tvar mimeType = dataUriRegexResult[ 1 ];\\n\\t\\t\\t\\tvar isBase64 = !! dataUriRegexResult[ 2 ];\\n\\t\\t\\t\\tvar data = dataUriRegexResult[ 3 ];\\n\\n\\t\\t\\t\\tdata = window.decodeURIComponent( data );\\n\\n\\t\\t\\t\\tif ( isBase64 ) data = window.atob( data );\\n\\n\\t\\t\\t\\ttry {\\n\\n\\t\\t\\t\\t\\tvar response;\\n\\t\\t\\t\\t\\tvar responseType = ( this.responseType || '' ).toLowerCase();\\n\\n\\t\\t\\t\\t\\tswitch ( responseType ) {\\n\\n\\t\\t\\t\\t\\t\\tcase 'arraybuffer':\\n\\t\\t\\t\\t\\t\\tcase 'blob':\\n\\n\\t\\t\\t\\t\\t\\t\\tvar view = new Uint8Array( data.length );\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var i = 0; i < data.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tview[ i ] = data.charCodeAt( i );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( responseType === 'blob' ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tresponse = new Blob( [ view.buffer ], { type: mimeType } );\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tresponse = view.buffer;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'document':\\n\\n\\t\\t\\t\\t\\t\\t\\tvar parser = new DOMParser();\\n\\t\\t\\t\\t\\t\\t\\tresponse = parser.parseFromString( data, mimeType );\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'json':\\n\\n\\t\\t\\t\\t\\t\\t\\tresponse = JSON.parse( data );\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tdefault: // 'text' or other\\n\\n\\t\\t\\t\\t\\t\\t\\tresponse = data;\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t// Wait for next browser tick like standard XMLHttpRequest event dispatching does\\n\\t\\t\\t\\t\\twindow.setTimeout( function () {\\n\\n\\t\\t\\t\\t\\t\\tif ( onLoad ) onLoad( response );\\n\\n\\t\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t\\t\\t}, 0 );\\n\\n\\t\\t\\t\\t} catch ( error ) {\\n\\n\\t\\t\\t\\t\\t// Wait for next browser tick like standard XMLHttpRequest event dispatching does\\n\\t\\t\\t\\t\\twindow.setTimeout( function () {\\n\\n\\t\\t\\t\\t\\t\\tif ( onError ) onError( error );\\n\\n\\t\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\t\\t\\t\\t\\t\\tscope.manager.itemError( url );\\n\\n\\t\\t\\t\\t\\t}, 0 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// Initialise array for duplicate requests\\n\\n\\t\\t\\t\\tloading[ url ] = [];\\n\\n\\t\\t\\t\\tloading[ url ].push( {\\n\\n\\t\\t\\t\\t\\tonLoad: onLoad,\\n\\t\\t\\t\\t\\tonProgress: onProgress,\\n\\t\\t\\t\\t\\tonError: onError\\n\\n\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\tvar request = new XMLHttpRequest();\\n\\n\\t\\t\\t\\trequest.open( 'GET', url, true );\\n\\n\\t\\t\\t\\trequest.addEventListener( 'load', function ( event ) {\\n\\n\\t\\t\\t\\t\\tvar response = this.response;\\n\\n\\t\\t\\t\\t\\tCache.add( url, response );\\n\\n\\t\\t\\t\\t\\tvar callbacks = loading[ url ];\\n\\n\\t\\t\\t\\t\\tdelete loading[ url ];\\n\\n\\t\\t\\t\\t\\tif ( this.status === 200 ) {\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, il = callbacks.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar callback = callbacks[ i ];\\n\\t\\t\\t\\t\\t\\t\\tif ( callback.onLoad ) callback.onLoad( response );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t\\t\\t} else if ( this.status === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\t// Some browsers return HTTP Status 0 when using non-http protocol\\n\\t\\t\\t\\t\\t\\t// e.g. 'file://' or 'data://'. Handle as success.\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.FileLoader: HTTP Status 0 received.' );\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, il = callbacks.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar callback = callbacks[ i ];\\n\\t\\t\\t\\t\\t\\t\\tif ( callback.onLoad ) callback.onLoad( response );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, il = callbacks.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar callback = callbacks[ i ];\\n\\t\\t\\t\\t\\t\\t\\tif ( callback.onError ) callback.onError( event );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\t\\t\\t\\t\\t\\tscope.manager.itemError( url );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}, false );\\n\\n\\t\\t\\t\\trequest.addEventListener( 'progress', function ( event ) {\\n\\n\\t\\t\\t\\t\\tvar callbacks = loading[ url ];\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, il = callbacks.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar callback = callbacks[ i ];\\n\\t\\t\\t\\t\\t\\tif ( callback.onProgress ) callback.onProgress( event );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}, false );\\n\\n\\t\\t\\t\\trequest.addEventListener( 'error', function ( event ) {\\n\\n\\t\\t\\t\\t\\tvar callbacks = loading[ url ];\\n\\n\\t\\t\\t\\t\\tdelete loading[ url ];\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, il = callbacks.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar callback = callbacks[ i ];\\n\\t\\t\\t\\t\\t\\tif ( callback.onError ) callback.onError( event );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\t\\t\\t\\t\\tscope.manager.itemError( url );\\n\\n\\t\\t\\t\\t}, false );\\n\\n\\t\\t\\t\\tif ( this.responseType !== undefined ) request.responseType = this.responseType;\\n\\t\\t\\t\\tif ( this.withCredentials !== undefined ) request.withCredentials = this.withCredentials;\\n\\n\\t\\t\\t\\tif ( request.overrideMimeType ) request.overrideMimeType( this.mimeType !== undefined ? this.mimeType : 'text/plain' );\\n\\n\\t\\t\\t\\tfor ( var header in this.requestHeader ) {\\n\\n\\t\\t\\t\\t\\trequest.setRequestHeader( header, this.requestHeader[ header ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\trequest.send( null );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tscope.manager.itemStart( url );\\n\\n\\t\\t\\treturn request;\\n\\n\\t\\t},\\n\\n\\t\\tsetPath: function ( value ) {\\n\\n\\t\\t\\tthis.path = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetResponseType: function ( value ) {\\n\\n\\t\\t\\tthis.responseType = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetWithCredentials: function ( value ) {\\n\\n\\t\\t\\tthis.withCredentials = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetMimeType: function ( value ) {\\n\\n\\t\\t\\tthis.mimeType = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetRequestHeader: function ( value ) {\\n\\n\\t\\t\\tthis.requestHeader = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t *\\n\\t * Abstract Base class to block based textures loader (dds, pvr, ...)\\n\\t */\\n\\n\\tfunction CompressedTextureLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t\\t// override in sub classes\\n\\t\\tthis._parser = null;\\n\\n\\t}\\n\\n\\tObject.assign( CompressedTextureLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar images = [];\\n\\n\\t\\t\\tvar texture = new CompressedTexture();\\n\\t\\t\\ttexture.image = images;\\n\\n\\t\\t\\tvar loader = new FileLoader( this.manager );\\n\\t\\t\\tloader.setPath( this.path );\\n\\t\\t\\tloader.setResponseType( 'arraybuffer' );\\n\\n\\t\\t\\tfunction loadTexture( i ) {\\n\\n\\t\\t\\t\\tloader.load( url[ i ], function ( buffer ) {\\n\\n\\t\\t\\t\\t\\tvar texDatas = scope._parser( buffer, true );\\n\\n\\t\\t\\t\\t\\timages[ i ] = {\\n\\t\\t\\t\\t\\t\\twidth: texDatas.width,\\n\\t\\t\\t\\t\\t\\theight: texDatas.height,\\n\\t\\t\\t\\t\\t\\tformat: texDatas.format,\\n\\t\\t\\t\\t\\t\\tmipmaps: texDatas.mipmaps\\n\\t\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\t\\tloaded += 1;\\n\\n\\t\\t\\t\\t\\tif ( loaded === 6 ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( texDatas.mipmapCount === 1 )\\n\\t\\t\\t\\t\\t\\t\\ttexture.minFilter = LinearFilter;\\n\\n\\t\\t\\t\\t\\t\\ttexture.format = texDatas.format;\\n\\t\\t\\t\\t\\t\\ttexture.needsUpdate = true;\\n\\n\\t\\t\\t\\t\\t\\tif ( onLoad ) onLoad( texture );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( Array.isArray( url ) ) {\\n\\n\\t\\t\\t\\tvar loaded = 0;\\n\\n\\t\\t\\t\\tfor ( var i = 0, il = url.length; i < il; ++ i ) {\\n\\n\\t\\t\\t\\t\\tloadTexture( i );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// compressed cubemap texture stored in a single DDS file\\n\\n\\t\\t\\t\\tloader.load( url, function ( buffer ) {\\n\\n\\t\\t\\t\\t\\tvar texDatas = scope._parser( buffer, true );\\n\\n\\t\\t\\t\\t\\tif ( texDatas.isCubemap ) {\\n\\n\\t\\t\\t\\t\\t\\tvar faces = texDatas.mipmaps.length / texDatas.mipmapCount;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var f = 0; f < faces; f ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\timages[ f ] = { mipmaps: [] };\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var i = 0; i < texDatas.mipmapCount; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\timages[ f ].mipmaps.push( texDatas.mipmaps[ f * texDatas.mipmapCount + i ] );\\n\\t\\t\\t\\t\\t\\t\\t\\timages[ f ].format = texDatas.format;\\n\\t\\t\\t\\t\\t\\t\\t\\timages[ f ].width = texDatas.width;\\n\\t\\t\\t\\t\\t\\t\\t\\timages[ f ].height = texDatas.height;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\ttexture.image.width = texDatas.width;\\n\\t\\t\\t\\t\\t\\ttexture.image.height = texDatas.height;\\n\\t\\t\\t\\t\\t\\ttexture.mipmaps = texDatas.mipmaps;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( texDatas.mipmapCount === 1 ) {\\n\\n\\t\\t\\t\\t\\t\\ttexture.minFilter = LinearFilter;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\ttexture.format = texDatas.format;\\n\\t\\t\\t\\t\\ttexture.needsUpdate = true;\\n\\n\\t\\t\\t\\t\\tif ( onLoad ) onLoad( texture );\\n\\n\\t\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn texture;\\n\\n\\t\\t},\\n\\n\\t\\tsetPath: function ( value ) {\\n\\n\\t\\t\\tthis.path = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author Nikos M. / https://github.com/foo123/\\n\\t *\\n\\t * Abstract Base class to load generic binary textures formats (rgbe, hdr, ...)\\n\\t */\\n\\n\\tfunction DataTextureLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t\\t// override in sub classes\\n\\t\\tthis._parser = null;\\n\\n\\t}\\n\\n\\tObject.assign( DataTextureLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar texture = new DataTexture();\\n\\n\\t\\t\\tvar loader = new FileLoader( this.manager );\\n\\t\\t\\tloader.setResponseType( 'arraybuffer' );\\n\\n\\t\\t\\tloader.load( url, function ( buffer ) {\\n\\n\\t\\t\\t\\tvar texData = scope._parser( buffer );\\n\\n\\t\\t\\t\\tif ( ! texData ) return;\\n\\n\\t\\t\\t\\tif ( undefined !== texData.image ) {\\n\\n\\t\\t\\t\\t\\ttexture.image = texData.image;\\n\\n\\t\\t\\t\\t} else if ( undefined !== texData.data ) {\\n\\n\\t\\t\\t\\t\\ttexture.image.width = texData.width;\\n\\t\\t\\t\\t\\ttexture.image.height = texData.height;\\n\\t\\t\\t\\t\\ttexture.image.data = texData.data;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\ttexture.wrapS = undefined !== texData.wrapS ? texData.wrapS : ClampToEdgeWrapping;\\n\\t\\t\\t\\ttexture.wrapT = undefined !== texData.wrapT ? texData.wrapT : ClampToEdgeWrapping;\\n\\n\\t\\t\\t\\ttexture.magFilter = undefined !== texData.magFilter ? texData.magFilter : LinearFilter;\\n\\t\\t\\t\\ttexture.minFilter = undefined !== texData.minFilter ? texData.minFilter : LinearMipMapLinearFilter;\\n\\n\\t\\t\\t\\ttexture.anisotropy = undefined !== texData.anisotropy ? texData.anisotropy : 1;\\n\\n\\t\\t\\t\\tif ( undefined !== texData.format ) {\\n\\n\\t\\t\\t\\t\\ttexture.format = texData.format;\\n\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tif ( undefined !== texData.type ) {\\n\\n\\t\\t\\t\\t\\ttexture.type = texData.type;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( undefined !== texData.mipmaps ) {\\n\\n\\t\\t\\t\\t\\ttexture.mipmaps = texData.mipmaps;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( 1 === texData.mipmapCount ) {\\n\\n\\t\\t\\t\\t\\ttexture.minFilter = LinearFilter;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\ttexture.needsUpdate = true;\\n\\n\\t\\t\\t\\tif ( onLoad ) onLoad( texture, texData );\\n\\n\\t\\t\\t}, onProgress, onError );\\n\\n\\n\\t\\t\\treturn texture;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction ImageLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t}\\n\\n\\tObject.assign( ImageLoader.prototype, {\\n\\n\\t\\tcrossOrigin: 'Anonymous',\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tif ( url === undefined ) url = '';\\n\\n\\t\\t\\tif ( this.path !== undefined ) url = this.path + url;\\n\\n\\t\\t\\turl = this.manager.resolveURL( url );\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar cached = Cache.get( url );\\n\\n\\t\\t\\tif ( cached !== undefined ) {\\n\\n\\t\\t\\t\\tscope.manager.itemStart( url );\\n\\n\\t\\t\\t\\tsetTimeout( function () {\\n\\n\\t\\t\\t\\t\\tif ( onLoad ) onLoad( cached );\\n\\n\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t\\t}, 0 );\\n\\n\\t\\t\\t\\treturn cached;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar image = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'img' );\\n\\n\\t\\t\\timage.addEventListener( 'load', function () {\\n\\n\\t\\t\\t\\tCache.add( url, this );\\n\\n\\t\\t\\t\\tif ( onLoad ) onLoad( this );\\n\\n\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t}, false );\\n\\n\\t\\t\\t/*\\n\\t\\t\\timage.addEventListener( 'progress', function ( event ) {\\n\\n\\t\\t\\t\\tif ( onProgress ) onProgress( event );\\n\\n\\t\\t\\t}, false );\\n\\t\\t\\t*/\\n\\n\\t\\t\\timage.addEventListener( 'error', function ( event ) {\\n\\n\\t\\t\\t\\tif ( onError ) onError( event );\\n\\n\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\t\\t\\t\\tscope.manager.itemError( url );\\n\\n\\t\\t\\t}, false );\\n\\n\\t\\t\\tif ( url.substr( 0, 5 ) !== 'data:' ) {\\n\\n\\t\\t\\t\\tif ( this.crossOrigin !== undefined ) image.crossOrigin = this.crossOrigin;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tscope.manager.itemStart( url );\\n\\n\\t\\t\\timage.src = url;\\n\\n\\t\\t\\treturn image;\\n\\n\\t\\t},\\n\\n\\t\\tsetCrossOrigin: function ( value ) {\\n\\n\\t\\t\\tthis.crossOrigin = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetPath: function ( value ) {\\n\\n\\t\\t\\tthis.path = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction CubeTextureLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t}\\n\\n\\tObject.assign( CubeTextureLoader.prototype, {\\n\\n\\t\\tcrossOrigin: 'Anonymous',\\n\\n\\t\\tload: function ( urls, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar texture = new CubeTexture();\\n\\n\\t\\t\\tvar loader = new ImageLoader( this.manager );\\n\\t\\t\\tloader.setCrossOrigin( this.crossOrigin );\\n\\t\\t\\tloader.setPath( this.path );\\n\\n\\t\\t\\tvar loaded = 0;\\n\\n\\t\\t\\tfunction loadTexture( i ) {\\n\\n\\t\\t\\t\\tloader.load( urls[ i ], function ( image ) {\\n\\n\\t\\t\\t\\t\\ttexture.images[ i ] = image;\\n\\n\\t\\t\\t\\t\\tloaded ++;\\n\\n\\t\\t\\t\\t\\tif ( loaded === 6 ) {\\n\\n\\t\\t\\t\\t\\t\\ttexture.needsUpdate = true;\\n\\n\\t\\t\\t\\t\\t\\tif ( onLoad ) onLoad( texture );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}, undefined, onError );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = 0; i < urls.length; ++ i ) {\\n\\n\\t\\t\\t\\tloadTexture( i );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn texture;\\n\\n\\t\\t},\\n\\n\\t\\tsetCrossOrigin: function ( value ) {\\n\\n\\t\\t\\tthis.crossOrigin = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetPath: function ( value ) {\\n\\n\\t\\t\\tthis.path = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction TextureLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t}\\n\\n\\tObject.assign( TextureLoader.prototype, {\\n\\n\\t\\tcrossOrigin: 'Anonymous',\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar texture = new Texture();\\n\\n\\t\\t\\tvar loader = new ImageLoader( this.manager );\\n\\t\\t\\tloader.setCrossOrigin( this.crossOrigin );\\n\\t\\t\\tloader.setPath( this.path );\\n\\n\\t\\t\\tloader.load( url, function ( image ) {\\n\\n\\t\\t\\t\\ttexture.image = image;\\n\\n\\t\\t\\t\\t// JPEGs can't have an alpha channel, so memory can be saved by storing them as RGB.\\n\\t\\t\\t\\tvar isJPEG = url.search( /\\\\.(jpg|jpeg)$/ ) > 0 || url.search( /^data\\\\:image\\\\/jpeg/ ) === 0;\\n\\n\\t\\t\\t\\ttexture.format = isJPEG ? RGBFormat : RGBAFormat;\\n\\t\\t\\t\\ttexture.needsUpdate = true;\\n\\n\\t\\t\\t\\tif ( onLoad !== undefined ) {\\n\\n\\t\\t\\t\\t\\tonLoad( texture );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t\\treturn texture;\\n\\n\\t\\t},\\n\\n\\t\\tsetCrossOrigin: function ( value ) {\\n\\n\\t\\t\\tthis.crossOrigin = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetPath: function ( value ) {\\n\\n\\t\\t\\tthis.path = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t * Extensible curve object\\n\\t *\\n\\t * Some common of curve methods:\\n\\t * .getPoint( t, optionalTarget ), .getTangent( t )\\n\\t * .getPointAt( u, optionalTarget ), .getTangentAt( u )\\n\\t * .getPoints(), .getSpacedPoints()\\n\\t * .getLength()\\n\\t * .updateArcLengths()\\n\\t *\\n\\t * This following curves inherit from THREE.Curve:\\n\\t *\\n\\t * -- 2D curves --\\n\\t * THREE.ArcCurve\\n\\t * THREE.CubicBezierCurve\\n\\t * THREE.EllipseCurve\\n\\t * THREE.LineCurve\\n\\t * THREE.QuadraticBezierCurve\\n\\t * THREE.SplineCurve\\n\\t *\\n\\t * -- 3D curves --\\n\\t * THREE.CatmullRomCurve3\\n\\t * THREE.CubicBezierCurve3\\n\\t * THREE.LineCurve3\\n\\t * THREE.QuadraticBezierCurve3\\n\\t *\\n\\t * A series of curves can be represented as a THREE.CurvePath.\\n\\t *\\n\\t **/\\n\\n\\t/**************************************************************\\n\\t *\\tAbstract Curve base class\\n\\t **************************************************************/\\n\\n\\tfunction Curve() {\\n\\n\\t\\tthis.type = 'Curve';\\n\\n\\t\\tthis.arcLengthDivisions = 200;\\n\\n\\t}\\n\\n\\tObject.assign( Curve.prototype, {\\n\\n\\t\\t// Virtual base class method to overwrite and implement in subclasses\\n\\t\\t//\\t- t [0 .. 1]\\n\\n\\t\\tgetPoint: function ( /* t, optionalTarget */ ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Curve: .getPoint() not implemented.' );\\n\\t\\t\\treturn null;\\n\\n\\t\\t},\\n\\n\\t\\t// Get point at relative position in curve according to arc length\\n\\t\\t// - u [0 .. 1]\\n\\n\\t\\tgetPointAt: function ( u, optionalTarget ) {\\n\\n\\t\\t\\tvar t = this.getUtoTmapping( u );\\n\\t\\t\\treturn this.getPoint( t, optionalTarget );\\n\\n\\t\\t},\\n\\n\\t\\t// Get sequence of points using getPoint( t )\\n\\n\\t\\tgetPoints: function ( divisions ) {\\n\\n\\t\\t\\tif ( divisions === undefined ) divisions = 5;\\n\\n\\t\\t\\tvar points = [];\\n\\n\\t\\t\\tfor ( var d = 0; d <= divisions; d ++ ) {\\n\\n\\t\\t\\t\\tpoints.push( this.getPoint( d / divisions ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn points;\\n\\n\\t\\t},\\n\\n\\t\\t// Get sequence of points using getPointAt( u )\\n\\n\\t\\tgetSpacedPoints: function ( divisions ) {\\n\\n\\t\\t\\tif ( divisions === undefined ) divisions = 5;\\n\\n\\t\\t\\tvar points = [];\\n\\n\\t\\t\\tfor ( var d = 0; d <= divisions; d ++ ) {\\n\\n\\t\\t\\t\\tpoints.push( this.getPointAt( d / divisions ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn points;\\n\\n\\t\\t},\\n\\n\\t\\t// Get total curve arc length\\n\\n\\t\\tgetLength: function () {\\n\\n\\t\\t\\tvar lengths = this.getLengths();\\n\\t\\t\\treturn lengths[ lengths.length - 1 ];\\n\\n\\t\\t},\\n\\n\\t\\t// Get list of cumulative segment lengths\\n\\n\\t\\tgetLengths: function ( divisions ) {\\n\\n\\t\\t\\tif ( divisions === undefined ) divisions = this.arcLengthDivisions;\\n\\n\\t\\t\\tif ( this.cacheArcLengths &&\\n\\t\\t\\t\\t( this.cacheArcLengths.length === divisions + 1 ) &&\\n\\t\\t\\t\\t! this.needsUpdate ) {\\n\\n\\t\\t\\t\\treturn this.cacheArcLengths;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.needsUpdate = false;\\n\\n\\t\\t\\tvar cache = [];\\n\\t\\t\\tvar current, last = this.getPoint( 0 );\\n\\t\\t\\tvar p, sum = 0;\\n\\n\\t\\t\\tcache.push( 0 );\\n\\n\\t\\t\\tfor ( p = 1; p <= divisions; p ++ ) {\\n\\n\\t\\t\\t\\tcurrent = this.getPoint( p / divisions );\\n\\t\\t\\t\\tsum += current.distanceTo( last );\\n\\t\\t\\t\\tcache.push( sum );\\n\\t\\t\\t\\tlast = current;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.cacheArcLengths = cache;\\n\\n\\t\\t\\treturn cache; // { sums: cache, sum: sum }; Sum is in the last element.\\n\\n\\t\\t},\\n\\n\\t\\tupdateArcLengths: function () {\\n\\n\\t\\t\\tthis.needsUpdate = true;\\n\\t\\t\\tthis.getLengths();\\n\\n\\t\\t},\\n\\n\\t\\t// Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equidistant\\n\\n\\t\\tgetUtoTmapping: function ( u, distance ) {\\n\\n\\t\\t\\tvar arcLengths = this.getLengths();\\n\\n\\t\\t\\tvar i = 0, il = arcLengths.length;\\n\\n\\t\\t\\tvar targetArcLength; // The targeted u distance value to get\\n\\n\\t\\t\\tif ( distance ) {\\n\\n\\t\\t\\t\\ttargetArcLength = distance;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\ttargetArcLength = u * arcLengths[ il - 1 ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// binary search for the index with largest value smaller than target u distance\\n\\n\\t\\t\\tvar low = 0, high = il - 1, comparison;\\n\\n\\t\\t\\twhile ( low <= high ) {\\n\\n\\t\\t\\t\\ti = Math.floor( low + ( high - low ) / 2 ); // less likely to overflow, though probably not issue here, JS doesn't really have integers, all numbers are floats\\n\\n\\t\\t\\t\\tcomparison = arcLengths[ i ] - targetArcLength;\\n\\n\\t\\t\\t\\tif ( comparison < 0 ) {\\n\\n\\t\\t\\t\\t\\tlow = i + 1;\\n\\n\\t\\t\\t\\t} else if ( comparison > 0 ) {\\n\\n\\t\\t\\t\\t\\thigh = i - 1;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\thigh = i;\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t// DONE\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\ti = high;\\n\\n\\t\\t\\tif ( arcLengths[ i ] === targetArcLength ) {\\n\\n\\t\\t\\t\\treturn i / ( il - 1 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// we could get finer grain at lengths, or use simple interpolation between two points\\n\\n\\t\\t\\tvar lengthBefore = arcLengths[ i ];\\n\\t\\t\\tvar lengthAfter = arcLengths[ i + 1 ];\\n\\n\\t\\t\\tvar segmentLength = lengthAfter - lengthBefore;\\n\\n\\t\\t\\t// determine where we are between the 'before' and 'after' points\\n\\n\\t\\t\\tvar segmentFraction = ( targetArcLength - lengthBefore ) / segmentLength;\\n\\n\\t\\t\\t// add that fractional amount to t\\n\\n\\t\\t\\tvar t = ( i + segmentFraction ) / ( il - 1 );\\n\\n\\t\\t\\treturn t;\\n\\n\\t\\t},\\n\\n\\t\\t// Returns a unit vector tangent at t\\n\\t\\t// In case any sub curve does not implement its tangent derivation,\\n\\t\\t// 2 points a small delta apart will be used to find its gradient\\n\\t\\t// which seems to give a reasonable approximation\\n\\n\\t\\tgetTangent: function ( t ) {\\n\\n\\t\\t\\tvar delta = 0.0001;\\n\\t\\t\\tvar t1 = t - delta;\\n\\t\\t\\tvar t2 = t + delta;\\n\\n\\t\\t\\t// Capping in case of danger\\n\\n\\t\\t\\tif ( t1 < 0 ) t1 = 0;\\n\\t\\t\\tif ( t2 > 1 ) t2 = 1;\\n\\n\\t\\t\\tvar pt1 = this.getPoint( t1 );\\n\\t\\t\\tvar pt2 = this.getPoint( t2 );\\n\\n\\t\\t\\tvar vec = pt2.clone().sub( pt1 );\\n\\t\\t\\treturn vec.normalize();\\n\\n\\t\\t},\\n\\n\\t\\tgetTangentAt: function ( u ) {\\n\\n\\t\\t\\tvar t = this.getUtoTmapping( u );\\n\\t\\t\\treturn this.getTangent( t );\\n\\n\\t\\t},\\n\\n\\t\\tcomputeFrenetFrames: function ( segments, closed ) {\\n\\n\\t\\t\\t// see http://www.cs.indiana.edu/pub/techreports/TR425.pdf\\n\\n\\t\\t\\tvar normal = new Vector3();\\n\\n\\t\\t\\tvar tangents = [];\\n\\t\\t\\tvar normals = [];\\n\\t\\t\\tvar binormals = [];\\n\\n\\t\\t\\tvar vec = new Vector3();\\n\\t\\t\\tvar mat = new Matrix4();\\n\\n\\t\\t\\tvar i, u, theta;\\n\\n\\t\\t\\t// compute the tangent vectors for each segment on the curve\\n\\n\\t\\t\\tfor ( i = 0; i <= segments; i ++ ) {\\n\\n\\t\\t\\t\\tu = i / segments;\\n\\n\\t\\t\\t\\ttangents[ i ] = this.getTangentAt( u );\\n\\t\\t\\t\\ttangents[ i ].normalize();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// select an initial normal vector perpendicular to the first tangent vector,\\n\\t\\t\\t// and in the direction of the minimum tangent xyz component\\n\\n\\t\\t\\tnormals[ 0 ] = new Vector3();\\n\\t\\t\\tbinormals[ 0 ] = new Vector3();\\n\\t\\t\\tvar min = Number.MAX_VALUE;\\n\\t\\t\\tvar tx = Math.abs( tangents[ 0 ].x );\\n\\t\\t\\tvar ty = Math.abs( tangents[ 0 ].y );\\n\\t\\t\\tvar tz = Math.abs( tangents[ 0 ].z );\\n\\n\\t\\t\\tif ( tx <= min ) {\\n\\n\\t\\t\\t\\tmin = tx;\\n\\t\\t\\t\\tnormal.set( 1, 0, 0 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( ty <= min ) {\\n\\n\\t\\t\\t\\tmin = ty;\\n\\t\\t\\t\\tnormal.set( 0, 1, 0 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( tz <= min ) {\\n\\n\\t\\t\\t\\tnormal.set( 0, 0, 1 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvec.crossVectors( tangents[ 0 ], normal ).normalize();\\n\\n\\t\\t\\tnormals[ 0 ].crossVectors( tangents[ 0 ], vec );\\n\\t\\t\\tbinormals[ 0 ].crossVectors( tangents[ 0 ], normals[ 0 ] );\\n\\n\\n\\t\\t\\t// compute the slowly-varying normal and binormal vectors for each segment on the curve\\n\\n\\t\\t\\tfor ( i = 1; i <= segments; i ++ ) {\\n\\n\\t\\t\\t\\tnormals[ i ] = normals[ i - 1 ].clone();\\n\\n\\t\\t\\t\\tbinormals[ i ] = binormals[ i - 1 ].clone();\\n\\n\\t\\t\\t\\tvec.crossVectors( tangents[ i - 1 ], tangents[ i ] );\\n\\n\\t\\t\\t\\tif ( vec.length() > Number.EPSILON ) {\\n\\n\\t\\t\\t\\t\\tvec.normalize();\\n\\n\\t\\t\\t\\t\\ttheta = Math.acos( _Math.clamp( tangents[ i - 1 ].dot( tangents[ i ] ), - 1, 1 ) ); // clamp for floating pt errors\\n\\n\\t\\t\\t\\t\\tnormals[ i ].applyMatrix4( mat.makeRotationAxis( vec, theta ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tbinormals[ i ].crossVectors( tangents[ i ], normals[ i ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// if the curve is closed, postprocess the vectors so the first and last normal vectors are the same\\n\\n\\t\\t\\tif ( closed === true ) {\\n\\n\\t\\t\\t\\ttheta = Math.acos( _Math.clamp( normals[ 0 ].dot( normals[ segments ] ), - 1, 1 ) );\\n\\t\\t\\t\\ttheta /= segments;\\n\\n\\t\\t\\t\\tif ( tangents[ 0 ].dot( vec.crossVectors( normals[ 0 ], normals[ segments ] ) ) > 0 ) {\\n\\n\\t\\t\\t\\t\\ttheta = - theta;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfor ( i = 1; i <= segments; i ++ ) {\\n\\n\\t\\t\\t\\t\\t// twist a little...\\n\\t\\t\\t\\t\\tnormals[ i ].applyMatrix4( mat.makeRotationAxis( tangents[ i ], theta * i ) );\\n\\t\\t\\t\\t\\tbinormals[ i ].crossVectors( tangents[ i ], normals[ i ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn {\\n\\t\\t\\t\\ttangents: tangents,\\n\\t\\t\\t\\tnormals: normals,\\n\\t\\t\\t\\tbinormals: binormals\\n\\t\\t\\t};\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tthis.arcLengthDivisions = source.arcLengthDivisions;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function () {\\n\\n\\t\\t\\tvar data = {\\n\\t\\t\\t\\tmetadata: {\\n\\t\\t\\t\\t\\tversion: 4.5,\\n\\t\\t\\t\\t\\ttype: 'Curve',\\n\\t\\t\\t\\t\\tgenerator: 'Curve.toJSON'\\n\\t\\t\\t\\t}\\n\\t\\t\\t};\\n\\n\\t\\t\\tdata.arcLengthDivisions = this.arcLengthDivisions;\\n\\t\\t\\tdata.type = this.type;\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t},\\n\\n\\t\\tfromJSON: function ( json ) {\\n\\n\\t\\t\\tthis.arcLengthDivisions = json.arcLengthDivisions;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tfunction EllipseCurve( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'EllipseCurve';\\n\\n\\t\\tthis.aX = aX || 0;\\n\\t\\tthis.aY = aY || 0;\\n\\n\\t\\tthis.xRadius = xRadius || 1;\\n\\t\\tthis.yRadius = yRadius || 1;\\n\\n\\t\\tthis.aStartAngle = aStartAngle || 0;\\n\\t\\tthis.aEndAngle = aEndAngle || 2 * Math.PI;\\n\\n\\t\\tthis.aClockwise = aClockwise || false;\\n\\n\\t\\tthis.aRotation = aRotation || 0;\\n\\n\\t}\\n\\n\\tEllipseCurve.prototype = Object.create( Curve.prototype );\\n\\tEllipseCurve.prototype.constructor = EllipseCurve;\\n\\n\\tEllipseCurve.prototype.isEllipseCurve = true;\\n\\n\\tEllipseCurve.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector2();\\n\\n\\t\\tvar twoPi = Math.PI * 2;\\n\\t\\tvar deltaAngle = this.aEndAngle - this.aStartAngle;\\n\\t\\tvar samePoints = Math.abs( deltaAngle ) < Number.EPSILON;\\n\\n\\t\\t// ensures that deltaAngle is 0 .. 2 PI\\n\\t\\twhile ( deltaAngle < 0 ) deltaAngle += twoPi;\\n\\t\\twhile ( deltaAngle > twoPi ) deltaAngle -= twoPi;\\n\\n\\t\\tif ( deltaAngle < Number.EPSILON ) {\\n\\n\\t\\t\\tif ( samePoints ) {\\n\\n\\t\\t\\t\\tdeltaAngle = 0;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tdeltaAngle = twoPi;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tif ( this.aClockwise === true && ! samePoints ) {\\n\\n\\t\\t\\tif ( deltaAngle === twoPi ) {\\n\\n\\t\\t\\t\\tdeltaAngle = - twoPi;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tdeltaAngle = deltaAngle - twoPi;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tvar angle = this.aStartAngle + t * deltaAngle;\\n\\t\\tvar x = this.aX + this.xRadius * Math.cos( angle );\\n\\t\\tvar y = this.aY + this.yRadius * Math.sin( angle );\\n\\n\\t\\tif ( this.aRotation !== 0 ) {\\n\\n\\t\\t\\tvar cos = Math.cos( this.aRotation );\\n\\t\\t\\tvar sin = Math.sin( this.aRotation );\\n\\n\\t\\t\\tvar tx = x - this.aX;\\n\\t\\t\\tvar ty = y - this.aY;\\n\\n\\t\\t\\t// Rotate the point about the center of the ellipse.\\n\\t\\t\\tx = tx * cos - ty * sin + this.aX;\\n\\t\\t\\ty = tx * sin + ty * cos + this.aY;\\n\\n\\t\\t}\\n\\n\\t\\treturn point.set( x, y );\\n\\n\\t};\\n\\n\\tEllipseCurve.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.aX = source.aX;\\n\\t\\tthis.aY = source.aY;\\n\\n\\t\\tthis.xRadius = source.xRadius;\\n\\t\\tthis.yRadius = source.yRadius;\\n\\n\\t\\tthis.aStartAngle = source.aStartAngle;\\n\\t\\tthis.aEndAngle = source.aEndAngle;\\n\\n\\t\\tthis.aClockwise = source.aClockwise;\\n\\n\\t\\tthis.aRotation = source.aRotation;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\n\\tEllipseCurve.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.aX = this.aX;\\n\\t\\tdata.aY = this.aY;\\n\\n\\t\\tdata.xRadius = this.xRadius;\\n\\t\\tdata.yRadius = this.yRadius;\\n\\n\\t\\tdata.aStartAngle = this.aStartAngle;\\n\\t\\tdata.aEndAngle = this.aEndAngle;\\n\\n\\t\\tdata.aClockwise = this.aClockwise;\\n\\n\\t\\tdata.aRotation = this.aRotation;\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tEllipseCurve.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.aX = json.aX;\\n\\t\\tthis.aY = json.aY;\\n\\n\\t\\tthis.xRadius = json.xRadius;\\n\\t\\tthis.yRadius = json.yRadius;\\n\\n\\t\\tthis.aStartAngle = json.aStartAngle;\\n\\t\\tthis.aEndAngle = json.aEndAngle;\\n\\n\\t\\tthis.aClockwise = json.aClockwise;\\n\\n\\t\\tthis.aRotation = json.aRotation;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tfunction ArcCurve( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {\\n\\n\\t\\tEllipseCurve.call( this, aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise );\\n\\n\\t\\tthis.type = 'ArcCurve';\\n\\n\\t}\\n\\n\\tArcCurve.prototype = Object.create( EllipseCurve.prototype );\\n\\tArcCurve.prototype.constructor = ArcCurve;\\n\\n\\tArcCurve.prototype.isArcCurve = true;\\n\\n\\t/**\\n\\t * @author zz85 https://github.com/zz85\\n\\t *\\n\\t * Centripetal CatmullRom Curve - which is useful for avoiding\\n\\t * cusps and self-intersections in non-uniform catmull rom curves.\\n\\t * http://www.cemyuksel.com/research/catmullrom_param/catmullrom.pdf\\n\\t *\\n\\t * curve.type accepts centripetal(default), chordal and catmullrom\\n\\t * curve.tension is used for catmullrom which defaults to 0.5\\n\\t */\\n\\n\\n\\t/*\\n\\tBased on an optimized c++ solution in\\n\\t - http://stackoverflow.com/questions/9489736/catmull-rom-curve-with-no-cusps-and-no-self-intersections/\\n\\t - http://ideone.com/NoEbVM\\n\\n\\tThis CubicPoly class could be used for reusing some variables and calculations,\\n\\tbut for three.js curve use, it could be possible inlined and flatten into a single function call\\n\\twhich can be placed in CurveUtils.\\n\\t*/\\n\\n\\tfunction CubicPoly() {\\n\\n\\t\\tvar c0 = 0, c1 = 0, c2 = 0, c3 = 0;\\n\\n\\t\\t/*\\n\\t\\t * Compute coefficients for a cubic polynomial\\n\\t\\t * p(s) = c0 + c1*s + c2*s^2 + c3*s^3\\n\\t\\t * such that\\n\\t\\t * p(0) = x0, p(1) = x1\\n\\t\\t * and\\n\\t\\t * p'(0) = t0, p'(1) = t1.\\n\\t\\t */\\n\\t\\tfunction init( x0, x1, t0, t1 ) {\\n\\n\\t\\t\\tc0 = x0;\\n\\t\\t\\tc1 = t0;\\n\\t\\t\\tc2 = - 3 * x0 + 3 * x1 - 2 * t0 - t1;\\n\\t\\t\\tc3 = 2 * x0 - 2 * x1 + t0 + t1;\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tinitCatmullRom: function ( x0, x1, x2, x3, tension ) {\\n\\n\\t\\t\\t\\tinit( x1, x2, tension * ( x2 - x0 ), tension * ( x3 - x1 ) );\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tinitNonuniformCatmullRom: function ( x0, x1, x2, x3, dt0, dt1, dt2 ) {\\n\\n\\t\\t\\t\\t// compute tangents when parameterized in [t1,t2]\\n\\t\\t\\t\\tvar t1 = ( x1 - x0 ) / dt0 - ( x2 - x0 ) / ( dt0 + dt1 ) + ( x2 - x1 ) / dt1;\\n\\t\\t\\t\\tvar t2 = ( x2 - x1 ) / dt1 - ( x3 - x1 ) / ( dt1 + dt2 ) + ( x3 - x2 ) / dt2;\\n\\n\\t\\t\\t\\t// rescale tangents for parametrization in [0,1]\\n\\t\\t\\t\\tt1 *= dt1;\\n\\t\\t\\t\\tt2 *= dt1;\\n\\n\\t\\t\\t\\tinit( x1, x2, t1, t2 );\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tcalc: function ( t ) {\\n\\n\\t\\t\\t\\tvar t2 = t * t;\\n\\t\\t\\t\\tvar t3 = t2 * t;\\n\\t\\t\\t\\treturn c0 + c1 * t + c2 * t2 + c3 * t3;\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t//\\n\\n\\tvar tmp = new Vector3();\\n\\tvar px = new CubicPoly();\\n\\tvar py = new CubicPoly();\\n\\tvar pz = new CubicPoly();\\n\\n\\tfunction CatmullRomCurve3( points, closed, curveType, tension ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'CatmullRomCurve3';\\n\\n\\t\\tthis.points = points || [];\\n\\t\\tthis.closed = closed || false;\\n\\t\\tthis.curveType = curveType || 'centripetal';\\n\\t\\tthis.tension = tension || 0.5;\\n\\n\\t}\\n\\n\\tCatmullRomCurve3.prototype = Object.create( Curve.prototype );\\n\\tCatmullRomCurve3.prototype.constructor = CatmullRomCurve3;\\n\\n\\tCatmullRomCurve3.prototype.isCatmullRomCurve3 = true;\\n\\n\\tCatmullRomCurve3.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector3();\\n\\n\\t\\tvar points = this.points;\\n\\t\\tvar l = points.length;\\n\\n\\t\\tvar p = ( l - ( this.closed ? 0 : 1 ) ) * t;\\n\\t\\tvar intPoint = Math.floor( p );\\n\\t\\tvar weight = p - intPoint;\\n\\n\\t\\tif ( this.closed ) {\\n\\n\\t\\t\\tintPoint += intPoint > 0 ? 0 : ( Math.floor( Math.abs( intPoint ) / points.length ) + 1 ) * points.length;\\n\\n\\t\\t} else if ( weight === 0 && intPoint === l - 1 ) {\\n\\n\\t\\t\\tintPoint = l - 2;\\n\\t\\t\\tweight = 1;\\n\\n\\t\\t}\\n\\n\\t\\tvar p0, p1, p2, p3; // 4 points\\n\\n\\t\\tif ( this.closed || intPoint > 0 ) {\\n\\n\\t\\t\\tp0 = points[ ( intPoint - 1 ) % l ];\\n\\n\\t\\t} else {\\n\\n\\t\\t\\t// extrapolate first point\\n\\t\\t\\ttmp.subVectors( points[ 0 ], points[ 1 ] ).add( points[ 0 ] );\\n\\t\\t\\tp0 = tmp;\\n\\n\\t\\t}\\n\\n\\t\\tp1 = points[ intPoint % l ];\\n\\t\\tp2 = points[ ( intPoint + 1 ) % l ];\\n\\n\\t\\tif ( this.closed || intPoint + 2 < l ) {\\n\\n\\t\\t\\tp3 = points[ ( intPoint + 2 ) % l ];\\n\\n\\t\\t} else {\\n\\n\\t\\t\\t// extrapolate last point\\n\\t\\t\\ttmp.subVectors( points[ l - 1 ], points[ l - 2 ] ).add( points[ l - 1 ] );\\n\\t\\t\\tp3 = tmp;\\n\\n\\t\\t}\\n\\n\\t\\tif ( this.curveType === 'centripetal' || this.curveType === 'chordal' ) {\\n\\n\\t\\t\\t// init Centripetal / Chordal Catmull-Rom\\n\\t\\t\\tvar pow = this.curveType === 'chordal' ? 0.5 : 0.25;\\n\\t\\t\\tvar dt0 = Math.pow( p0.distanceToSquared( p1 ), pow );\\n\\t\\t\\tvar dt1 = Math.pow( p1.distanceToSquared( p2 ), pow );\\n\\t\\t\\tvar dt2 = Math.pow( p2.distanceToSquared( p3 ), pow );\\n\\n\\t\\t\\t// safety check for repeated points\\n\\t\\t\\tif ( dt1 < 1e-4 ) dt1 = 1.0;\\n\\t\\t\\tif ( dt0 < 1e-4 ) dt0 = dt1;\\n\\t\\t\\tif ( dt2 < 1e-4 ) dt2 = dt1;\\n\\n\\t\\t\\tpx.initNonuniformCatmullRom( p0.x, p1.x, p2.x, p3.x, dt0, dt1, dt2 );\\n\\t\\t\\tpy.initNonuniformCatmullRom( p0.y, p1.y, p2.y, p3.y, dt0, dt1, dt2 );\\n\\t\\t\\tpz.initNonuniformCatmullRom( p0.z, p1.z, p2.z, p3.z, dt0, dt1, dt2 );\\n\\n\\t\\t} else if ( this.curveType === 'catmullrom' ) {\\n\\n\\t\\t\\tpx.initCatmullRom( p0.x, p1.x, p2.x, p3.x, this.tension );\\n\\t\\t\\tpy.initCatmullRom( p0.y, p1.y, p2.y, p3.y, this.tension );\\n\\t\\t\\tpz.initCatmullRom( p0.z, p1.z, p2.z, p3.z, this.tension );\\n\\n\\t\\t}\\n\\n\\t\\tpoint.set(\\n\\t\\t\\tpx.calc( weight ),\\n\\t\\t\\tpy.calc( weight ),\\n\\t\\t\\tpz.calc( weight )\\n\\t\\t);\\n\\n\\t\\treturn point;\\n\\n\\t};\\n\\n\\tCatmullRomCurve3.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.points = [];\\n\\n\\t\\tfor ( var i = 0, l = source.points.length; i < l; i ++ ) {\\n\\n\\t\\t\\tvar point = source.points[ i ];\\n\\n\\t\\t\\tthis.points.push( point.clone() );\\n\\n\\t\\t}\\n\\n\\t\\tthis.closed = source.closed;\\n\\t\\tthis.curveType = source.curveType;\\n\\t\\tthis.tension = source.tension;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tCatmullRomCurve3.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.points = [];\\n\\n\\t\\tfor ( var i = 0, l = this.points.length; i < l; i ++ ) {\\n\\n\\t\\t\\tvar point = this.points[ i ];\\n\\t\\t\\tdata.points.push( point.toArray() );\\n\\n\\t\\t}\\n\\n\\t\\tdata.closed = this.closed;\\n\\t\\tdata.curveType = this.curveType;\\n\\t\\tdata.tension = this.tension;\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tCatmullRomCurve3.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.points = [];\\n\\n\\t\\tfor ( var i = 0, l = json.points.length; i < l; i ++ ) {\\n\\n\\t\\t\\tvar point = json.points[ i ];\\n\\t\\t\\tthis.points.push( new Vector3().fromArray( point ) );\\n\\n\\t\\t}\\n\\n\\t\\tthis.closed = json.closed;\\n\\t\\tthis.curveType = json.curveType;\\n\\t\\tthis.tension = json.tension;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t *\\n\\t * Bezier Curves formulas obtained from\\n\\t * http://en.wikipedia.org/wiki/Bézier_curve\\n\\t */\\n\\n\\tfunction CatmullRom( t, p0, p1, p2, p3 ) {\\n\\n\\t\\tvar v0 = ( p2 - p0 ) * 0.5;\\n\\t\\tvar v1 = ( p3 - p1 ) * 0.5;\\n\\t\\tvar t2 = t * t;\\n\\t\\tvar t3 = t * t2;\\n\\t\\treturn ( 2 * p1 - 2 * p2 + v0 + v1 ) * t3 + ( - 3 * p1 + 3 * p2 - 2 * v0 - v1 ) * t2 + v0 * t + p1;\\n\\n\\t}\\n\\n\\t//\\n\\n\\tfunction QuadraticBezierP0( t, p ) {\\n\\n\\t\\tvar k = 1 - t;\\n\\t\\treturn k * k * p;\\n\\n\\t}\\n\\n\\tfunction QuadraticBezierP1( t, p ) {\\n\\n\\t\\treturn 2 * ( 1 - t ) * t * p;\\n\\n\\t}\\n\\n\\tfunction QuadraticBezierP2( t, p ) {\\n\\n\\t\\treturn t * t * p;\\n\\n\\t}\\n\\n\\tfunction QuadraticBezier( t, p0, p1, p2 ) {\\n\\n\\t\\treturn QuadraticBezierP0( t, p0 ) + QuadraticBezierP1( t, p1 ) +\\n\\t\\t\\tQuadraticBezierP2( t, p2 );\\n\\n\\t}\\n\\n\\t//\\n\\n\\tfunction CubicBezierP0( t, p ) {\\n\\n\\t\\tvar k = 1 - t;\\n\\t\\treturn k * k * k * p;\\n\\n\\t}\\n\\n\\tfunction CubicBezierP1( t, p ) {\\n\\n\\t\\tvar k = 1 - t;\\n\\t\\treturn 3 * k * k * t * p;\\n\\n\\t}\\n\\n\\tfunction CubicBezierP2( t, p ) {\\n\\n\\t\\treturn 3 * ( 1 - t ) * t * t * p;\\n\\n\\t}\\n\\n\\tfunction CubicBezierP3( t, p ) {\\n\\n\\t\\treturn t * t * t * p;\\n\\n\\t}\\n\\n\\tfunction CubicBezier( t, p0, p1, p2, p3 ) {\\n\\n\\t\\treturn CubicBezierP0( t, p0 ) + CubicBezierP1( t, p1 ) + CubicBezierP2( t, p2 ) +\\n\\t\\t\\tCubicBezierP3( t, p3 );\\n\\n\\t}\\n\\n\\tfunction CubicBezierCurve( v0, v1, v2, v3 ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'CubicBezierCurve';\\n\\n\\t\\tthis.v0 = v0 || new Vector2();\\n\\t\\tthis.v1 = v1 || new Vector2();\\n\\t\\tthis.v2 = v2 || new Vector2();\\n\\t\\tthis.v3 = v3 || new Vector2();\\n\\n\\t}\\n\\n\\tCubicBezierCurve.prototype = Object.create( Curve.prototype );\\n\\tCubicBezierCurve.prototype.constructor = CubicBezierCurve;\\n\\n\\tCubicBezierCurve.prototype.isCubicBezierCurve = true;\\n\\n\\tCubicBezierCurve.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector2();\\n\\n\\t\\tvar v0 = this.v0, v1 = this.v1, v2 = this.v2, v3 = this.v3;\\n\\n\\t\\tpoint.set(\\n\\t\\t\\tCubicBezier( t, v0.x, v1.x, v2.x, v3.x ),\\n\\t\\t\\tCubicBezier( t, v0.y, v1.y, v2.y, v3.y )\\n\\t\\t);\\n\\n\\t\\treturn point;\\n\\n\\t};\\n\\n\\tCubicBezierCurve.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.v0.copy( source.v0 );\\n\\t\\tthis.v1.copy( source.v1 );\\n\\t\\tthis.v2.copy( source.v2 );\\n\\t\\tthis.v3.copy( source.v3 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tCubicBezierCurve.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.v0 = this.v0.toArray();\\n\\t\\tdata.v1 = this.v1.toArray();\\n\\t\\tdata.v2 = this.v2.toArray();\\n\\t\\tdata.v3 = this.v3.toArray();\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tCubicBezierCurve.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.v0.fromArray( json.v0 );\\n\\t\\tthis.v1.fromArray( json.v1 );\\n\\t\\tthis.v2.fromArray( json.v2 );\\n\\t\\tthis.v3.fromArray( json.v3 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tfunction CubicBezierCurve3( v0, v1, v2, v3 ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'CubicBezierCurve3';\\n\\n\\t\\tthis.v0 = v0 || new Vector3();\\n\\t\\tthis.v1 = v1 || new Vector3();\\n\\t\\tthis.v2 = v2 || new Vector3();\\n\\t\\tthis.v3 = v3 || new Vector3();\\n\\n\\t}\\n\\n\\tCubicBezierCurve3.prototype = Object.create( Curve.prototype );\\n\\tCubicBezierCurve3.prototype.constructor = CubicBezierCurve3;\\n\\n\\tCubicBezierCurve3.prototype.isCubicBezierCurve3 = true;\\n\\n\\tCubicBezierCurve3.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector3();\\n\\n\\t\\tvar v0 = this.v0, v1 = this.v1, v2 = this.v2, v3 = this.v3;\\n\\n\\t\\tpoint.set(\\n\\t\\t\\tCubicBezier( t, v0.x, v1.x, v2.x, v3.x ),\\n\\t\\t\\tCubicBezier( t, v0.y, v1.y, v2.y, v3.y ),\\n\\t\\t\\tCubicBezier( t, v0.z, v1.z, v2.z, v3.z )\\n\\t\\t);\\n\\n\\t\\treturn point;\\n\\n\\t};\\n\\n\\tCubicBezierCurve3.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.v0.copy( source.v0 );\\n\\t\\tthis.v1.copy( source.v1 );\\n\\t\\tthis.v2.copy( source.v2 );\\n\\t\\tthis.v3.copy( source.v3 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tCubicBezierCurve3.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.v0 = this.v0.toArray();\\n\\t\\tdata.v1 = this.v1.toArray();\\n\\t\\tdata.v2 = this.v2.toArray();\\n\\t\\tdata.v3 = this.v3.toArray();\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tCubicBezierCurve3.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.v0.fromArray( json.v0 );\\n\\t\\tthis.v1.fromArray( json.v1 );\\n\\t\\tthis.v2.fromArray( json.v2 );\\n\\t\\tthis.v3.fromArray( json.v3 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tfunction LineCurve( v1, v2 ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'LineCurve';\\n\\n\\t\\tthis.v1 = v1 || new Vector2();\\n\\t\\tthis.v2 = v2 || new Vector2();\\n\\n\\t}\\n\\n\\tLineCurve.prototype = Object.create( Curve.prototype );\\n\\tLineCurve.prototype.constructor = LineCurve;\\n\\n\\tLineCurve.prototype.isLineCurve = true;\\n\\n\\tLineCurve.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector2();\\n\\n\\t\\tif ( t === 1 ) {\\n\\n\\t\\t\\tpoint.copy( this.v2 );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tpoint.copy( this.v2 ).sub( this.v1 );\\n\\t\\t\\tpoint.multiplyScalar( t ).add( this.v1 );\\n\\n\\t\\t}\\n\\n\\t\\treturn point;\\n\\n\\t};\\n\\n\\t// Line curve is linear, so we can overwrite default getPointAt\\n\\n\\tLineCurve.prototype.getPointAt = function ( u, optionalTarget ) {\\n\\n\\t\\treturn this.getPoint( u, optionalTarget );\\n\\n\\t};\\n\\n\\tLineCurve.prototype.getTangent = function ( /* t */ ) {\\n\\n\\t\\tvar tangent = this.v2.clone().sub( this.v1 );\\n\\n\\t\\treturn tangent.normalize();\\n\\n\\t};\\n\\n\\tLineCurve.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.v1.copy( source.v1 );\\n\\t\\tthis.v2.copy( source.v2 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tLineCurve.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.v1 = this.v1.toArray();\\n\\t\\tdata.v2 = this.v2.toArray();\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tLineCurve.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.v1.fromArray( json.v1 );\\n\\t\\tthis.v2.fromArray( json.v2 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tfunction LineCurve3( v1, v2 ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'LineCurve3';\\n\\n\\t\\tthis.v1 = v1 || new Vector3();\\n\\t\\tthis.v2 = v2 || new Vector3();\\n\\n\\t}\\n\\n\\tLineCurve3.prototype = Object.create( Curve.prototype );\\n\\tLineCurve3.prototype.constructor = LineCurve3;\\n\\n\\tLineCurve3.prototype.isLineCurve3 = true;\\n\\n\\tLineCurve3.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector3();\\n\\n\\t\\tif ( t === 1 ) {\\n\\n\\t\\t\\tpoint.copy( this.v2 );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tpoint.copy( this.v2 ).sub( this.v1 );\\n\\t\\t\\tpoint.multiplyScalar( t ).add( this.v1 );\\n\\n\\t\\t}\\n\\n\\t\\treturn point;\\n\\n\\t};\\n\\n\\t// Line curve is linear, so we can overwrite default getPointAt\\n\\n\\tLineCurve3.prototype.getPointAt = function ( u, optionalTarget ) {\\n\\n\\t\\treturn this.getPoint( u, optionalTarget );\\n\\n\\t};\\n\\n\\tLineCurve3.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.v1.copy( source.v1 );\\n\\t\\tthis.v2.copy( source.v2 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tLineCurve3.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.v1 = this.v1.toArray();\\n\\t\\tdata.v2 = this.v2.toArray();\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tLineCurve3.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.v1.fromArray( json.v1 );\\n\\t\\tthis.v2.fromArray( json.v2 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tfunction QuadraticBezierCurve( v0, v1, v2 ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'QuadraticBezierCurve';\\n\\n\\t\\tthis.v0 = v0 || new Vector2();\\n\\t\\tthis.v1 = v1 || new Vector2();\\n\\t\\tthis.v2 = v2 || new Vector2();\\n\\n\\t}\\n\\n\\tQuadraticBezierCurve.prototype = Object.create( Curve.prototype );\\n\\tQuadraticBezierCurve.prototype.constructor = QuadraticBezierCurve;\\n\\n\\tQuadraticBezierCurve.prototype.isQuadraticBezierCurve = true;\\n\\n\\tQuadraticBezierCurve.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector2();\\n\\n\\t\\tvar v0 = this.v0, v1 = this.v1, v2 = this.v2;\\n\\n\\t\\tpoint.set(\\n\\t\\t\\tQuadraticBezier( t, v0.x, v1.x, v2.x ),\\n\\t\\t\\tQuadraticBezier( t, v0.y, v1.y, v2.y )\\n\\t\\t);\\n\\n\\t\\treturn point;\\n\\n\\t};\\n\\n\\tQuadraticBezierCurve.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.v0.copy( source.v0 );\\n\\t\\tthis.v1.copy( source.v1 );\\n\\t\\tthis.v2.copy( source.v2 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tQuadraticBezierCurve.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.v0 = this.v0.toArray();\\n\\t\\tdata.v1 = this.v1.toArray();\\n\\t\\tdata.v2 = this.v2.toArray();\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tQuadraticBezierCurve.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.v0.fromArray( json.v0 );\\n\\t\\tthis.v1.fromArray( json.v1 );\\n\\t\\tthis.v2.fromArray( json.v2 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tfunction QuadraticBezierCurve3( v0, v1, v2 ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'QuadraticBezierCurve3';\\n\\n\\t\\tthis.v0 = v0 || new Vector3();\\n\\t\\tthis.v1 = v1 || new Vector3();\\n\\t\\tthis.v2 = v2 || new Vector3();\\n\\n\\t}\\n\\n\\tQuadraticBezierCurve3.prototype = Object.create( Curve.prototype );\\n\\tQuadraticBezierCurve3.prototype.constructor = QuadraticBezierCurve3;\\n\\n\\tQuadraticBezierCurve3.prototype.isQuadraticBezierCurve3 = true;\\n\\n\\tQuadraticBezierCurve3.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector3();\\n\\n\\t\\tvar v0 = this.v0, v1 = this.v1, v2 = this.v2;\\n\\n\\t\\tpoint.set(\\n\\t\\t\\tQuadraticBezier( t, v0.x, v1.x, v2.x ),\\n\\t\\t\\tQuadraticBezier( t, v0.y, v1.y, v2.y ),\\n\\t\\t\\tQuadraticBezier( t, v0.z, v1.z, v2.z )\\n\\t\\t);\\n\\n\\t\\treturn point;\\n\\n\\t};\\n\\n\\tQuadraticBezierCurve3.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.v0.copy( source.v0 );\\n\\t\\tthis.v1.copy( source.v1 );\\n\\t\\tthis.v2.copy( source.v2 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tQuadraticBezierCurve3.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.v0 = this.v0.toArray();\\n\\t\\tdata.v1 = this.v1.toArray();\\n\\t\\tdata.v2 = this.v2.toArray();\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tQuadraticBezierCurve3.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.v0.fromArray( json.v0 );\\n\\t\\tthis.v1.fromArray( json.v1 );\\n\\t\\tthis.v2.fromArray( json.v2 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tfunction SplineCurve( points /* array of Vector2 */ ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'SplineCurve';\\n\\n\\t\\tthis.points = points || [];\\n\\n\\t}\\n\\n\\tSplineCurve.prototype = Object.create( Curve.prototype );\\n\\tSplineCurve.prototype.constructor = SplineCurve;\\n\\n\\tSplineCurve.prototype.isSplineCurve = true;\\n\\n\\tSplineCurve.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector2();\\n\\n\\t\\tvar points = this.points;\\n\\t\\tvar p = ( points.length - 1 ) * t;\\n\\n\\t\\tvar intPoint = Math.floor( p );\\n\\t\\tvar weight = p - intPoint;\\n\\n\\t\\tvar p0 = points[ intPoint === 0 ? intPoint : intPoint - 1 ];\\n\\t\\tvar p1 = points[ intPoint ];\\n\\t\\tvar p2 = points[ intPoint > points.length - 2 ? points.length - 1 : intPoint + 1 ];\\n\\t\\tvar p3 = points[ intPoint > points.length - 3 ? points.length - 1 : intPoint + 2 ];\\n\\n\\t\\tpoint.set(\\n\\t\\t\\tCatmullRom( weight, p0.x, p1.x, p2.x, p3.x ),\\n\\t\\t\\tCatmullRom( weight, p0.y, p1.y, p2.y, p3.y )\\n\\t\\t);\\n\\n\\t\\treturn point;\\n\\n\\t};\\n\\n\\tSplineCurve.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.points = [];\\n\\n\\t\\tfor ( var i = 0, l = source.points.length; i < l; i ++ ) {\\n\\n\\t\\t\\tvar point = source.points[ i ];\\n\\n\\t\\t\\tthis.points.push( point.clone() );\\n\\n\\t\\t}\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tSplineCurve.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.points = [];\\n\\n\\t\\tfor ( var i = 0, l = this.points.length; i < l; i ++ ) {\\n\\n\\t\\t\\tvar point = this.points[ i ];\\n\\t\\t\\tdata.points.push( point.toArray() );\\n\\n\\t\\t}\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tSplineCurve.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.points = [];\\n\\n\\t\\tfor ( var i = 0, l = json.points.length; i < l; i ++ ) {\\n\\n\\t\\t\\tvar point = json.points[ i ];\\n\\t\\t\\tthis.points.push( new Vector2().fromArray( point ) );\\n\\n\\t\\t}\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\n\\n\\tvar Curves = Object.freeze({\\n\\t\\tArcCurve: ArcCurve,\\n\\t\\tCatmullRomCurve3: CatmullRomCurve3,\\n\\t\\tCubicBezierCurve: CubicBezierCurve,\\n\\t\\tCubicBezierCurve3: CubicBezierCurve3,\\n\\t\\tEllipseCurve: EllipseCurve,\\n\\t\\tLineCurve: LineCurve,\\n\\t\\tLineCurve3: LineCurve3,\\n\\t\\tQuadraticBezierCurve: QuadraticBezierCurve,\\n\\t\\tQuadraticBezierCurve3: QuadraticBezierCurve3,\\n\\t\\tSplineCurve: SplineCurve\\n\\t});\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t *\\n\\t **/\\n\\n\\t/**************************************************************\\n\\t *\\tCurved Path - a curve path is simply a array of connected\\n\\t * curves, but retains the api of a curve\\n\\t **************************************************************/\\n\\n\\tfunction CurvePath() {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'CurvePath';\\n\\n\\t\\tthis.curves = [];\\n\\t\\tthis.autoClose = false; // Automatically closes the path\\n\\n\\t}\\n\\n\\tCurvePath.prototype = Object.assign( Object.create( Curve.prototype ), {\\n\\n\\t\\tconstructor: CurvePath,\\n\\n\\t\\tadd: function ( curve ) {\\n\\n\\t\\t\\tthis.curves.push( curve );\\n\\n\\t\\t},\\n\\n\\t\\tclosePath: function () {\\n\\n\\t\\t\\t// Add a line curve if start and end of lines are not connected\\n\\t\\t\\tvar startPoint = this.curves[ 0 ].getPoint( 0 );\\n\\t\\t\\tvar endPoint = this.curves[ this.curves.length - 1 ].getPoint( 1 );\\n\\n\\t\\t\\tif ( ! startPoint.equals( endPoint ) ) {\\n\\n\\t\\t\\t\\tthis.curves.push( new LineCurve( endPoint, startPoint ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t// To get accurate point with reference to\\n\\t\\t// entire path distance at time t,\\n\\t\\t// following has to be done:\\n\\n\\t\\t// 1. Length of each sub path have to be known\\n\\t\\t// 2. Locate and identify type of curve\\n\\t\\t// 3. Get t for the curve\\n\\t\\t// 4. Return curve.getPointAt(t')\\n\\n\\t\\tgetPoint: function ( t ) {\\n\\n\\t\\t\\tvar d = t * this.getLength();\\n\\t\\t\\tvar curveLengths = this.getCurveLengths();\\n\\t\\t\\tvar i = 0;\\n\\n\\t\\t\\t// To think about boundaries points.\\n\\n\\t\\t\\twhile ( i < curveLengths.length ) {\\n\\n\\t\\t\\t\\tif ( curveLengths[ i ] >= d ) {\\n\\n\\t\\t\\t\\t\\tvar diff = curveLengths[ i ] - d;\\n\\t\\t\\t\\t\\tvar curve = this.curves[ i ];\\n\\n\\t\\t\\t\\t\\tvar segmentLength = curve.getLength();\\n\\t\\t\\t\\t\\tvar u = segmentLength === 0 ? 0 : 1 - diff / segmentLength;\\n\\n\\t\\t\\t\\t\\treturn curve.getPointAt( u );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\ti ++;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn null;\\n\\n\\t\\t\\t// loop where sum != 0, sum > d , sum+1 1 && ! points[ points.length - 1 ].equals( points[ 0 ] ) ) {\\n\\n\\t\\t\\t\\tpoints.push( points[ 0 ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn points;\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.curves = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = source.curves.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar curve = source.curves[ i ];\\n\\n\\t\\t\\t\\tthis.curves.push( curve.clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.autoClose = source.autoClose;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function () {\\n\\n\\t\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\t\\tdata.autoClose = this.autoClose;\\n\\t\\t\\tdata.curves = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = this.curves.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar curve = this.curves[ i ];\\n\\t\\t\\t\\tdata.curves.push( curve.toJSON() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t},\\n\\n\\t\\tfromJSON: function ( json ) {\\n\\n\\t\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\t\\tthis.autoClose = json.autoClose;\\n\\t\\t\\tthis.curves = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = json.curves.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar curve = json.curves[ i ];\\n\\t\\t\\t\\tthis.curves.push( new Curves[ curve.type ]().fromJSON( curve ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t * Creates free form 2d path using series of points, lines or curves.\\n\\t **/\\n\\n\\tfunction Path( points ) {\\n\\n\\t\\tCurvePath.call( this );\\n\\n\\t\\tthis.type = 'Path';\\n\\n\\t\\tthis.currentPoint = new Vector2();\\n\\n\\t\\tif ( points ) {\\n\\n\\t\\t\\tthis.setFromPoints( points );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tPath.prototype = Object.assign( Object.create( CurvePath.prototype ), {\\n\\n\\t\\tconstructor: Path,\\n\\n\\t\\tsetFromPoints: function ( points ) {\\n\\n\\t\\t\\tthis.moveTo( points[ 0 ].x, points[ 0 ].y );\\n\\n\\t\\t\\tfor ( var i = 1, l = points.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tthis.lineTo( points[ i ].x, points[ i ].y );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tmoveTo: function ( x, y ) {\\n\\n\\t\\t\\tthis.currentPoint.set( x, y ); // TODO consider referencing vectors instead of copying?\\n\\n\\t\\t},\\n\\n\\t\\tlineTo: function ( x, y ) {\\n\\n\\t\\t\\tvar curve = new LineCurve( this.currentPoint.clone(), new Vector2( x, y ) );\\n\\t\\t\\tthis.curves.push( curve );\\n\\n\\t\\t\\tthis.currentPoint.set( x, y );\\n\\n\\t\\t},\\n\\n\\t\\tquadraticCurveTo: function ( aCPx, aCPy, aX, aY ) {\\n\\n\\t\\t\\tvar curve = new QuadraticBezierCurve(\\n\\t\\t\\t\\tthis.currentPoint.clone(),\\n\\t\\t\\t\\tnew Vector2( aCPx, aCPy ),\\n\\t\\t\\t\\tnew Vector2( aX, aY )\\n\\t\\t\\t);\\n\\n\\t\\t\\tthis.curves.push( curve );\\n\\n\\t\\t\\tthis.currentPoint.set( aX, aY );\\n\\n\\t\\t},\\n\\n\\t\\tbezierCurveTo: function ( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY ) {\\n\\n\\t\\t\\tvar curve = new CubicBezierCurve(\\n\\t\\t\\t\\tthis.currentPoint.clone(),\\n\\t\\t\\t\\tnew Vector2( aCP1x, aCP1y ),\\n\\t\\t\\t\\tnew Vector2( aCP2x, aCP2y ),\\n\\t\\t\\t\\tnew Vector2( aX, aY )\\n\\t\\t\\t);\\n\\n\\t\\t\\tthis.curves.push( curve );\\n\\n\\t\\t\\tthis.currentPoint.set( aX, aY );\\n\\n\\t\\t},\\n\\n\\t\\tsplineThru: function ( pts /*Array of Vector*/ ) {\\n\\n\\t\\t\\tvar npts = [ this.currentPoint.clone() ].concat( pts );\\n\\n\\t\\t\\tvar curve = new SplineCurve( npts );\\n\\t\\t\\tthis.curves.push( curve );\\n\\n\\t\\t\\tthis.currentPoint.copy( pts[ pts.length - 1 ] );\\n\\n\\t\\t},\\n\\n\\t\\tarc: function ( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {\\n\\n\\t\\t\\tvar x0 = this.currentPoint.x;\\n\\t\\t\\tvar y0 = this.currentPoint.y;\\n\\n\\t\\t\\tthis.absarc( aX + x0, aY + y0, aRadius,\\n\\t\\t\\t\\taStartAngle, aEndAngle, aClockwise );\\n\\n\\t\\t},\\n\\n\\t\\tabsarc: function ( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {\\n\\n\\t\\t\\tthis.absellipse( aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise );\\n\\n\\t\\t},\\n\\n\\t\\tellipse: function ( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {\\n\\n\\t\\t\\tvar x0 = this.currentPoint.x;\\n\\t\\t\\tvar y0 = this.currentPoint.y;\\n\\n\\t\\t\\tthis.absellipse( aX + x0, aY + y0, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation );\\n\\n\\t\\t},\\n\\n\\t\\tabsellipse: function ( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {\\n\\n\\t\\t\\tvar curve = new EllipseCurve( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation );\\n\\n\\t\\t\\tif ( this.curves.length > 0 ) {\\n\\n\\t\\t\\t\\t// if a previous curve is present, attempt to join\\n\\t\\t\\t\\tvar firstPoint = curve.getPoint( 0 );\\n\\n\\t\\t\\t\\tif ( ! firstPoint.equals( this.currentPoint ) ) {\\n\\n\\t\\t\\t\\t\\tthis.lineTo( firstPoint.x, firstPoint.y );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.curves.push( curve );\\n\\n\\t\\t\\tvar lastPoint = curve.getPoint( 1 );\\n\\t\\t\\tthis.currentPoint.copy( lastPoint );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tCurvePath.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.currentPoint.copy( source.currentPoint );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function () {\\n\\n\\t\\t\\tvar data = CurvePath.prototype.toJSON.call( this );\\n\\n\\t\\t\\tdata.currentPoint = this.currentPoint.toArray();\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t},\\n\\n\\t\\tfromJSON: function ( json ) {\\n\\n\\t\\t\\tCurvePath.prototype.fromJSON.call( this, json );\\n\\n\\t\\t\\tthis.currentPoint.fromArray( json.currentPoint );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t * Defines a 2d shape plane using paths.\\n\\t **/\\n\\n\\t// STEP 1 Create a path.\\n\\t// STEP 2 Turn path into shape.\\n\\t// STEP 3 ExtrudeGeometry takes in Shape/Shapes\\n\\t// STEP 3a - Extract points from each shape, turn to vertices\\n\\t// STEP 3b - Triangulate each shape, add faces.\\n\\n\\tfunction Shape( points ) {\\n\\n\\t\\tPath.call( this, points );\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.type = 'Shape';\\n\\n\\t\\tthis.holes = [];\\n\\n\\t}\\n\\n\\tShape.prototype = Object.assign( Object.create( Path.prototype ), {\\n\\n\\t\\tconstructor: Shape,\\n\\n\\t\\tgetPointsHoles: function ( divisions ) {\\n\\n\\t\\t\\tvar holesPts = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = this.holes.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tholesPts[ i ] = this.holes[ i ].getPoints( divisions );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn holesPts;\\n\\n\\t\\t},\\n\\n\\t\\t// get points of shape and holes (keypoints based on segments parameter)\\n\\n\\t\\textractPoints: function ( divisions ) {\\n\\n\\t\\t\\treturn {\\n\\n\\t\\t\\t\\tshape: this.getPoints( divisions ),\\n\\t\\t\\t\\tholes: this.getPointsHoles( divisions )\\n\\n\\t\\t\\t};\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tPath.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.holes = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = source.holes.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar hole = source.holes[ i ];\\n\\n\\t\\t\\t\\tthis.holes.push( hole.clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function () {\\n\\n\\t\\t\\tvar data = Path.prototype.toJSON.call( this );\\n\\n\\t\\t\\tdata.uuid = this.uuid;\\n\\t\\t\\tdata.holes = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = this.holes.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar hole = this.holes[ i ];\\n\\t\\t\\t\\tdata.holes.push( hole.toJSON() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t},\\n\\n\\t\\tfromJSON: function ( json ) {\\n\\n\\t\\t\\tPath.prototype.fromJSON.call( this, json );\\n\\n\\t\\t\\tthis.uuid = json.uuid;\\n\\t\\t\\tthis.holes = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = json.holes.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar hole = json.holes[ i ];\\n\\t\\t\\t\\tthis.holes.push( new Path().fromJSON( hole ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction Light( color, intensity ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Light';\\n\\n\\t\\tthis.color = new Color( color );\\n\\t\\tthis.intensity = intensity !== undefined ? intensity : 1;\\n\\n\\t\\tthis.receiveShadow = undefined;\\n\\n\\t}\\n\\n\\tLight.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Light,\\n\\n\\t\\tisLight: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tObject3D.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.color.copy( source.color );\\n\\t\\t\\tthis.intensity = source.intensity;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\tvar data = Object3D.prototype.toJSON.call( this, meta );\\n\\n\\t\\t\\tdata.object.color = this.color.getHex();\\n\\t\\t\\tdata.object.intensity = this.intensity;\\n\\n\\t\\t\\tif ( this.groundColor !== undefined ) data.object.groundColor = this.groundColor.getHex();\\n\\n\\t\\t\\tif ( this.distance !== undefined ) data.object.distance = this.distance;\\n\\t\\t\\tif ( this.angle !== undefined ) data.object.angle = this.angle;\\n\\t\\t\\tif ( this.decay !== undefined ) data.object.decay = this.decay;\\n\\t\\t\\tif ( this.penumbra !== undefined ) data.object.penumbra = this.penumbra;\\n\\n\\t\\t\\tif ( this.shadow !== undefined ) data.object.shadow = this.shadow.toJSON();\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction HemisphereLight( skyColor, groundColor, intensity ) {\\n\\n\\t\\tLight.call( this, skyColor, intensity );\\n\\n\\t\\tthis.type = 'HemisphereLight';\\n\\n\\t\\tthis.castShadow = undefined;\\n\\n\\t\\tthis.position.copy( Object3D.DefaultUp );\\n\\t\\tthis.updateMatrix();\\n\\n\\t\\tthis.groundColor = new Color( groundColor );\\n\\n\\t}\\n\\n\\tHemisphereLight.prototype = Object.assign( Object.create( Light.prototype ), {\\n\\n\\t\\tconstructor: HemisphereLight,\\n\\n\\t\\tisHemisphereLight: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tLight.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.groundColor.copy( source.groundColor );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction LightShadow( camera ) {\\n\\n\\t\\tthis.camera = camera;\\n\\n\\t\\tthis.bias = 0;\\n\\t\\tthis.radius = 1;\\n\\n\\t\\tthis.mapSize = new Vector2( 512, 512 );\\n\\n\\t\\tthis.map = null;\\n\\t\\tthis.matrix = new Matrix4();\\n\\n\\t}\\n\\n\\tObject.assign( LightShadow.prototype, {\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tthis.camera = source.camera.clone();\\n\\n\\t\\t\\tthis.bias = source.bias;\\n\\t\\t\\tthis.radius = source.radius;\\n\\n\\t\\t\\tthis.mapSize.copy( source.mapSize );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function () {\\n\\n\\t\\t\\tvar object = {};\\n\\n\\t\\t\\tif ( this.bias !== 0 ) object.bias = this.bias;\\n\\t\\t\\tif ( this.radius !== 1 ) object.radius = this.radius;\\n\\t\\t\\tif ( this.mapSize.x !== 512 || this.mapSize.y !== 512 ) object.mapSize = this.mapSize.toArray();\\n\\n\\t\\t\\tobject.camera = this.camera.toJSON( false ).object;\\n\\t\\t\\tdelete object.camera.matrix;\\n\\n\\t\\t\\treturn object;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction SpotLightShadow() {\\n\\n\\t\\tLightShadow.call( this, new PerspectiveCamera( 50, 1, 0.5, 500 ) );\\n\\n\\t}\\n\\n\\tSpotLightShadow.prototype = Object.assign( Object.create( LightShadow.prototype ), {\\n\\n\\t\\tconstructor: SpotLightShadow,\\n\\n\\t\\tisSpotLightShadow: true,\\n\\n\\t\\tupdate: function ( light ) {\\n\\n\\t\\t\\tvar camera = this.camera;\\n\\n\\t\\t\\tvar fov = _Math.RAD2DEG * 2 * light.angle;\\n\\t\\t\\tvar aspect = this.mapSize.width / this.mapSize.height;\\n\\t\\t\\tvar far = light.distance || camera.far;\\n\\n\\t\\t\\tif ( fov !== camera.fov || aspect !== camera.aspect || far !== camera.far ) {\\n\\n\\t\\t\\t\\tcamera.fov = fov;\\n\\t\\t\\t\\tcamera.aspect = aspect;\\n\\t\\t\\t\\tcamera.far = far;\\n\\t\\t\\t\\tcamera.updateProjectionMatrix();\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction SpotLight( color, intensity, distance, angle, penumbra, decay ) {\\n\\n\\t\\tLight.call( this, color, intensity );\\n\\n\\t\\tthis.type = 'SpotLight';\\n\\n\\t\\tthis.position.copy( Object3D.DefaultUp );\\n\\t\\tthis.updateMatrix();\\n\\n\\t\\tthis.target = new Object3D();\\n\\n\\t\\tObject.defineProperty( this, 'power', {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\t// intensity = power per solid angle.\\n\\t\\t\\t\\t// ref: equation (17) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf\\n\\t\\t\\t\\treturn this.intensity * Math.PI;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( power ) {\\n\\n\\t\\t\\t\\t// intensity = power per solid angle.\\n\\t\\t\\t\\t// ref: equation (17) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf\\n\\t\\t\\t\\tthis.intensity = power / Math.PI;\\n\\n\\t\\t\\t}\\n\\t\\t} );\\n\\n\\t\\tthis.distance = ( distance !== undefined ) ? distance : 0;\\n\\t\\tthis.angle = ( angle !== undefined ) ? angle : Math.PI / 3;\\n\\t\\tthis.penumbra = ( penumbra !== undefined ) ? penumbra : 0;\\n\\t\\tthis.decay = ( decay !== undefined ) ? decay : 1;\\t// for physically correct lights, should be 2.\\n\\n\\t\\tthis.shadow = new SpotLightShadow();\\n\\n\\t}\\n\\n\\tSpotLight.prototype = Object.assign( Object.create( Light.prototype ), {\\n\\n\\t\\tconstructor: SpotLight,\\n\\n\\t\\tisSpotLight: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tLight.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.distance = source.distance;\\n\\t\\t\\tthis.angle = source.angle;\\n\\t\\t\\tthis.penumbra = source.penumbra;\\n\\t\\t\\tthis.decay = source.decay;\\n\\n\\t\\t\\tthis.target = source.target.clone();\\n\\n\\t\\t\\tthis.shadow = source.shadow.clone();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\n\\tfunction PointLight( color, intensity, distance, decay ) {\\n\\n\\t\\tLight.call( this, color, intensity );\\n\\n\\t\\tthis.type = 'PointLight';\\n\\n\\t\\tObject.defineProperty( this, 'power', {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\t// intensity = power per solid angle.\\n\\t\\t\\t\\t// ref: equation (15) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf\\n\\t\\t\\t\\treturn this.intensity * 4 * Math.PI;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( power ) {\\n\\n\\t\\t\\t\\t// intensity = power per solid angle.\\n\\t\\t\\t\\t// ref: equation (15) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf\\n\\t\\t\\t\\tthis.intensity = power / ( 4 * Math.PI );\\n\\n\\t\\t\\t}\\n\\t\\t} );\\n\\n\\t\\tthis.distance = ( distance !== undefined ) ? distance : 0;\\n\\t\\tthis.decay = ( decay !== undefined ) ? decay : 1;\\t// for physically correct lights, should be 2.\\n\\n\\t\\tthis.shadow = new LightShadow( new PerspectiveCamera( 90, 1, 0.5, 500 ) );\\n\\n\\t}\\n\\n\\tPointLight.prototype = Object.assign( Object.create( Light.prototype ), {\\n\\n\\t\\tconstructor: PointLight,\\n\\n\\t\\tisPointLight: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tLight.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.distance = source.distance;\\n\\t\\t\\tthis.decay = source.decay;\\n\\n\\t\\t\\tthis.shadow = source.shadow.clone();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction DirectionalLightShadow( ) {\\n\\n\\t\\tLightShadow.call( this, new OrthographicCamera( - 5, 5, 5, - 5, 0.5, 500 ) );\\n\\n\\t}\\n\\n\\tDirectionalLightShadow.prototype = Object.assign( Object.create( LightShadow.prototype ), {\\n\\n\\t\\tconstructor: DirectionalLightShadow\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction DirectionalLight( color, intensity ) {\\n\\n\\t\\tLight.call( this, color, intensity );\\n\\n\\t\\tthis.type = 'DirectionalLight';\\n\\n\\t\\tthis.position.copy( Object3D.DefaultUp );\\n\\t\\tthis.updateMatrix();\\n\\n\\t\\tthis.target = new Object3D();\\n\\n\\t\\tthis.shadow = new DirectionalLightShadow();\\n\\n\\t}\\n\\n\\tDirectionalLight.prototype = Object.assign( Object.create( Light.prototype ), {\\n\\n\\t\\tconstructor: DirectionalLight,\\n\\n\\t\\tisDirectionalLight: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tLight.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.target = source.target.clone();\\n\\n\\t\\t\\tthis.shadow = source.shadow.clone();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction AmbientLight( color, intensity ) {\\n\\n\\t\\tLight.call( this, color, intensity );\\n\\n\\t\\tthis.type = 'AmbientLight';\\n\\n\\t\\tthis.castShadow = undefined;\\n\\n\\t}\\n\\n\\tAmbientLight.prototype = Object.assign( Object.create( Light.prototype ), {\\n\\n\\t\\tconstructor: AmbientLight,\\n\\n\\t\\tisAmbientLight: true\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author abelnation / http://github.com/abelnation\\n\\t */\\n\\n\\tfunction RectAreaLight( color, intensity, width, height ) {\\n\\n\\t\\tLight.call( this, color, intensity );\\n\\n\\t\\tthis.type = 'RectAreaLight';\\n\\n\\t\\tthis.position.set( 0, 1, 0 );\\n\\t\\tthis.updateMatrix();\\n\\n\\t\\tthis.width = ( width !== undefined ) ? width : 10;\\n\\t\\tthis.height = ( height !== undefined ) ? height : 10;\\n\\n\\t\\t// TODO (abelnation): distance/decay\\n\\n\\t\\t// TODO (abelnation): update method for RectAreaLight to update transform to lookat target\\n\\n\\t\\t// TODO (abelnation): shadows\\n\\n\\t}\\n\\n\\t// TODO (abelnation): RectAreaLight update when light shape is changed\\n\\tRectAreaLight.prototype = Object.assign( Object.create( Light.prototype ), {\\n\\n\\t\\tconstructor: RectAreaLight,\\n\\n\\t\\tisRectAreaLight: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tLight.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.width = source.width;\\n\\t\\t\\tthis.height = source.height;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\tvar data = Light.prototype.toJSON.call( this, meta );\\n\\n\\t\\t\\tdata.object.width = this.width;\\n\\t\\t\\tdata.object.height = this.height;\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * A Track that interpolates Strings\\n\\t *\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction StringKeyframeTrack( name, times, values, interpolation ) {\\n\\n\\t\\tKeyframeTrack.call( this, name, times, values, interpolation );\\n\\n\\t}\\n\\n\\tStringKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {\\n\\n\\t\\tconstructor: StringKeyframeTrack,\\n\\n\\t\\tValueTypeName: 'string',\\n\\t\\tValueBufferType: Array,\\n\\n\\t\\tDefaultInterpolation: InterpolateDiscrete,\\n\\n\\t\\tInterpolantFactoryMethodLinear: undefined,\\n\\n\\t\\tInterpolantFactoryMethodSmooth: undefined\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * A Track of Boolean keyframe values.\\n\\t *\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction BooleanKeyframeTrack( name, times, values ) {\\n\\n\\t\\tKeyframeTrack.call( this, name, times, values );\\n\\n\\t}\\n\\n\\tBooleanKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {\\n\\n\\t\\tconstructor: BooleanKeyframeTrack,\\n\\n\\t\\tValueTypeName: 'bool',\\n\\t\\tValueBufferType: Array,\\n\\n\\t\\tDefaultInterpolation: InterpolateDiscrete,\\n\\n\\t\\tInterpolantFactoryMethodLinear: undefined,\\n\\t\\tInterpolantFactoryMethodSmooth: undefined\\n\\n\\t\\t// Note: Actually this track could have a optimized / compressed\\n\\t\\t// representation of a single value and a custom interpolant that\\n\\t\\t// computes \\\"firstValue ^ isOdd( index )\\\".\\n\\n\\t} );\\n\\n\\t/**\\n\\t * Abstract base class of interpolants over parametric samples.\\n\\t *\\n\\t * The parameter domain is one dimensional, typically the time or a path\\n\\t * along a curve defined by the data.\\n\\t *\\n\\t * The sample values can have any dimensionality and derived classes may\\n\\t * apply special interpretations to the data.\\n\\t *\\n\\t * This class provides the interval seek in a Template Method, deferring\\n\\t * the actual interpolation to derived classes.\\n\\t *\\n\\t * Time complexity is O(1) for linear access crossing at most two points\\n\\t * and O(log N) for random access, where N is the number of positions.\\n\\t *\\n\\t * References:\\n\\t *\\n\\t * \\t\\thttp://www.oodesign.com/template-method-pattern.html\\n\\t *\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction Interpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {\\n\\n\\t\\tthis.parameterPositions = parameterPositions;\\n\\t\\tthis._cachedIndex = 0;\\n\\n\\t\\tthis.resultBuffer = resultBuffer !== undefined ?\\n\\t\\t\\tresultBuffer : new sampleValues.constructor( sampleSize );\\n\\t\\tthis.sampleValues = sampleValues;\\n\\t\\tthis.valueSize = sampleSize;\\n\\n\\t}\\n\\n\\tObject.assign( Interpolant.prototype, {\\n\\n\\t\\tevaluate: function ( t ) {\\n\\n\\t\\t\\tvar pp = this.parameterPositions,\\n\\t\\t\\t\\ti1 = this._cachedIndex,\\n\\n\\t\\t\\t\\tt1 = pp[ i1 ],\\n\\t\\t\\t\\tt0 = pp[ i1 - 1 ];\\n\\n\\t\\t\\tvalidate_interval: {\\n\\n\\t\\t\\t\\tseek: {\\n\\n\\t\\t\\t\\t\\tvar right;\\n\\n\\t\\t\\t\\t\\tlinear_scan: {\\n\\n\\t\\t\\t\\t\\t\\t//- See http://jsperf.com/comparison-to-undefined/3\\n\\t\\t\\t\\t\\t\\t//- slower code:\\n\\t\\t\\t\\t\\t\\t//-\\n\\t\\t\\t\\t\\t\\t//- \\t\\t\\t\\tif ( t >= t1 || t1 === undefined ) {\\n\\t\\t\\t\\t\\t\\tforward_scan: if ( ! ( t < t1 ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var giveUpAt = i1 + 2; ; ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( t1 === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif ( t < t0 ) break forward_scan;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// after end\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\ti1 = pp.length;\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tthis._cachedIndex = i1;\\n\\t\\t\\t\\t\\t\\t\\t\\t\\treturn this.afterEnd_( i1 - 1, t, t0 );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( i1 === giveUpAt ) break; // this loop\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tt0 = t1;\\n\\t\\t\\t\\t\\t\\t\\t\\tt1 = pp[ ++ i1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( t < t1 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// we have arrived at the sought interval\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak seek;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t// prepare binary search on the right side of the index\\n\\t\\t\\t\\t\\t\\t\\tright = pp.length;\\n\\t\\t\\t\\t\\t\\t\\tbreak linear_scan;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t//- slower code:\\n\\t\\t\\t\\t\\t\\t//-\\t\\t\\t\\t\\tif ( t < t0 || t0 === undefined ) {\\n\\t\\t\\t\\t\\t\\tif ( ! ( t >= t0 ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// looping?\\n\\n\\t\\t\\t\\t\\t\\t\\tvar t1global = pp[ 1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( t < t1global ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\ti1 = 2; // + 1, using the scan for the details\\n\\t\\t\\t\\t\\t\\t\\t\\tt0 = t1global;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t// linear reverse scan\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var giveUpAt = i1 - 2; ; ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( t0 === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// before start\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tthis._cachedIndex = 0;\\n\\t\\t\\t\\t\\t\\t\\t\\t\\treturn this.beforeStart_( 0, t, t1 );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( i1 === giveUpAt ) break; // this loop\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tt1 = t0;\\n\\t\\t\\t\\t\\t\\t\\t\\tt0 = pp[ -- i1 - 1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( t >= t0 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// we have arrived at the sought interval\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak seek;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t// prepare binary search on the left side of the index\\n\\t\\t\\t\\t\\t\\t\\tright = i1;\\n\\t\\t\\t\\t\\t\\t\\ti1 = 0;\\n\\t\\t\\t\\t\\t\\t\\tbreak linear_scan;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t// the interval is valid\\n\\n\\t\\t\\t\\t\\t\\tbreak validate_interval;\\n\\n\\t\\t\\t\\t\\t} // linear scan\\n\\n\\t\\t\\t\\t\\t// binary search\\n\\n\\t\\t\\t\\t\\twhile ( i1 < right ) {\\n\\n\\t\\t\\t\\t\\t\\tvar mid = ( i1 + right ) >>> 1;\\n\\n\\t\\t\\t\\t\\t\\tif ( t < pp[ mid ] ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tright = mid;\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\ti1 = mid + 1;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tt1 = pp[ i1 ];\\n\\t\\t\\t\\t\\tt0 = pp[ i1 - 1 ];\\n\\n\\t\\t\\t\\t\\t// check boundary cases, again\\n\\n\\t\\t\\t\\t\\tif ( t0 === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tthis._cachedIndex = 0;\\n\\t\\t\\t\\t\\t\\treturn this.beforeStart_( 0, t, t1 );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( t1 === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\ti1 = pp.length;\\n\\t\\t\\t\\t\\t\\tthis._cachedIndex = i1;\\n\\t\\t\\t\\t\\t\\treturn this.afterEnd_( i1 - 1, t0, t );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} // seek\\n\\n\\t\\t\\t\\tthis._cachedIndex = i1;\\n\\n\\t\\t\\t\\tthis.intervalChanged_( i1, t0, t1 );\\n\\n\\t\\t\\t} // validate_interval\\n\\n\\t\\t\\treturn this.interpolate_( i1, t0, t, t1 );\\n\\n\\t\\t},\\n\\n\\t\\tsettings: null, // optional, subclass-specific settings structure\\n\\t\\t// Note: The indirection allows central control of many interpolants.\\n\\n\\t\\t// --- Protected interface\\n\\n\\t\\tDefaultSettings_: {},\\n\\n\\t\\tgetSettings_: function () {\\n\\n\\t\\t\\treturn this.settings || this.DefaultSettings_;\\n\\n\\t\\t},\\n\\n\\t\\tcopySampleValue_: function ( index ) {\\n\\n\\t\\t\\t// copies a sample value to the result buffer\\n\\n\\t\\t\\tvar result = this.resultBuffer,\\n\\t\\t\\t\\tvalues = this.sampleValues,\\n\\t\\t\\t\\tstride = this.valueSize,\\n\\t\\t\\t\\toffset = index * stride;\\n\\n\\t\\t\\tfor ( var i = 0; i !== stride; ++ i ) {\\n\\n\\t\\t\\t\\tresult[ i ] = values[ offset + i ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn result;\\n\\n\\t\\t},\\n\\n\\t\\t// Template methods for derived classes:\\n\\n\\t\\tinterpolate_: function ( /* i1, t0, t, t1 */ ) {\\n\\n\\t\\t\\tthrow new Error( 'call to abstract method' );\\n\\t\\t\\t// implementations shall return this.resultBuffer\\n\\n\\t\\t},\\n\\n\\t\\tintervalChanged_: function ( /* i1, t0, t1 */ ) {\\n\\n\\t\\t\\t// empty\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//!\\\\ DECLARE ALIAS AFTER assign prototype !\\n\\tObject.assign( Interpolant.prototype, {\\n\\n\\t\\t//( 0, t, t0 ), returns this.resultBuffer\\n\\t\\tbeforeStart_: Interpolant.prototype.copySampleValue_,\\n\\n\\t\\t//( N-1, tN-1, t ), returns this.resultBuffer\\n\\t\\tafterEnd_: Interpolant.prototype.copySampleValue_,\\n\\n\\t} );\\n\\n\\t/**\\n\\t * Spherical linear unit quaternion interpolant.\\n\\t *\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction QuaternionLinearInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {\\n\\n\\t\\tInterpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );\\n\\n\\t}\\n\\n\\tQuaternionLinearInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), {\\n\\n\\t\\tconstructor: QuaternionLinearInterpolant,\\n\\n\\t\\tinterpolate_: function ( i1, t0, t, t1 ) {\\n\\n\\t\\t\\tvar result = this.resultBuffer,\\n\\t\\t\\t\\tvalues = this.sampleValues,\\n\\t\\t\\t\\tstride = this.valueSize,\\n\\n\\t\\t\\t\\toffset = i1 * stride,\\n\\n\\t\\t\\t\\talpha = ( t - t0 ) / ( t1 - t0 );\\n\\n\\t\\t\\tfor ( var end = offset + stride; offset !== end; offset += 4 ) {\\n\\n\\t\\t\\t\\tQuaternion.slerpFlat( result, 0, values, offset - stride, values, offset, alpha );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn result;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * A Track of quaternion keyframe values.\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction QuaternionKeyframeTrack( name, times, values, interpolation ) {\\n\\n\\t\\tKeyframeTrack.call( this, name, times, values, interpolation );\\n\\n\\t}\\n\\n\\tQuaternionKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {\\n\\n\\t\\tconstructor: QuaternionKeyframeTrack,\\n\\n\\t\\tValueTypeName: 'quaternion',\\n\\n\\t\\t// ValueBufferType is inherited\\n\\n\\t\\tDefaultInterpolation: InterpolateLinear,\\n\\n\\t\\tInterpolantFactoryMethodLinear: function ( result ) {\\n\\n\\t\\t\\treturn new QuaternionLinearInterpolant( this.times, this.values, this.getValueSize(), result );\\n\\n\\t\\t},\\n\\n\\t\\tInterpolantFactoryMethodSmooth: undefined // not yet implemented\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * A Track of keyframe values that represent color.\\n\\t *\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction ColorKeyframeTrack( name, times, values, interpolation ) {\\n\\n\\t\\tKeyframeTrack.call( this, name, times, values, interpolation );\\n\\n\\t}\\n\\n\\tColorKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {\\n\\n\\t\\tconstructor: ColorKeyframeTrack,\\n\\n\\t\\tValueTypeName: 'color'\\n\\n\\t\\t// ValueBufferType is inherited\\n\\n\\t\\t// DefaultInterpolation is inherited\\n\\n\\t\\t// Note: Very basic implementation and nothing special yet.\\n\\t\\t// However, this is the place for color space parameterization.\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * A Track of numeric keyframe values.\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction NumberKeyframeTrack( name, times, values, interpolation ) {\\n\\n\\t\\tKeyframeTrack.call( this, name, times, values, interpolation );\\n\\n\\t}\\n\\n\\tNumberKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {\\n\\n\\t\\tconstructor: NumberKeyframeTrack,\\n\\n\\t\\tValueTypeName: 'number'\\n\\n\\t\\t// ValueBufferType is inherited\\n\\n\\t\\t// DefaultInterpolation is inherited\\n\\n\\t} );\\n\\n\\t/**\\n\\t * Fast and simple cubic spline interpolant.\\n\\t *\\n\\t * It was derived from a Hermitian construction setting the first derivative\\n\\t * at each sample position to the linear slope between neighboring positions\\n\\t * over their parameter interval.\\n\\t *\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction CubicInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {\\n\\n\\t\\tInterpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );\\n\\n\\t\\tthis._weightPrev = - 0;\\n\\t\\tthis._offsetPrev = - 0;\\n\\t\\tthis._weightNext = - 0;\\n\\t\\tthis._offsetNext = - 0;\\n\\n\\t}\\n\\n\\tCubicInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), {\\n\\n\\t\\tconstructor: CubicInterpolant,\\n\\n\\t\\tDefaultSettings_: {\\n\\n\\t\\t\\tendingStart: ZeroCurvatureEnding,\\n\\t\\t\\tendingEnd: ZeroCurvatureEnding\\n\\n\\t\\t},\\n\\n\\t\\tintervalChanged_: function ( i1, t0, t1 ) {\\n\\n\\t\\t\\tvar pp = this.parameterPositions,\\n\\t\\t\\t\\tiPrev = i1 - 2,\\n\\t\\t\\t\\tiNext = i1 + 1,\\n\\n\\t\\t\\t\\ttPrev = pp[ iPrev ],\\n\\t\\t\\t\\ttNext = pp[ iNext ];\\n\\n\\t\\t\\tif ( tPrev === undefined ) {\\n\\n\\t\\t\\t\\tswitch ( this.getSettings_().endingStart ) {\\n\\n\\t\\t\\t\\t\\tcase ZeroSlopeEnding:\\n\\n\\t\\t\\t\\t\\t\\t// f'(t0) = 0\\n\\t\\t\\t\\t\\t\\tiPrev = i1;\\n\\t\\t\\t\\t\\t\\ttPrev = 2 * t0 - t1;\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase WrapAroundEnding:\\n\\n\\t\\t\\t\\t\\t\\t// use the other end of the curve\\n\\t\\t\\t\\t\\t\\tiPrev = pp.length - 2;\\n\\t\\t\\t\\t\\t\\ttPrev = t0 + pp[ iPrev ] - pp[ iPrev + 1 ];\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tdefault: // ZeroCurvatureEnding\\n\\n\\t\\t\\t\\t\\t\\t// f''(t0) = 0 a.k.a. Natural Spline\\n\\t\\t\\t\\t\\t\\tiPrev = i1;\\n\\t\\t\\t\\t\\t\\ttPrev = t1;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( tNext === undefined ) {\\n\\n\\t\\t\\t\\tswitch ( this.getSettings_().endingEnd ) {\\n\\n\\t\\t\\t\\t\\tcase ZeroSlopeEnding:\\n\\n\\t\\t\\t\\t\\t\\t// f'(tN) = 0\\n\\t\\t\\t\\t\\t\\tiNext = i1;\\n\\t\\t\\t\\t\\t\\ttNext = 2 * t1 - t0;\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase WrapAroundEnding:\\n\\n\\t\\t\\t\\t\\t\\t// use the other end of the curve\\n\\t\\t\\t\\t\\t\\tiNext = 1;\\n\\t\\t\\t\\t\\t\\ttNext = t1 + pp[ 1 ] - pp[ 0 ];\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tdefault: // ZeroCurvatureEnding\\n\\n\\t\\t\\t\\t\\t\\t// f''(tN) = 0, a.k.a. Natural Spline\\n\\t\\t\\t\\t\\t\\tiNext = i1 - 1;\\n\\t\\t\\t\\t\\t\\ttNext = t0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar halfDt = ( t1 - t0 ) * 0.5,\\n\\t\\t\\t\\tstride = this.valueSize;\\n\\n\\t\\t\\tthis._weightPrev = halfDt / ( t0 - tPrev );\\n\\t\\t\\tthis._weightNext = halfDt / ( tNext - t1 );\\n\\t\\t\\tthis._offsetPrev = iPrev * stride;\\n\\t\\t\\tthis._offsetNext = iNext * stride;\\n\\n\\t\\t},\\n\\n\\t\\tinterpolate_: function ( i1, t0, t, t1 ) {\\n\\n\\t\\t\\tvar result = this.resultBuffer,\\n\\t\\t\\t\\tvalues = this.sampleValues,\\n\\t\\t\\t\\tstride = this.valueSize,\\n\\n\\t\\t\\t\\to1 = i1 * stride,\\t\\to0 = o1 - stride,\\n\\t\\t\\t\\toP = this._offsetPrev, \\toN = this._offsetNext,\\n\\t\\t\\t\\twP = this._weightPrev,\\twN = this._weightNext,\\n\\n\\t\\t\\t\\tp = ( t - t0 ) / ( t1 - t0 ),\\n\\t\\t\\t\\tpp = p * p,\\n\\t\\t\\t\\tppp = pp * p;\\n\\n\\t\\t\\t// evaluate polynomials\\n\\n\\t\\t\\tvar sP = - wP * ppp + 2 * wP * pp - wP * p;\\n\\t\\t\\tvar s0 = ( 1 + wP ) * ppp + ( - 1.5 - 2 * wP ) * pp + ( - 0.5 + wP ) * p + 1;\\n\\t\\t\\tvar s1 = ( - 1 - wN ) * ppp + ( 1.5 + wN ) * pp + 0.5 * p;\\n\\t\\t\\tvar sN = wN * ppp - wN * pp;\\n\\n\\t\\t\\t// combine data linearly\\n\\n\\t\\t\\tfor ( var i = 0; i !== stride; ++ i ) {\\n\\n\\t\\t\\t\\tresult[ i ] =\\n\\t\\t\\t\\t\\t\\tsP * values[ oP + i ] +\\n\\t\\t\\t\\t\\t\\ts0 * values[ o0 + i ] +\\n\\t\\t\\t\\t\\t\\ts1 * values[ o1 + i ] +\\n\\t\\t\\t\\t\\t\\tsN * values[ oN + i ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn result;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction LinearInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {\\n\\n\\t\\tInterpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );\\n\\n\\t}\\n\\n\\tLinearInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), {\\n\\n\\t\\tconstructor: LinearInterpolant,\\n\\n\\t\\tinterpolate_: function ( i1, t0, t, t1 ) {\\n\\n\\t\\t\\tvar result = this.resultBuffer,\\n\\t\\t\\t\\tvalues = this.sampleValues,\\n\\t\\t\\t\\tstride = this.valueSize,\\n\\n\\t\\t\\t\\toffset1 = i1 * stride,\\n\\t\\t\\t\\toffset0 = offset1 - stride,\\n\\n\\t\\t\\t\\tweight1 = ( t - t0 ) / ( t1 - t0 ),\\n\\t\\t\\t\\tweight0 = 1 - weight1;\\n\\n\\t\\t\\tfor ( var i = 0; i !== stride; ++ i ) {\\n\\n\\t\\t\\t\\tresult[ i ] =\\n\\t\\t\\t\\t\\t\\tvalues[ offset0 + i ] * weight0 +\\n\\t\\t\\t\\t\\t\\tvalues[ offset1 + i ] * weight1;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn result;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * Interpolant that evaluates to the sample value at the position preceeding\\n\\t * the parameter.\\n\\t *\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction DiscreteInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {\\n\\n\\t\\tInterpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );\\n\\n\\t}\\n\\n\\tDiscreteInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), {\\n\\n\\t\\tconstructor: DiscreteInterpolant,\\n\\n\\t\\tinterpolate_: function ( i1 /*, t0, t, t1 */ ) {\\n\\n\\t\\t\\treturn this.copySampleValue_( i1 - 1 );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author tschw\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t */\\n\\n\\tvar AnimationUtils = {\\n\\n\\t\\t// same as Array.prototype.slice, but also works on typed arrays\\n\\t\\tarraySlice: function ( array, from, to ) {\\n\\n\\t\\t\\tif ( AnimationUtils.isTypedArray( array ) ) {\\n\\n\\t\\t\\t\\t// in ios9 array.subarray(from, undefined) will return empty array\\n\\t\\t\\t\\t// but array.subarray(from) or array.subarray(from, len) is correct\\n\\t\\t\\t\\treturn new array.constructor( array.subarray( from, to !== undefined ? to : array.length ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn array.slice( from, to );\\n\\n\\t\\t},\\n\\n\\t\\t// converts an array to a specific type\\n\\t\\tconvertArray: function ( array, type, forceClone ) {\\n\\n\\t\\t\\tif ( ! array || // let 'undefined' and 'null' pass\\n\\t\\t\\t\\t\\t! forceClone && array.constructor === type ) return array;\\n\\n\\t\\t\\tif ( typeof type.BYTES_PER_ELEMENT === 'number' ) {\\n\\n\\t\\t\\t\\treturn new type( array ); // create typed array\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn Array.prototype.slice.call( array ); // create Array\\n\\n\\t\\t},\\n\\n\\t\\tisTypedArray: function ( object ) {\\n\\n\\t\\t\\treturn ArrayBuffer.isView( object ) &&\\n\\t\\t\\t\\t\\t! ( object instanceof DataView );\\n\\n\\t\\t},\\n\\n\\t\\t// returns an array by which times and values can be sorted\\n\\t\\tgetKeyframeOrder: function ( times ) {\\n\\n\\t\\t\\tfunction compareTime( i, j ) {\\n\\n\\t\\t\\t\\treturn times[ i ] - times[ j ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar n = times.length;\\n\\t\\t\\tvar result = new Array( n );\\n\\t\\t\\tfor ( var i = 0; i !== n; ++ i ) result[ i ] = i;\\n\\n\\t\\t\\tresult.sort( compareTime );\\n\\n\\t\\t\\treturn result;\\n\\n\\t\\t},\\n\\n\\t\\t// uses the array previously returned by 'getKeyframeOrder' to sort data\\n\\t\\tsortedArray: function ( values, stride, order ) {\\n\\n\\t\\t\\tvar nValues = values.length;\\n\\t\\t\\tvar result = new values.constructor( nValues );\\n\\n\\t\\t\\tfor ( var i = 0, dstOffset = 0; dstOffset !== nValues; ++ i ) {\\n\\n\\t\\t\\t\\tvar srcOffset = order[ i ] * stride;\\n\\n\\t\\t\\t\\tfor ( var j = 0; j !== stride; ++ j ) {\\n\\n\\t\\t\\t\\t\\tresult[ dstOffset ++ ] = values[ srcOffset + j ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn result;\\n\\n\\t\\t},\\n\\n\\t\\t// function for parsing AOS keyframe formats\\n\\t\\tflattenJSON: function ( jsonKeys, times, values, valuePropertyName ) {\\n\\n\\t\\t\\tvar i = 1, key = jsonKeys[ 0 ];\\n\\n\\t\\t\\twhile ( key !== undefined && key[ valuePropertyName ] === undefined ) {\\n\\n\\t\\t\\t\\tkey = jsonKeys[ i ++ ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( key === undefined ) return; // no data\\n\\n\\t\\t\\tvar value = key[ valuePropertyName ];\\n\\t\\t\\tif ( value === undefined ) return; // no data\\n\\n\\t\\t\\tif ( Array.isArray( value ) ) {\\n\\n\\t\\t\\t\\tdo {\\n\\n\\t\\t\\t\\t\\tvalue = key[ valuePropertyName ];\\n\\n\\t\\t\\t\\t\\tif ( value !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\ttimes.push( key.time );\\n\\t\\t\\t\\t\\t\\tvalues.push.apply( values, value ); // push all elements\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tkey = jsonKeys[ i ++ ];\\n\\n\\t\\t\\t\\t} while ( key !== undefined );\\n\\n\\t\\t\\t} else if ( value.toArray !== undefined ) {\\n\\n\\t\\t\\t\\t// ...assume THREE.Math-ish\\n\\n\\t\\t\\t\\tdo {\\n\\n\\t\\t\\t\\t\\tvalue = key[ valuePropertyName ];\\n\\n\\t\\t\\t\\t\\tif ( value !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\ttimes.push( key.time );\\n\\t\\t\\t\\t\\t\\tvalue.toArray( values, values.length );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tkey = jsonKeys[ i ++ ];\\n\\n\\t\\t\\t\\t} while ( key !== undefined );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// otherwise push as-is\\n\\n\\t\\t\\t\\tdo {\\n\\n\\t\\t\\t\\t\\tvalue = key[ valuePropertyName ];\\n\\n\\t\\t\\t\\t\\tif ( value !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\ttimes.push( key.time );\\n\\t\\t\\t\\t\\t\\tvalues.push( value );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tkey = jsonKeys[ i ++ ];\\n\\n\\t\\t\\t\\t} while ( key !== undefined );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t *\\n\\t * A timed sequence of keyframes for a specific property.\\n\\t *\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction KeyframeTrack( name, times, values, interpolation ) {\\n\\n\\t\\tif ( name === undefined ) throw new Error( 'THREE.KeyframeTrack: track name is undefined' );\\n\\t\\tif ( times === undefined || times.length === 0 ) throw new Error( 'THREE.KeyframeTrack: no keyframes in track named ' + name );\\n\\n\\t\\tthis.name = name;\\n\\n\\t\\tthis.times = AnimationUtils.convertArray( times, this.TimeBufferType );\\n\\t\\tthis.values = AnimationUtils.convertArray( values, this.ValueBufferType );\\n\\n\\t\\tthis.setInterpolation( interpolation || this.DefaultInterpolation );\\n\\n\\t\\tthis.validate();\\n\\t\\tthis.optimize();\\n\\n\\t}\\n\\n\\t// Static methods:\\n\\n\\tObject.assign( KeyframeTrack, {\\n\\n\\t\\t// Serialization (in static context, because of constructor invocation\\n\\t\\t// and automatic invocation of .toJSON):\\n\\n\\t\\tparse: function ( json ) {\\n\\n\\t\\t\\tif ( json.type === undefined ) {\\n\\n\\t\\t\\t\\tthrow new Error( 'THREE.KeyframeTrack: track type undefined, can not parse' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar trackType = KeyframeTrack._getTrackTypeForValueTypeName( json.type );\\n\\n\\t\\t\\tif ( json.times === undefined ) {\\n\\n\\t\\t\\t\\tvar times = [], values = [];\\n\\n\\t\\t\\t\\tAnimationUtils.flattenJSON( json.keys, times, values, 'value' );\\n\\n\\t\\t\\t\\tjson.times = times;\\n\\t\\t\\t\\tjson.values = values;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// derived classes can define a static parse method\\n\\t\\t\\tif ( trackType.parse !== undefined ) {\\n\\n\\t\\t\\t\\treturn trackType.parse( json );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// by default, we assume a constructor compatible with the base\\n\\t\\t\\t\\treturn new trackType( json.name, json.times, json.values, json.interpolation );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( track ) {\\n\\n\\t\\t\\tvar trackType = track.constructor;\\n\\n\\t\\t\\tvar json;\\n\\n\\t\\t\\t// derived classes can define a static toJSON method\\n\\t\\t\\tif ( trackType.toJSON !== undefined ) {\\n\\n\\t\\t\\t\\tjson = trackType.toJSON( track );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// by default, we assume the data can be serialized as-is\\n\\t\\t\\t\\tjson = {\\n\\n\\t\\t\\t\\t\\t'name': track.name,\\n\\t\\t\\t\\t\\t'times': AnimationUtils.convertArray( track.times, Array ),\\n\\t\\t\\t\\t\\t'values': AnimationUtils.convertArray( track.values, Array )\\n\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\tvar interpolation = track.getInterpolation();\\n\\n\\t\\t\\t\\tif ( interpolation !== track.DefaultInterpolation ) {\\n\\n\\t\\t\\t\\t\\tjson.interpolation = interpolation;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tjson.type = track.ValueTypeName; // mandatory\\n\\n\\t\\t\\treturn json;\\n\\n\\t\\t},\\n\\n\\t\\t_getTrackTypeForValueTypeName: function ( typeName ) {\\n\\n\\t\\t\\tswitch ( typeName.toLowerCase() ) {\\n\\n\\t\\t\\t\\tcase 'scalar':\\n\\t\\t\\t\\tcase 'double':\\n\\t\\t\\t\\tcase 'float':\\n\\t\\t\\t\\tcase 'number':\\n\\t\\t\\t\\tcase 'integer':\\n\\n\\t\\t\\t\\t\\treturn NumberKeyframeTrack;\\n\\n\\t\\t\\t\\tcase 'vector':\\n\\t\\t\\t\\tcase 'vector2':\\n\\t\\t\\t\\tcase 'vector3':\\n\\t\\t\\t\\tcase 'vector4':\\n\\n\\t\\t\\t\\t\\treturn VectorKeyframeTrack;\\n\\n\\t\\t\\t\\tcase 'color':\\n\\n\\t\\t\\t\\t\\treturn ColorKeyframeTrack;\\n\\n\\t\\t\\t\\tcase 'quaternion':\\n\\n\\t\\t\\t\\t\\treturn QuaternionKeyframeTrack;\\n\\n\\t\\t\\t\\tcase 'bool':\\n\\t\\t\\t\\tcase 'boolean':\\n\\n\\t\\t\\t\\t\\treturn BooleanKeyframeTrack;\\n\\n\\t\\t\\t\\tcase 'string':\\n\\n\\t\\t\\t\\t\\treturn StringKeyframeTrack;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthrow new Error( 'THREE.KeyframeTrack: Unsupported typeName: ' + typeName );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( KeyframeTrack.prototype, {\\n\\n\\t\\tconstructor: KeyframeTrack,\\n\\n\\t\\tTimeBufferType: Float32Array,\\n\\n\\t\\tValueBufferType: Float32Array,\\n\\n\\t\\tDefaultInterpolation: InterpolateLinear,\\n\\n\\t\\tInterpolantFactoryMethodDiscrete: function ( result ) {\\n\\n\\t\\t\\treturn new DiscreteInterpolant( this.times, this.values, this.getValueSize(), result );\\n\\n\\t\\t},\\n\\n\\t\\tInterpolantFactoryMethodLinear: function ( result ) {\\n\\n\\t\\t\\treturn new LinearInterpolant( this.times, this.values, this.getValueSize(), result );\\n\\n\\t\\t},\\n\\n\\t\\tInterpolantFactoryMethodSmooth: function ( result ) {\\n\\n\\t\\t\\treturn new CubicInterpolant( this.times, this.values, this.getValueSize(), result );\\n\\n\\t\\t},\\n\\n\\t\\tsetInterpolation: function ( interpolation ) {\\n\\n\\t\\t\\tvar factoryMethod;\\n\\n\\t\\t\\tswitch ( interpolation ) {\\n\\n\\t\\t\\t\\tcase InterpolateDiscrete:\\n\\n\\t\\t\\t\\t\\tfactoryMethod = this.InterpolantFactoryMethodDiscrete;\\n\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\tcase InterpolateLinear:\\n\\n\\t\\t\\t\\t\\tfactoryMethod = this.InterpolantFactoryMethodLinear;\\n\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\tcase InterpolateSmooth:\\n\\n\\t\\t\\t\\t\\tfactoryMethod = this.InterpolantFactoryMethodSmooth;\\n\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( factoryMethod === undefined ) {\\n\\n\\t\\t\\t\\tvar message = \\\"unsupported interpolation for \\\" +\\n\\t\\t\\t\\t\\tthis.ValueTypeName + \\\" keyframe track named \\\" + this.name;\\n\\n\\t\\t\\t\\tif ( this.createInterpolant === undefined ) {\\n\\n\\t\\t\\t\\t\\t// fall back to default, unless the default itself is messed up\\n\\t\\t\\t\\t\\tif ( interpolation !== this.DefaultInterpolation ) {\\n\\n\\t\\t\\t\\t\\t\\tthis.setInterpolation( this.DefaultInterpolation );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tthrow new Error( message ); // fatal, in this case\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.KeyframeTrack:', message );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.createInterpolant = factoryMethod;\\n\\n\\t\\t},\\n\\n\\t\\tgetInterpolation: function () {\\n\\n\\t\\t\\tswitch ( this.createInterpolant ) {\\n\\n\\t\\t\\t\\tcase this.InterpolantFactoryMethodDiscrete:\\n\\n\\t\\t\\t\\t\\treturn InterpolateDiscrete;\\n\\n\\t\\t\\t\\tcase this.InterpolantFactoryMethodLinear:\\n\\n\\t\\t\\t\\t\\treturn InterpolateLinear;\\n\\n\\t\\t\\t\\tcase this.InterpolantFactoryMethodSmooth:\\n\\n\\t\\t\\t\\t\\treturn InterpolateSmooth;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tgetValueSize: function () {\\n\\n\\t\\t\\treturn this.values.length / this.times.length;\\n\\n\\t\\t},\\n\\n\\t\\t// move all keyframes either forwards or backwards in time\\n\\t\\tshift: function ( timeOffset ) {\\n\\n\\t\\t\\tif ( timeOffset !== 0.0 ) {\\n\\n\\t\\t\\t\\tvar times = this.times;\\n\\n\\t\\t\\t\\tfor ( var i = 0, n = times.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\ttimes[ i ] += timeOffset;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// scale all keyframe times by a factor (useful for frame <-> seconds conversions)\\n\\t\\tscale: function ( timeScale ) {\\n\\n\\t\\t\\tif ( timeScale !== 1.0 ) {\\n\\n\\t\\t\\t\\tvar times = this.times;\\n\\n\\t\\t\\t\\tfor ( var i = 0, n = times.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\ttimes[ i ] *= timeScale;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// removes keyframes before and after animation without changing any values within the range [startTime, endTime].\\n\\t\\t// IMPORTANT: We do not shift around keys to the start of the track time, because for interpolated keys this will change their values\\n\\t\\ttrim: function ( startTime, endTime ) {\\n\\n\\t\\t\\tvar times = this.times,\\n\\t\\t\\t\\tnKeys = times.length,\\n\\t\\t\\t\\tfrom = 0,\\n\\t\\t\\t\\tto = nKeys - 1;\\n\\n\\t\\t\\twhile ( from !== nKeys && times[ from ] < startTime ) {\\n\\n\\t\\t\\t\\t++ from;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\twhile ( to !== - 1 && times[ to ] > endTime ) {\\n\\n\\t\\t\\t\\t-- to;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t++ to; // inclusive -> exclusive bound\\n\\n\\t\\t\\tif ( from !== 0 || to !== nKeys ) {\\n\\n\\t\\t\\t\\t// empty tracks are forbidden, so keep at least one keyframe\\n\\t\\t\\t\\tif ( from >= to ) to = Math.max( to, 1 ), from = to - 1;\\n\\n\\t\\t\\t\\tvar stride = this.getValueSize();\\n\\t\\t\\t\\tthis.times = AnimationUtils.arraySlice( times, from, to );\\n\\t\\t\\t\\tthis.values = AnimationUtils.arraySlice( this.values, from * stride, to * stride );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// ensure we do not get a GarbageInGarbageOut situation, make sure tracks are at least minimally viable\\n\\t\\tvalidate: function () {\\n\\n\\t\\t\\tvar valid = true;\\n\\n\\t\\t\\tvar valueSize = this.getValueSize();\\n\\t\\t\\tif ( valueSize - Math.floor( valueSize ) !== 0 ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.KeyframeTrack: Invalid value size in track.', this );\\n\\t\\t\\t\\tvalid = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar times = this.times,\\n\\t\\t\\t\\tvalues = this.values,\\n\\n\\t\\t\\t\\tnKeys = times.length;\\n\\n\\t\\t\\tif ( nKeys === 0 ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.KeyframeTrack: Track is empty.', this );\\n\\t\\t\\t\\tvalid = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar prevTime = null;\\n\\n\\t\\t\\tfor ( var i = 0; i !== nKeys; i ++ ) {\\n\\n\\t\\t\\t\\tvar currTime = times[ i ];\\n\\n\\t\\t\\t\\tif ( typeof currTime === 'number' && isNaN( currTime ) ) {\\n\\n\\t\\t\\t\\t\\tconsole.error( 'THREE.KeyframeTrack: Time is not a valid number.', this, i, currTime );\\n\\t\\t\\t\\t\\tvalid = false;\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( prevTime !== null && prevTime > currTime ) {\\n\\n\\t\\t\\t\\t\\tconsole.error( 'THREE.KeyframeTrack: Out of order keys.', this, i, currTime, prevTime );\\n\\t\\t\\t\\t\\tvalid = false;\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tprevTime = currTime;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( values !== undefined ) {\\n\\n\\t\\t\\t\\tif ( AnimationUtils.isTypedArray( values ) ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, n = values.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\t\\tvar value = values[ i ];\\n\\n\\t\\t\\t\\t\\t\\tif ( isNaN( value ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.KeyframeTrack: Value is not a valid number.', this, i, value );\\n\\t\\t\\t\\t\\t\\t\\tvalid = false;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn valid;\\n\\n\\t\\t},\\n\\n\\t\\t// removes equivalent sequential keys as common in morph target sequences\\n\\t\\t// (0,0,0,0,1,1,1,0,0,0,0,0,0,0) --\x3e (0,0,1,1,0,0)\\n\\t\\toptimize: function () {\\n\\n\\t\\t\\tvar times = this.times,\\n\\t\\t\\t\\tvalues = this.values,\\n\\t\\t\\t\\tstride = this.getValueSize(),\\n\\n\\t\\t\\t\\tsmoothInterpolation = this.getInterpolation() === InterpolateSmooth,\\n\\n\\t\\t\\t\\twriteIndex = 1,\\n\\t\\t\\t\\tlastIndex = times.length - 1;\\n\\n\\t\\t\\tfor ( var i = 1; i < lastIndex; ++ i ) {\\n\\n\\t\\t\\t\\tvar keep = false;\\n\\n\\t\\t\\t\\tvar time = times[ i ];\\n\\t\\t\\t\\tvar timeNext = times[ i + 1 ];\\n\\n\\t\\t\\t\\t// remove adjacent keyframes scheduled at the same time\\n\\n\\t\\t\\t\\tif ( time !== timeNext && ( i !== 1 || time !== time[ 0 ] ) ) {\\n\\n\\t\\t\\t\\t\\tif ( ! smoothInterpolation ) {\\n\\n\\t\\t\\t\\t\\t\\t// remove unnecessary keyframes same as their neighbors\\n\\n\\t\\t\\t\\t\\t\\tvar offset = i * stride,\\n\\t\\t\\t\\t\\t\\t\\toffsetP = offset - stride,\\n\\t\\t\\t\\t\\t\\t\\toffsetN = offset + stride;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var j = 0; j !== stride; ++ j ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar value = values[ offset + j ];\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( value !== values[ offsetP + j ] ||\\n\\t\\t\\t\\t\\t\\t\\t\\tvalue !== values[ offsetN + j ] ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tkeep = true;\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tkeep = true;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// in-place compaction\\n\\n\\t\\t\\t\\tif ( keep ) {\\n\\n\\t\\t\\t\\t\\tif ( i !== writeIndex ) {\\n\\n\\t\\t\\t\\t\\t\\ttimes[ writeIndex ] = times[ i ];\\n\\n\\t\\t\\t\\t\\t\\tvar readOffset = i * stride,\\n\\t\\t\\t\\t\\t\\t\\twriteOffset = writeIndex * stride;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var j = 0; j !== stride; ++ j ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvalues[ writeOffset + j ] = values[ readOffset + j ];\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t++ writeIndex;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// flush last keyframe (compaction looks ahead)\\n\\n\\t\\t\\tif ( lastIndex > 0 ) {\\n\\n\\t\\t\\t\\ttimes[ writeIndex ] = times[ lastIndex ];\\n\\n\\t\\t\\t\\tfor ( var readOffset = lastIndex * stride, writeOffset = writeIndex * stride, j = 0; j !== stride; ++ j ) {\\n\\n\\t\\t\\t\\t\\tvalues[ writeOffset + j ] = values[ readOffset + j ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t++ writeIndex;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( writeIndex !== times.length ) {\\n\\n\\t\\t\\t\\tthis.times = AnimationUtils.arraySlice( times, 0, writeIndex );\\n\\t\\t\\t\\tthis.values = AnimationUtils.arraySlice( values, 0, writeIndex * stride );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * A Track of vectored keyframe values.\\n\\t *\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction VectorKeyframeTrack( name, times, values, interpolation ) {\\n\\n\\t\\tKeyframeTrack.call( this, name, times, values, interpolation );\\n\\n\\t}\\n\\n\\tVectorKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {\\n\\n\\t\\tconstructor: VectorKeyframeTrack,\\n\\n\\t\\tValueTypeName: 'vector'\\n\\n\\t\\t// ValueBufferType is inherited\\n\\n\\t\\t// DefaultInterpolation is inherited\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * Reusable set of Tracks that represent an animation.\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t */\\n\\n\\tfunction AnimationClip( name, duration, tracks ) {\\n\\n\\t\\tthis.name = name;\\n\\t\\tthis.tracks = tracks;\\n\\t\\tthis.duration = ( duration !== undefined ) ? duration : - 1;\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\t// this means it should figure out its duration by scanning the tracks\\n\\t\\tif ( this.duration < 0 ) {\\n\\n\\t\\t\\tthis.resetDuration();\\n\\n\\t\\t}\\n\\n\\t\\tthis.optimize();\\n\\n\\t}\\n\\n\\tObject.assign( AnimationClip, {\\n\\n\\t\\tparse: function ( json ) {\\n\\n\\t\\t\\tvar tracks = [],\\n\\t\\t\\t\\tjsonTracks = json.tracks,\\n\\t\\t\\t\\tframeTime = 1.0 / ( json.fps || 1.0 );\\n\\n\\t\\t\\tfor ( var i = 0, n = jsonTracks.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\ttracks.push( KeyframeTrack.parse( jsonTracks[ i ] ).scale( frameTime ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn new AnimationClip( json.name, json.duration, tracks );\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( clip ) {\\n\\n\\t\\t\\tvar tracks = [],\\n\\t\\t\\t\\tclipTracks = clip.tracks;\\n\\n\\t\\t\\tvar json = {\\n\\n\\t\\t\\t\\t'name': clip.name,\\n\\t\\t\\t\\t'duration': clip.duration,\\n\\t\\t\\t\\t'tracks': tracks\\n\\n\\t\\t\\t};\\n\\n\\t\\t\\tfor ( var i = 0, n = clipTracks.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\ttracks.push( KeyframeTrack.toJSON( clipTracks[ i ] ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn json;\\n\\n\\t\\t},\\n\\n\\t\\tCreateFromMorphTargetSequence: function ( name, morphTargetSequence, fps, noLoop ) {\\n\\n\\t\\t\\tvar numMorphTargets = morphTargetSequence.length;\\n\\t\\t\\tvar tracks = [];\\n\\n\\t\\t\\tfor ( var i = 0; i < numMorphTargets; i ++ ) {\\n\\n\\t\\t\\t\\tvar times = [];\\n\\t\\t\\t\\tvar values = [];\\n\\n\\t\\t\\t\\ttimes.push(\\n\\t\\t\\t\\t\\t( i + numMorphTargets - 1 ) % numMorphTargets,\\n\\t\\t\\t\\t\\ti,\\n\\t\\t\\t\\t\\t( i + 1 ) % numMorphTargets );\\n\\n\\t\\t\\t\\tvalues.push( 0, 1, 0 );\\n\\n\\t\\t\\t\\tvar order = AnimationUtils.getKeyframeOrder( times );\\n\\t\\t\\t\\ttimes = AnimationUtils.sortedArray( times, 1, order );\\n\\t\\t\\t\\tvalues = AnimationUtils.sortedArray( values, 1, order );\\n\\n\\t\\t\\t\\t// if there is a key at the first frame, duplicate it as the\\n\\t\\t\\t\\t// last frame as well for perfect loop.\\n\\t\\t\\t\\tif ( ! noLoop && times[ 0 ] === 0 ) {\\n\\n\\t\\t\\t\\t\\ttimes.push( numMorphTargets );\\n\\t\\t\\t\\t\\tvalues.push( values[ 0 ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\ttracks.push(\\n\\t\\t\\t\\t\\tnew NumberKeyframeTrack(\\n\\t\\t\\t\\t\\t\\t'.morphTargetInfluences[' + morphTargetSequence[ i ].name + ']',\\n\\t\\t\\t\\t\\t\\ttimes, values\\n\\t\\t\\t\\t\\t).scale( 1.0 / fps ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn new AnimationClip( name, - 1, tracks );\\n\\n\\t\\t},\\n\\n\\t\\tfindByName: function ( objectOrClipArray, name ) {\\n\\n\\t\\t\\tvar clipArray = objectOrClipArray;\\n\\n\\t\\t\\tif ( ! Array.isArray( objectOrClipArray ) ) {\\n\\n\\t\\t\\t\\tvar o = objectOrClipArray;\\n\\t\\t\\t\\tclipArray = o.geometry && o.geometry.animations || o.animations;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = 0; i < clipArray.length; i ++ ) {\\n\\n\\t\\t\\t\\tif ( clipArray[ i ].name === name ) {\\n\\n\\t\\t\\t\\t\\treturn clipArray[ i ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn null;\\n\\n\\t\\t},\\n\\n\\t\\tCreateClipsFromMorphTargetSequences: function ( morphTargets, fps, noLoop ) {\\n\\n\\t\\t\\tvar animationToMorphTargets = {};\\n\\n\\t\\t\\t// tested with https://regex101.com/ on trick sequences\\n\\t\\t\\t// such flamingo_flyA_003, flamingo_run1_003, crdeath0059\\n\\t\\t\\tvar pattern = /^([\\\\w-]*?)([\\\\d]+)$/;\\n\\n\\t\\t\\t// sort morph target names into animation groups based\\n\\t\\t\\t// patterns like Walk_001, Walk_002, Run_001, Run_002\\n\\t\\t\\tfor ( var i = 0, il = morphTargets.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar morphTarget = morphTargets[ i ];\\n\\t\\t\\t\\tvar parts = morphTarget.name.match( pattern );\\n\\n\\t\\t\\t\\tif ( parts && parts.length > 1 ) {\\n\\n\\t\\t\\t\\t\\tvar name = parts[ 1 ];\\n\\n\\t\\t\\t\\t\\tvar animationMorphTargets = animationToMorphTargets[ name ];\\n\\t\\t\\t\\t\\tif ( ! animationMorphTargets ) {\\n\\n\\t\\t\\t\\t\\t\\tanimationToMorphTargets[ name ] = animationMorphTargets = [];\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tanimationMorphTargets.push( morphTarget );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar clips = [];\\n\\n\\t\\t\\tfor ( var name in animationToMorphTargets ) {\\n\\n\\t\\t\\t\\tclips.push( AnimationClip.CreateFromMorphTargetSequence( name, animationToMorphTargets[ name ], fps, noLoop ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn clips;\\n\\n\\t\\t},\\n\\n\\t\\t// parse the animation.hierarchy format\\n\\t\\tparseAnimation: function ( animation, bones ) {\\n\\n\\t\\t\\tif ( ! animation ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.AnimationClip: No animation in JSONLoader data.' );\\n\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar addNonemptyTrack = function ( trackType, trackName, animationKeys, propertyName, destTracks ) {\\n\\n\\t\\t\\t\\t// only return track if there are actually keys.\\n\\t\\t\\t\\tif ( animationKeys.length !== 0 ) {\\n\\n\\t\\t\\t\\t\\tvar times = [];\\n\\t\\t\\t\\t\\tvar values = [];\\n\\n\\t\\t\\t\\t\\tAnimationUtils.flattenJSON( animationKeys, times, values, propertyName );\\n\\n\\t\\t\\t\\t\\t// empty keys are filtered out, so check again\\n\\t\\t\\t\\t\\tif ( times.length !== 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tdestTracks.push( new trackType( trackName, times, values ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t\\tvar tracks = [];\\n\\n\\t\\t\\tvar clipName = animation.name || 'default';\\n\\t\\t\\t// automatic length determination in AnimationClip.\\n\\t\\t\\tvar duration = animation.length || - 1;\\n\\t\\t\\tvar fps = animation.fps || 30;\\n\\n\\t\\t\\tvar hierarchyTracks = animation.hierarchy || [];\\n\\n\\t\\t\\tfor ( var h = 0; h < hierarchyTracks.length; h ++ ) {\\n\\n\\t\\t\\t\\tvar animationKeys = hierarchyTracks[ h ].keys;\\n\\n\\t\\t\\t\\t// skip empty tracks\\n\\t\\t\\t\\tif ( ! animationKeys || animationKeys.length === 0 ) continue;\\n\\n\\t\\t\\t\\t// process morph targets\\n\\t\\t\\t\\tif ( animationKeys[ 0 ].morphTargets ) {\\n\\n\\t\\t\\t\\t\\t// figure out all morph targets used in this track\\n\\t\\t\\t\\t\\tvar morphTargetNames = {};\\n\\n\\t\\t\\t\\t\\tfor ( var k = 0; k < animationKeys.length; k ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( animationKeys[ k ].morphTargets ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var m = 0; m < animationKeys[ k ].morphTargets.length; m ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tmorphTargetNames[ animationKeys[ k ].morphTargets[ m ] ] = - 1;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t// create a track for each morph target with all zero\\n\\t\\t\\t\\t\\t// morphTargetInfluences except for the keys in which\\n\\t\\t\\t\\t\\t// the morphTarget is named.\\n\\t\\t\\t\\t\\tfor ( var morphTargetName in morphTargetNames ) {\\n\\n\\t\\t\\t\\t\\t\\tvar times = [];\\n\\t\\t\\t\\t\\t\\tvar values = [];\\n\\n\\t\\t\\t\\t\\t\\tfor ( var m = 0; m !== animationKeys[ k ].morphTargets.length; ++ m ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar animationKey = animationKeys[ k ];\\n\\n\\t\\t\\t\\t\\t\\t\\ttimes.push( animationKey.time );\\n\\t\\t\\t\\t\\t\\t\\tvalues.push( ( animationKey.morphTarget === morphTargetName ) ? 1 : 0 );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\ttracks.push( new NumberKeyframeTrack( '.morphTargetInfluence[' + morphTargetName + ']', times, values ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tduration = morphTargetNames.length * ( fps || 1.0 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// ...assume skeletal animation\\n\\n\\t\\t\\t\\t\\tvar boneName = '.bones[' + bones[ h ].name + ']';\\n\\n\\t\\t\\t\\t\\taddNonemptyTrack(\\n\\t\\t\\t\\t\\t\\tVectorKeyframeTrack, boneName + '.position',\\n\\t\\t\\t\\t\\t\\tanimationKeys, 'pos', tracks );\\n\\n\\t\\t\\t\\t\\taddNonemptyTrack(\\n\\t\\t\\t\\t\\t\\tQuaternionKeyframeTrack, boneName + '.quaternion',\\n\\t\\t\\t\\t\\t\\tanimationKeys, 'rot', tracks );\\n\\n\\t\\t\\t\\t\\taddNonemptyTrack(\\n\\t\\t\\t\\t\\t\\tVectorKeyframeTrack, boneName + '.scale',\\n\\t\\t\\t\\t\\t\\tanimationKeys, 'scl', tracks );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( tracks.length === 0 ) {\\n\\n\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar clip = new AnimationClip( clipName, duration, tracks );\\n\\n\\t\\t\\treturn clip;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( AnimationClip.prototype, {\\n\\n\\t\\tresetDuration: function () {\\n\\n\\t\\t\\tvar tracks = this.tracks, duration = 0;\\n\\n\\t\\t\\tfor ( var i = 0, n = tracks.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tvar track = this.tracks[ i ];\\n\\n\\t\\t\\t\\tduration = Math.max( duration, track.times[ track.times.length - 1 ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.duration = duration;\\n\\n\\t\\t},\\n\\n\\t\\ttrim: function () {\\n\\n\\t\\t\\tfor ( var i = 0; i < this.tracks.length; i ++ ) {\\n\\n\\t\\t\\t\\tthis.tracks[ i ].trim( 0, this.duration );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\toptimize: function () {\\n\\n\\t\\t\\tfor ( var i = 0; i < this.tracks.length; i ++ ) {\\n\\n\\t\\t\\t\\tthis.tracks[ i ].optimize();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction MaterialLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\t\\tthis.textures = {};\\n\\n\\t}\\n\\n\\tObject.assign( MaterialLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar loader = new FileLoader( scope.manager );\\n\\t\\t\\tloader.load( url, function ( text ) {\\n\\n\\t\\t\\t\\tonLoad( scope.parse( JSON.parse( text ) ) );\\n\\n\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t},\\n\\n\\t\\tsetTextures: function ( value ) {\\n\\n\\t\\t\\tthis.textures = value;\\n\\n\\t\\t},\\n\\n\\t\\tparse: function ( json ) {\\n\\n\\t\\t\\tvar textures = this.textures;\\n\\n\\t\\t\\tfunction getTexture( name ) {\\n\\n\\t\\t\\t\\tif ( textures[ name ] === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.MaterialLoader: Undefined texture', name );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn textures[ name ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar material = new Materials[ json.type ]();\\n\\n\\t\\t\\tif ( json.uuid !== undefined ) material.uuid = json.uuid;\\n\\t\\t\\tif ( json.name !== undefined ) material.name = json.name;\\n\\t\\t\\tif ( json.color !== undefined ) material.color.setHex( json.color );\\n\\t\\t\\tif ( json.roughness !== undefined ) material.roughness = json.roughness;\\n\\t\\t\\tif ( json.metalness !== undefined ) material.metalness = json.metalness;\\n\\t\\t\\tif ( json.emissive !== undefined ) material.emissive.setHex( json.emissive );\\n\\t\\t\\tif ( json.specular !== undefined ) material.specular.setHex( json.specular );\\n\\t\\t\\tif ( json.shininess !== undefined ) material.shininess = json.shininess;\\n\\t\\t\\tif ( json.clearCoat !== undefined ) material.clearCoat = json.clearCoat;\\n\\t\\t\\tif ( json.clearCoatRoughness !== undefined ) material.clearCoatRoughness = json.clearCoatRoughness;\\n\\t\\t\\tif ( json.uniforms !== undefined ) material.uniforms = json.uniforms;\\n\\t\\t\\tif ( json.vertexShader !== undefined ) material.vertexShader = json.vertexShader;\\n\\t\\t\\tif ( json.fragmentShader !== undefined ) material.fragmentShader = json.fragmentShader;\\n\\t\\t\\tif ( json.vertexColors !== undefined ) material.vertexColors = json.vertexColors;\\n\\t\\t\\tif ( json.fog !== undefined ) material.fog = json.fog;\\n\\t\\t\\tif ( json.flatShading !== undefined ) material.flatShading = json.flatShading;\\n\\t\\t\\tif ( json.blending !== undefined ) material.blending = json.blending;\\n\\t\\t\\tif ( json.side !== undefined ) material.side = json.side;\\n\\t\\t\\tif ( json.opacity !== undefined ) material.opacity = json.opacity;\\n\\t\\t\\tif ( json.transparent !== undefined ) material.transparent = json.transparent;\\n\\t\\t\\tif ( json.alphaTest !== undefined ) material.alphaTest = json.alphaTest;\\n\\t\\t\\tif ( json.depthTest !== undefined ) material.depthTest = json.depthTest;\\n\\t\\t\\tif ( json.depthWrite !== undefined ) material.depthWrite = json.depthWrite;\\n\\t\\t\\tif ( json.colorWrite !== undefined ) material.colorWrite = json.colorWrite;\\n\\t\\t\\tif ( json.wireframe !== undefined ) material.wireframe = json.wireframe;\\n\\t\\t\\tif ( json.wireframeLinewidth !== undefined ) material.wireframeLinewidth = json.wireframeLinewidth;\\n\\t\\t\\tif ( json.wireframeLinecap !== undefined ) material.wireframeLinecap = json.wireframeLinecap;\\n\\t\\t\\tif ( json.wireframeLinejoin !== undefined ) material.wireframeLinejoin = json.wireframeLinejoin;\\n\\n\\t\\t\\tif ( json.rotation !== undefined ) material.rotation = json.rotation;\\n\\n\\t\\t\\tif ( json.linewidth !== 1 ) material.linewidth = json.linewidth;\\n\\t\\t\\tif ( json.dashSize !== undefined ) material.dashSize = json.dashSize;\\n\\t\\t\\tif ( json.gapSize !== undefined ) material.gapSize = json.gapSize;\\n\\t\\t\\tif ( json.scale !== undefined ) material.scale = json.scale;\\n\\n\\t\\t\\tif ( json.skinning !== undefined ) material.skinning = json.skinning;\\n\\t\\t\\tif ( json.morphTargets !== undefined ) material.morphTargets = json.morphTargets;\\n\\t\\t\\tif ( json.dithering !== undefined ) material.dithering = json.dithering;\\n\\n\\t\\t\\tif ( json.visible !== undefined ) material.visible = json.visible;\\n\\t\\t\\tif ( json.userData !== undefined ) material.userData = json.userData;\\n\\n\\t\\t\\t// Deprecated\\n\\n\\t\\t\\tif ( json.shading !== undefined ) material.flatShading = json.shading === 1; // THREE.FlatShading\\n\\n\\t\\t\\t// for PointsMaterial\\n\\n\\t\\t\\tif ( json.size !== undefined ) material.size = json.size;\\n\\t\\t\\tif ( json.sizeAttenuation !== undefined ) material.sizeAttenuation = json.sizeAttenuation;\\n\\n\\t\\t\\t// maps\\n\\n\\t\\t\\tif ( json.map !== undefined ) material.map = getTexture( json.map );\\n\\n\\t\\t\\tif ( json.alphaMap !== undefined ) {\\n\\n\\t\\t\\t\\tmaterial.alphaMap = getTexture( json.alphaMap );\\n\\t\\t\\t\\tmaterial.transparent = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( json.bumpMap !== undefined ) material.bumpMap = getTexture( json.bumpMap );\\n\\t\\t\\tif ( json.bumpScale !== undefined ) material.bumpScale = json.bumpScale;\\n\\n\\t\\t\\tif ( json.normalMap !== undefined ) material.normalMap = getTexture( json.normalMap );\\n\\t\\t\\tif ( json.normalScale !== undefined ) {\\n\\n\\t\\t\\t\\tvar normalScale = json.normalScale;\\n\\n\\t\\t\\t\\tif ( Array.isArray( normalScale ) === false ) {\\n\\n\\t\\t\\t\\t\\t// Blender exporter used to export a scalar. See #7459\\n\\n\\t\\t\\t\\t\\tnormalScale = [ normalScale, normalScale ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tmaterial.normalScale = new Vector2().fromArray( normalScale );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( json.displacementMap !== undefined ) material.displacementMap = getTexture( json.displacementMap );\\n\\t\\t\\tif ( json.displacementScale !== undefined ) material.displacementScale = json.displacementScale;\\n\\t\\t\\tif ( json.displacementBias !== undefined ) material.displacementBias = json.displacementBias;\\n\\n\\t\\t\\tif ( json.roughnessMap !== undefined ) material.roughnessMap = getTexture( json.roughnessMap );\\n\\t\\t\\tif ( json.metalnessMap !== undefined ) material.metalnessMap = getTexture( json.metalnessMap );\\n\\n\\t\\t\\tif ( json.emissiveMap !== undefined ) material.emissiveMap = getTexture( json.emissiveMap );\\n\\t\\t\\tif ( json.emissiveIntensity !== undefined ) material.emissiveIntensity = json.emissiveIntensity;\\n\\n\\t\\t\\tif ( json.specularMap !== undefined ) material.specularMap = getTexture( json.specularMap );\\n\\n\\t\\t\\tif ( json.envMap !== undefined ) material.envMap = getTexture( json.envMap );\\n\\n\\t\\t\\tif ( json.reflectivity !== undefined ) material.reflectivity = json.reflectivity;\\n\\n\\t\\t\\tif ( json.lightMap !== undefined ) material.lightMap = getTexture( json.lightMap );\\n\\t\\t\\tif ( json.lightMapIntensity !== undefined ) material.lightMapIntensity = json.lightMapIntensity;\\n\\n\\t\\t\\tif ( json.aoMap !== undefined ) material.aoMap = getTexture( json.aoMap );\\n\\t\\t\\tif ( json.aoMapIntensity !== undefined ) material.aoMapIntensity = json.aoMapIntensity;\\n\\n\\t\\t\\tif ( json.gradientMap !== undefined ) material.gradientMap = getTexture( json.gradientMap );\\n\\n\\t\\t\\treturn material;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction BufferGeometryLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t}\\n\\n\\tObject.assign( BufferGeometryLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar loader = new FileLoader( scope.manager );\\n\\t\\t\\tloader.load( url, function ( text ) {\\n\\n\\t\\t\\t\\tonLoad( scope.parse( JSON.parse( text ) ) );\\n\\n\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t},\\n\\n\\t\\tparse: function ( json ) {\\n\\n\\t\\t\\tvar geometry = new BufferGeometry();\\n\\n\\t\\t\\tvar index = json.data.index;\\n\\n\\t\\t\\tif ( index !== undefined ) {\\n\\n\\t\\t\\t\\tvar typedArray = new TYPED_ARRAYS[ index.type ]( index.array );\\n\\t\\t\\t\\tgeometry.setIndex( new BufferAttribute( typedArray, 1 ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar attributes = json.data.attributes;\\n\\n\\t\\t\\tfor ( var key in attributes ) {\\n\\n\\t\\t\\t\\tvar attribute = attributes[ key ];\\n\\t\\t\\t\\tvar typedArray = new TYPED_ARRAYS[ attribute.type ]( attribute.array );\\n\\n\\t\\t\\t\\tgeometry.addAttribute( key, new BufferAttribute( typedArray, attribute.itemSize, attribute.normalized ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar groups = json.data.groups || json.data.drawcalls || json.data.offsets;\\n\\n\\t\\t\\tif ( groups !== undefined ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0, n = groups.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\tvar group = groups[ i ];\\n\\n\\t\\t\\t\\t\\tgeometry.addGroup( group.start, group.count, group.materialIndex );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar boundingSphere = json.data.boundingSphere;\\n\\n\\t\\t\\tif ( boundingSphere !== undefined ) {\\n\\n\\t\\t\\t\\tvar center = new Vector3();\\n\\n\\t\\t\\t\\tif ( boundingSphere.center !== undefined ) {\\n\\n\\t\\t\\t\\t\\tcenter.fromArray( boundingSphere.center );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometry.boundingSphere = new Sphere( center, boundingSphere.radius );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn geometry;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tvar TYPED_ARRAYS = {\\n\\t\\tInt8Array: Int8Array,\\n\\t\\tUint8Array: Uint8Array,\\n\\t\\t// Workaround for IE11 pre KB2929437. See #11440\\n\\t\\tUint8ClampedArray: typeof Uint8ClampedArray !== 'undefined' ? Uint8ClampedArray : Uint8Array,\\n\\t\\tInt16Array: Int16Array,\\n\\t\\tUint16Array: Uint16Array,\\n\\t\\tInt32Array: Int32Array,\\n\\t\\tUint32Array: Uint32Array,\\n\\t\\tFloat32Array: Float32Array,\\n\\t\\tFloat64Array: Float64Array\\n\\t};\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction Loader() {\\n\\n\\t\\tthis.onLoadStart = function () {};\\n\\t\\tthis.onLoadProgress = function () {};\\n\\t\\tthis.onLoadComplete = function () {};\\n\\n\\t}\\n\\n\\tLoader.Handlers = {\\n\\n\\t\\thandlers: [],\\n\\n\\t\\tadd: function ( regex, loader ) {\\n\\n\\t\\t\\tthis.handlers.push( regex, loader );\\n\\n\\t\\t},\\n\\n\\t\\tget: function ( file ) {\\n\\n\\t\\t\\tvar handlers = this.handlers;\\n\\n\\t\\t\\tfor ( var i = 0, l = handlers.length; i < l; i += 2 ) {\\n\\n\\t\\t\\t\\tvar regex = handlers[ i ];\\n\\t\\t\\t\\tvar loader = handlers[ i + 1 ];\\n\\n\\t\\t\\t\\tif ( regex.test( file ) ) {\\n\\n\\t\\t\\t\\t\\treturn loader;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn null;\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\tObject.assign( Loader.prototype, {\\n\\n\\t\\tcrossOrigin: undefined,\\n\\n\\t\\tinitMaterials: function ( materials, texturePath, crossOrigin ) {\\n\\n\\t\\t\\tvar array = [];\\n\\n\\t\\t\\tfor ( var i = 0; i < materials.length; ++ i ) {\\n\\n\\t\\t\\t\\tarray[ i ] = this.createMaterial( materials[ i ], texturePath, crossOrigin );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t},\\n\\n\\t\\tcreateMaterial: ( function () {\\n\\n\\t\\t\\tvar BlendingMode = {\\n\\t\\t\\t\\tNoBlending: NoBlending,\\n\\t\\t\\t\\tNormalBlending: NormalBlending,\\n\\t\\t\\t\\tAdditiveBlending: AdditiveBlending,\\n\\t\\t\\t\\tSubtractiveBlending: SubtractiveBlending,\\n\\t\\t\\t\\tMultiplyBlending: MultiplyBlending,\\n\\t\\t\\t\\tCustomBlending: CustomBlending\\n\\t\\t\\t};\\n\\n\\t\\t\\tvar color = new Color();\\n\\t\\t\\tvar textureLoader = new TextureLoader();\\n\\t\\t\\tvar materialLoader = new MaterialLoader();\\n\\n\\t\\t\\treturn function createMaterial( m, texturePath, crossOrigin ) {\\n\\n\\t\\t\\t\\t// convert from old material format\\n\\n\\t\\t\\t\\tvar textures = {};\\n\\n\\t\\t\\t\\tfunction loadTexture( path, repeat, offset, wrap, anisotropy ) {\\n\\n\\t\\t\\t\\t\\tvar fullPath = texturePath + path;\\n\\t\\t\\t\\t\\tvar loader = Loader.Handlers.get( fullPath );\\n\\n\\t\\t\\t\\t\\tvar texture;\\n\\n\\t\\t\\t\\t\\tif ( loader !== null ) {\\n\\n\\t\\t\\t\\t\\t\\ttexture = loader.load( fullPath );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\ttextureLoader.setCrossOrigin( crossOrigin );\\n\\t\\t\\t\\t\\t\\ttexture = textureLoader.load( fullPath );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( repeat !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\ttexture.repeat.fromArray( repeat );\\n\\n\\t\\t\\t\\t\\t\\tif ( repeat[ 0 ] !== 1 ) texture.wrapS = RepeatWrapping;\\n\\t\\t\\t\\t\\t\\tif ( repeat[ 1 ] !== 1 ) texture.wrapT = RepeatWrapping;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( offset !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\ttexture.offset.fromArray( offset );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( wrap !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( wrap[ 0 ] === 'repeat' ) texture.wrapS = RepeatWrapping;\\n\\t\\t\\t\\t\\t\\tif ( wrap[ 0 ] === 'mirror' ) texture.wrapS = MirroredRepeatWrapping;\\n\\n\\t\\t\\t\\t\\t\\tif ( wrap[ 1 ] === 'repeat' ) texture.wrapT = RepeatWrapping;\\n\\t\\t\\t\\t\\t\\tif ( wrap[ 1 ] === 'mirror' ) texture.wrapT = MirroredRepeatWrapping;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( anisotropy !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\ttexture.anisotropy = anisotropy;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tvar uuid = _Math.generateUUID();\\n\\n\\t\\t\\t\\t\\ttextures[ uuid ] = texture;\\n\\n\\t\\t\\t\\t\\treturn uuid;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t//\\n\\n\\t\\t\\t\\tvar json = {\\n\\t\\t\\t\\t\\tuuid: _Math.generateUUID(),\\n\\t\\t\\t\\t\\ttype: 'MeshLambertMaterial'\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\tfor ( var name in m ) {\\n\\n\\t\\t\\t\\t\\tvar value = m[ name ];\\n\\n\\t\\t\\t\\t\\tswitch ( name ) {\\n\\n\\t\\t\\t\\t\\t\\tcase 'DbgColor':\\n\\t\\t\\t\\t\\t\\tcase 'DbgIndex':\\n\\t\\t\\t\\t\\t\\tcase 'opticalDensity':\\n\\t\\t\\t\\t\\t\\tcase 'illumination':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'DbgName':\\n\\t\\t\\t\\t\\t\\t\\tjson.name = value;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'blending':\\n\\t\\t\\t\\t\\t\\t\\tjson.blending = BlendingMode[ value ];\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'colorAmbient':\\n\\t\\t\\t\\t\\t\\tcase 'mapAmbient':\\n\\t\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.Loader.createMaterial:', name, 'is no longer supported.' );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'colorDiffuse':\\n\\t\\t\\t\\t\\t\\t\\tjson.color = color.fromArray( value ).getHex();\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'colorSpecular':\\n\\t\\t\\t\\t\\t\\t\\tjson.specular = color.fromArray( value ).getHex();\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'colorEmissive':\\n\\t\\t\\t\\t\\t\\t\\tjson.emissive = color.fromArray( value ).getHex();\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'specularCoef':\\n\\t\\t\\t\\t\\t\\t\\tjson.shininess = value;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'shading':\\n\\t\\t\\t\\t\\t\\t\\tif ( value.toLowerCase() === 'basic' ) json.type = 'MeshBasicMaterial';\\n\\t\\t\\t\\t\\t\\t\\tif ( value.toLowerCase() === 'phong' ) json.type = 'MeshPhongMaterial';\\n\\t\\t\\t\\t\\t\\t\\tif ( value.toLowerCase() === 'standard' ) json.type = 'MeshStandardMaterial';\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapDiffuse':\\n\\t\\t\\t\\t\\t\\t\\tjson.map = loadTexture( value, m.mapDiffuseRepeat, m.mapDiffuseOffset, m.mapDiffuseWrap, m.mapDiffuseAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapDiffuseRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapDiffuseOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapDiffuseWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapDiffuseAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapEmissive':\\n\\t\\t\\t\\t\\t\\t\\tjson.emissiveMap = loadTexture( value, m.mapEmissiveRepeat, m.mapEmissiveOffset, m.mapEmissiveWrap, m.mapEmissiveAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapEmissiveRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapEmissiveOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapEmissiveWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapEmissiveAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapLight':\\n\\t\\t\\t\\t\\t\\t\\tjson.lightMap = loadTexture( value, m.mapLightRepeat, m.mapLightOffset, m.mapLightWrap, m.mapLightAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapLightRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapLightOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapLightWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapLightAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapAO':\\n\\t\\t\\t\\t\\t\\t\\tjson.aoMap = loadTexture( value, m.mapAORepeat, m.mapAOOffset, m.mapAOWrap, m.mapAOAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapAORepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapAOOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapAOWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapAOAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapBump':\\n\\t\\t\\t\\t\\t\\t\\tjson.bumpMap = loadTexture( value, m.mapBumpRepeat, m.mapBumpOffset, m.mapBumpWrap, m.mapBumpAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapBumpScale':\\n\\t\\t\\t\\t\\t\\t\\tjson.bumpScale = value;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapBumpRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapBumpOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapBumpWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapBumpAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapNormal':\\n\\t\\t\\t\\t\\t\\t\\tjson.normalMap = loadTexture( value, m.mapNormalRepeat, m.mapNormalOffset, m.mapNormalWrap, m.mapNormalAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapNormalFactor':\\n\\t\\t\\t\\t\\t\\t\\tjson.normalScale = [ value, value ];\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapNormalRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapNormalOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapNormalWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapNormalAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapSpecular':\\n\\t\\t\\t\\t\\t\\t\\tjson.specularMap = loadTexture( value, m.mapSpecularRepeat, m.mapSpecularOffset, m.mapSpecularWrap, m.mapSpecularAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapSpecularRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapSpecularOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapSpecularWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapSpecularAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapMetalness':\\n\\t\\t\\t\\t\\t\\t\\tjson.metalnessMap = loadTexture( value, m.mapMetalnessRepeat, m.mapMetalnessOffset, m.mapMetalnessWrap, m.mapMetalnessAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapMetalnessRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapMetalnessOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapMetalnessWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapMetalnessAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapRoughness':\\n\\t\\t\\t\\t\\t\\t\\tjson.roughnessMap = loadTexture( value, m.mapRoughnessRepeat, m.mapRoughnessOffset, m.mapRoughnessWrap, m.mapRoughnessAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapRoughnessRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapRoughnessOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapRoughnessWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapRoughnessAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapAlpha':\\n\\t\\t\\t\\t\\t\\t\\tjson.alphaMap = loadTexture( value, m.mapAlphaRepeat, m.mapAlphaOffset, m.mapAlphaWrap, m.mapAlphaAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapAlphaRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapAlphaOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapAlphaWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapAlphaAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'flipSided':\\n\\t\\t\\t\\t\\t\\t\\tjson.side = BackSide;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'doubleSided':\\n\\t\\t\\t\\t\\t\\t\\tjson.side = DoubleSide;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'transparency':\\n\\t\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.Loader.createMaterial: transparency has been renamed to opacity' );\\n\\t\\t\\t\\t\\t\\t\\tjson.opacity = value;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'depthTest':\\n\\t\\t\\t\\t\\t\\tcase 'depthWrite':\\n\\t\\t\\t\\t\\t\\tcase 'colorWrite':\\n\\t\\t\\t\\t\\t\\tcase 'opacity':\\n\\t\\t\\t\\t\\t\\tcase 'reflectivity':\\n\\t\\t\\t\\t\\t\\tcase 'transparent':\\n\\t\\t\\t\\t\\t\\tcase 'visible':\\n\\t\\t\\t\\t\\t\\tcase 'wireframe':\\n\\t\\t\\t\\t\\t\\t\\tjson[ name ] = value;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'vertexColors':\\n\\t\\t\\t\\t\\t\\t\\tif ( value === true ) json.vertexColors = VertexColors;\\n\\t\\t\\t\\t\\t\\t\\tif ( value === 'face' ) json.vertexColors = FaceColors;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tdefault:\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.Loader.createMaterial: Unsupported', name, value );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( json.type === 'MeshBasicMaterial' ) delete json.emissive;\\n\\t\\t\\t\\tif ( json.type !== 'MeshPhongMaterial' ) delete json.specular;\\n\\n\\t\\t\\t\\tif ( json.opacity < 1 ) json.transparent = true;\\n\\n\\t\\t\\t\\tmaterialLoader.setTextures( textures );\\n\\n\\t\\t\\t\\treturn materialLoader.parse( json );\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )()\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author Don McCurdy / https://www.donmccurdy.com\\n\\t */\\n\\n\\tvar LoaderUtils = {\\n\\n\\t\\tdecodeText: function ( array ) {\\n\\n\\t\\t\\tif ( typeof TextDecoder !== 'undefined' ) {\\n\\n\\t\\t\\t\\treturn new TextDecoder().decode( array );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Avoid the String.fromCharCode.apply(null, array) shortcut, which\\n\\t\\t\\t// throws a \\\"maximum call stack size exceeded\\\" error for large arrays.\\n\\n\\t\\t\\tvar s = '';\\n\\n\\t\\t\\tfor ( var i = 0, il = array.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t// Implicitly assumes little-endian.\\n\\t\\t\\t\\ts += String.fromCharCode( array[ i ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn s;\\n\\n\\t\\t},\\n\\n\\t\\textractUrlBase: function ( url ) {\\n\\n\\t\\t\\tvar parts = url.split( '/' );\\n\\n\\t\\t\\tif ( parts.length === 1 ) return './';\\n\\n\\t\\t\\tparts.pop();\\n\\n\\t\\t\\treturn parts.join( '/' ) + '/';\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction JSONLoader( manager ) {\\n\\n\\t\\tif ( typeof manager === 'boolean' ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.JSONLoader: showStatus parameter has been removed from constructor.' );\\n\\t\\t\\tmanager = undefined;\\n\\n\\t\\t}\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t\\tthis.withCredentials = false;\\n\\n\\t}\\n\\n\\tObject.assign( JSONLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar texturePath = this.texturePath && ( typeof this.texturePath === 'string' ) ? this.texturePath : LoaderUtils.extractUrlBase( url );\\n\\n\\t\\t\\tvar loader = new FileLoader( this.manager );\\n\\t\\t\\tloader.setWithCredentials( this.withCredentials );\\n\\t\\t\\tloader.load( url, function ( text ) {\\n\\n\\t\\t\\t\\tvar json = JSON.parse( text );\\n\\t\\t\\t\\tvar metadata = json.metadata;\\n\\n\\t\\t\\t\\tif ( metadata !== undefined ) {\\n\\n\\t\\t\\t\\t\\tvar type = metadata.type;\\n\\n\\t\\t\\t\\t\\tif ( type !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( type.toLowerCase() === 'object' ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.JSONLoader: ' + url + ' should be loaded with THREE.ObjectLoader instead.' );\\n\\t\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tif ( type.toLowerCase() === 'scene' ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.JSONLoader: ' + url + ' should be loaded with THREE.SceneLoader instead.' );\\n\\t\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar object = scope.parse( json, texturePath );\\n\\t\\t\\t\\tonLoad( object.geometry, object.materials );\\n\\n\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t},\\n\\n\\t\\tsetTexturePath: function ( value ) {\\n\\n\\t\\t\\tthis.texturePath = value;\\n\\n\\t\\t},\\n\\n\\t\\tparse: ( function () {\\n\\n\\t\\t\\tfunction parseModel( json, geometry ) {\\n\\n\\t\\t\\t\\tfunction isBitSet( value, position ) {\\n\\n\\t\\t\\t\\t\\treturn value & ( 1 << position );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar i, j, fi,\\n\\n\\t\\t\\t\\t\\toffset, zLength,\\n\\n\\t\\t\\t\\t\\tcolorIndex, normalIndex, uvIndex, materialIndex,\\n\\n\\t\\t\\t\\t\\ttype,\\n\\t\\t\\t\\t\\tisQuad,\\n\\t\\t\\t\\t\\thasMaterial,\\n\\t\\t\\t\\t\\thasFaceVertexUv,\\n\\t\\t\\t\\t\\thasFaceNormal, hasFaceVertexNormal,\\n\\t\\t\\t\\t\\thasFaceColor, hasFaceVertexColor,\\n\\n\\t\\t\\t\\t\\tvertex, face, faceA, faceB, hex, normal,\\n\\n\\t\\t\\t\\t\\tuvLayer, uv, u, v,\\n\\n\\t\\t\\t\\t\\tfaces = json.faces,\\n\\t\\t\\t\\t\\tvertices = json.vertices,\\n\\t\\t\\t\\t\\tnormals = json.normals,\\n\\t\\t\\t\\t\\tcolors = json.colors,\\n\\n\\t\\t\\t\\t\\tscale = json.scale,\\n\\n\\t\\t\\t\\t\\tnUvLayers = 0;\\n\\n\\n\\t\\t\\t\\tif ( json.uvs !== undefined ) {\\n\\n\\t\\t\\t\\t\\t// disregard empty arrays\\n\\n\\t\\t\\t\\t\\tfor ( i = 0; i < json.uvs.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( json.uvs[ i ].length ) nUvLayers ++;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tfor ( i = 0; i < nUvLayers; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tgeometry.faceVertexUvs[ i ] = [];\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\toffset = 0;\\n\\t\\t\\t\\tzLength = vertices.length;\\n\\n\\t\\t\\t\\twhile ( offset < zLength ) {\\n\\n\\t\\t\\t\\t\\tvertex = new Vector3();\\n\\n\\t\\t\\t\\t\\tvertex.x = vertices[ offset ++ ] * scale;\\n\\t\\t\\t\\t\\tvertex.y = vertices[ offset ++ ] * scale;\\n\\t\\t\\t\\t\\tvertex.z = vertices[ offset ++ ] * scale;\\n\\n\\t\\t\\t\\t\\tgeometry.vertices.push( vertex );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\toffset = 0;\\n\\t\\t\\t\\tzLength = faces.length;\\n\\n\\t\\t\\t\\twhile ( offset < zLength ) {\\n\\n\\t\\t\\t\\t\\ttype = faces[ offset ++ ];\\n\\n\\t\\t\\t\\t\\tisQuad = isBitSet( type, 0 );\\n\\t\\t\\t\\t\\thasMaterial = isBitSet( type, 1 );\\n\\t\\t\\t\\t\\thasFaceVertexUv = isBitSet( type, 3 );\\n\\t\\t\\t\\t\\thasFaceNormal = isBitSet( type, 4 );\\n\\t\\t\\t\\t\\thasFaceVertexNormal = isBitSet( type, 5 );\\n\\t\\t\\t\\t\\thasFaceColor = isBitSet( type, 6 );\\n\\t\\t\\t\\t\\thasFaceVertexColor = isBitSet( type, 7 );\\n\\n\\t\\t\\t\\t\\t// console.log(\\\"type\\\", type, \\\"bits\\\", isQuad, hasMaterial, hasFaceVertexUv, hasFaceNormal, hasFaceVertexNormal, hasFaceColor, hasFaceVertexColor);\\n\\n\\t\\t\\t\\t\\tif ( isQuad ) {\\n\\n\\t\\t\\t\\t\\t\\tfaceA = new Face3();\\n\\t\\t\\t\\t\\t\\tfaceA.a = faces[ offset ];\\n\\t\\t\\t\\t\\t\\tfaceA.b = faces[ offset + 1 ];\\n\\t\\t\\t\\t\\t\\tfaceA.c = faces[ offset + 3 ];\\n\\n\\t\\t\\t\\t\\t\\tfaceB = new Face3();\\n\\t\\t\\t\\t\\t\\tfaceB.a = faces[ offset + 1 ];\\n\\t\\t\\t\\t\\t\\tfaceB.b = faces[ offset + 2 ];\\n\\t\\t\\t\\t\\t\\tfaceB.c = faces[ offset + 3 ];\\n\\n\\t\\t\\t\\t\\t\\toffset += 4;\\n\\n\\t\\t\\t\\t\\t\\tif ( hasMaterial ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tmaterialIndex = faces[ offset ++ ];\\n\\t\\t\\t\\t\\t\\t\\tfaceA.materialIndex = materialIndex;\\n\\t\\t\\t\\t\\t\\t\\tfaceB.materialIndex = materialIndex;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t// to get face <=> uv index correspondence\\n\\n\\t\\t\\t\\t\\t\\tfi = geometry.faces.length;\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceVertexUv ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( i = 0; i < nUvLayers; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tuvLayer = json.uvs[ i ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgeometry.faceVertexUvs[ i ][ fi ] = [];\\n\\t\\t\\t\\t\\t\\t\\t\\tgeometry.faceVertexUvs[ i ][ fi + 1 ] = [];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tfor ( j = 0; j < 4; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tuvIndex = faces[ offset ++ ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tu = uvLayer[ uvIndex * 2 ];\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tv = uvLayer[ uvIndex * 2 + 1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tuv = new Vector2( u, v );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif ( j !== 2 ) geometry.faceVertexUvs[ i ][ fi ].push( uv );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif ( j !== 0 ) geometry.faceVertexUvs[ i ][ fi + 1 ].push( uv );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceNormal ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tnormalIndex = faces[ offset ++ ] * 3;\\n\\n\\t\\t\\t\\t\\t\\t\\tfaceA.normal.set(\\n\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ++ ],\\n\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ++ ],\\n\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ]\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tfaceB.normal.copy( faceA.normal );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceVertexNormal ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( i = 0; i < 4; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tnormalIndex = faces[ offset ++ ] * 3;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tnormal = new Vector3(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ++ ],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ++ ],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ]\\n\\t\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( i !== 2 ) faceA.vertexNormals.push( normal );\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( i !== 0 ) faceB.vertexNormals.push( normal );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceColor ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tcolorIndex = faces[ offset ++ ];\\n\\t\\t\\t\\t\\t\\t\\thex = colors[ colorIndex ];\\n\\n\\t\\t\\t\\t\\t\\t\\tfaceA.color.setHex( hex );\\n\\t\\t\\t\\t\\t\\t\\tfaceB.color.setHex( hex );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceVertexColor ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( i = 0; i < 4; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcolorIndex = faces[ offset ++ ];\\n\\t\\t\\t\\t\\t\\t\\t\\thex = colors[ colorIndex ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( i !== 2 ) faceA.vertexColors.push( new Color( hex ) );\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( i !== 0 ) faceB.vertexColors.push( new Color( hex ) );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tgeometry.faces.push( faceA );\\n\\t\\t\\t\\t\\t\\tgeometry.faces.push( faceB );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tface = new Face3();\\n\\t\\t\\t\\t\\t\\tface.a = faces[ offset ++ ];\\n\\t\\t\\t\\t\\t\\tface.b = faces[ offset ++ ];\\n\\t\\t\\t\\t\\t\\tface.c = faces[ offset ++ ];\\n\\n\\t\\t\\t\\t\\t\\tif ( hasMaterial ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tmaterialIndex = faces[ offset ++ ];\\n\\t\\t\\t\\t\\t\\t\\tface.materialIndex = materialIndex;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t// to get face <=> uv index correspondence\\n\\n\\t\\t\\t\\t\\t\\tfi = geometry.faces.length;\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceVertexUv ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( i = 0; i < nUvLayers; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tuvLayer = json.uvs[ i ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgeometry.faceVertexUvs[ i ][ fi ] = [];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tfor ( j = 0; j < 3; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tuvIndex = faces[ offset ++ ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tu = uvLayer[ uvIndex * 2 ];\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tv = uvLayer[ uvIndex * 2 + 1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tuv = new Vector2( u, v );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgeometry.faceVertexUvs[ i ][ fi ].push( uv );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceNormal ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tnormalIndex = faces[ offset ++ ] * 3;\\n\\n\\t\\t\\t\\t\\t\\t\\tface.normal.set(\\n\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ++ ],\\n\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ++ ],\\n\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ]\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceVertexNormal ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( i = 0; i < 3; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tnormalIndex = faces[ offset ++ ] * 3;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tnormal = new Vector3(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ++ ],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ++ ],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ]\\n\\t\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tface.vertexNormals.push( normal );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceColor ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tcolorIndex = faces[ offset ++ ];\\n\\t\\t\\t\\t\\t\\t\\tface.color.setHex( colors[ colorIndex ] );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceVertexColor ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( i = 0; i < 3; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcolorIndex = faces[ offset ++ ];\\n\\t\\t\\t\\t\\t\\t\\t\\tface.vertexColors.push( new Color( colors[ colorIndex ] ) );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tgeometry.faces.push( face );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction parseSkin( json, geometry ) {\\n\\n\\t\\t\\t\\tvar influencesPerVertex = ( json.influencesPerVertex !== undefined ) ? json.influencesPerVertex : 2;\\n\\n\\t\\t\\t\\tif ( json.skinWeights ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, l = json.skinWeights.length; i < l; i += influencesPerVertex ) {\\n\\n\\t\\t\\t\\t\\t\\tvar x = json.skinWeights[ i ];\\n\\t\\t\\t\\t\\t\\tvar y = ( influencesPerVertex > 1 ) ? json.skinWeights[ i + 1 ] : 0;\\n\\t\\t\\t\\t\\t\\tvar z = ( influencesPerVertex > 2 ) ? json.skinWeights[ i + 2 ] : 0;\\n\\t\\t\\t\\t\\t\\tvar w = ( influencesPerVertex > 3 ) ? json.skinWeights[ i + 3 ] : 0;\\n\\n\\t\\t\\t\\t\\t\\tgeometry.skinWeights.push( new Vector4( x, y, z, w ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( json.skinIndices ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, l = json.skinIndices.length; i < l; i += influencesPerVertex ) {\\n\\n\\t\\t\\t\\t\\t\\tvar a = json.skinIndices[ i ];\\n\\t\\t\\t\\t\\t\\tvar b = ( influencesPerVertex > 1 ) ? json.skinIndices[ i + 1 ] : 0;\\n\\t\\t\\t\\t\\t\\tvar c = ( influencesPerVertex > 2 ) ? json.skinIndices[ i + 2 ] : 0;\\n\\t\\t\\t\\t\\t\\tvar d = ( influencesPerVertex > 3 ) ? json.skinIndices[ i + 3 ] : 0;\\n\\n\\t\\t\\t\\t\\t\\tgeometry.skinIndices.push( new Vector4( a, b, c, d ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometry.bones = json.bones;\\n\\n\\t\\t\\t\\tif ( geometry.bones && geometry.bones.length > 0 && ( geometry.skinWeights.length !== geometry.skinIndices.length || geometry.skinIndices.length !== geometry.vertices.length ) ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'When skinning, number of vertices (' + geometry.vertices.length + '), skinIndices (' +\\n\\t\\t\\t\\t\\t\\tgeometry.skinIndices.length + '), and skinWeights (' + geometry.skinWeights.length + ') should match.' );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction parseMorphing( json, geometry ) {\\n\\n\\t\\t\\t\\tvar scale = json.scale;\\n\\n\\t\\t\\t\\tif ( json.morphTargets !== undefined ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, l = json.morphTargets.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tgeometry.morphTargets[ i ] = {};\\n\\t\\t\\t\\t\\t\\tgeometry.morphTargets[ i ].name = json.morphTargets[ i ].name;\\n\\t\\t\\t\\t\\t\\tgeometry.morphTargets[ i ].vertices = [];\\n\\n\\t\\t\\t\\t\\t\\tvar dstVertices = geometry.morphTargets[ i ].vertices;\\n\\t\\t\\t\\t\\t\\tvar srcVertices = json.morphTargets[ i ].vertices;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var v = 0, vl = srcVertices.length; v < vl; v += 3 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar vertex = new Vector3();\\n\\t\\t\\t\\t\\t\\t\\tvertex.x = srcVertices[ v ] * scale;\\n\\t\\t\\t\\t\\t\\t\\tvertex.y = srcVertices[ v + 1 ] * scale;\\n\\t\\t\\t\\t\\t\\t\\tvertex.z = srcVertices[ v + 2 ] * scale;\\n\\n\\t\\t\\t\\t\\t\\t\\tdstVertices.push( vertex );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( json.morphColors !== undefined && json.morphColors.length > 0 ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.JSONLoader: \\\"morphColors\\\" no longer supported. Using them as face colors.' );\\n\\n\\t\\t\\t\\t\\tvar faces = geometry.faces;\\n\\t\\t\\t\\t\\tvar morphColors = json.morphColors[ 0 ].colors;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, l = faces.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tfaces[ i ].color.fromArray( morphColors, i * 3 );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction parseAnimations( json, geometry ) {\\n\\n\\t\\t\\t\\tvar outputAnimations = [];\\n\\n\\t\\t\\t\\t// parse old style Bone/Hierarchy animations\\n\\t\\t\\t\\tvar animations = [];\\n\\n\\t\\t\\t\\tif ( json.animation !== undefined ) {\\n\\n\\t\\t\\t\\t\\tanimations.push( json.animation );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( json.animations !== undefined ) {\\n\\n\\t\\t\\t\\t\\tif ( json.animations.length ) {\\n\\n\\t\\t\\t\\t\\t\\tanimations = animations.concat( json.animations );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tanimations.push( json.animations );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < animations.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar clip = AnimationClip.parseAnimation( animations[ i ], geometry.bones );\\n\\t\\t\\t\\t\\tif ( clip ) outputAnimations.push( clip );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// parse implicit morph animations\\n\\t\\t\\t\\tif ( geometry.morphTargets ) {\\n\\n\\t\\t\\t\\t\\t// TODO: Figure out what an appropraite FPS is for morph target animations -- defaulting to 10, but really it is completely arbitrary.\\n\\t\\t\\t\\t\\tvar morphAnimationClips = AnimationClip.CreateClipsFromMorphTargetSequences( geometry.morphTargets, 10 );\\n\\t\\t\\t\\t\\toutputAnimations = outputAnimations.concat( morphAnimationClips );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( outputAnimations.length > 0 ) geometry.animations = outputAnimations;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn function ( json, texturePath ) {\\n\\n\\t\\t\\t\\tif ( json.data !== undefined ) {\\n\\n\\t\\t\\t\\t\\t// Geometry 4.0 spec\\n\\t\\t\\t\\t\\tjson = json.data;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( json.scale !== undefined ) {\\n\\n\\t\\t\\t\\t\\tjson.scale = 1.0 / json.scale;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tjson.scale = 1.0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar geometry = new Geometry();\\n\\n\\t\\t\\t\\tparseModel( json, geometry );\\n\\t\\t\\t\\tparseSkin( json, geometry );\\n\\t\\t\\t\\tparseMorphing( json, geometry );\\n\\t\\t\\t\\tparseAnimations( json, geometry );\\n\\n\\t\\t\\t\\tgeometry.computeFaceNormals();\\n\\t\\t\\t\\tgeometry.computeBoundingSphere();\\n\\n\\t\\t\\t\\tif ( json.materials === undefined || json.materials.length === 0 ) {\\n\\n\\t\\t\\t\\t\\treturn { geometry: geometry };\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tvar materials = Loader.prototype.initMaterials( json.materials, texturePath, this.crossOrigin );\\n\\n\\t\\t\\t\\t\\treturn { geometry: geometry, materials: materials };\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )()\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction ObjectLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\t\\tthis.texturePath = '';\\n\\n\\t}\\n\\n\\tObject.assign( ObjectLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tif ( this.texturePath === '' ) {\\n\\n\\t\\t\\t\\tthis.texturePath = url.substring( 0, url.lastIndexOf( '/' ) + 1 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar loader = new FileLoader( scope.manager );\\n\\t\\t\\tloader.load( url, function ( text ) {\\n\\n\\t\\t\\t\\tvar json = null;\\n\\n\\t\\t\\t\\ttry {\\n\\n\\t\\t\\t\\t\\tjson = JSON.parse( text );\\n\\n\\t\\t\\t\\t} catch ( error ) {\\n\\n\\t\\t\\t\\t\\tif ( onError !== undefined ) onError( error );\\n\\n\\t\\t\\t\\t\\tconsole.error( 'THREE:ObjectLoader: Can\\\\'t parse ' + url + '.', error.message );\\n\\n\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar metadata = json.metadata;\\n\\n\\t\\t\\t\\tif ( metadata === undefined || metadata.type === undefined || metadata.type.toLowerCase() === 'geometry' ) {\\n\\n\\t\\t\\t\\t\\tconsole.error( 'THREE.ObjectLoader: Can\\\\'t load ' + url + '. Use THREE.JSONLoader instead.' );\\n\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tscope.parse( json, onLoad );\\n\\n\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t},\\n\\n\\t\\tsetTexturePath: function ( value ) {\\n\\n\\t\\t\\tthis.texturePath = value;\\n\\n\\t\\t},\\n\\n\\t\\tsetCrossOrigin: function ( value ) {\\n\\n\\t\\t\\tthis.crossOrigin = value;\\n\\n\\t\\t},\\n\\n\\t\\tparse: function ( json, onLoad ) {\\n\\n\\t\\t\\tvar shapes = this.parseShape( json.shapes );\\n\\t\\t\\tvar geometries = this.parseGeometries( json.geometries, shapes );\\n\\n\\t\\t\\tvar images = this.parseImages( json.images, function () {\\n\\n\\t\\t\\t\\tif ( onLoad !== undefined ) onLoad( object );\\n\\n\\t\\t\\t} );\\n\\n\\t\\t\\tvar textures = this.parseTextures( json.textures, images );\\n\\t\\t\\tvar materials = this.parseMaterials( json.materials, textures );\\n\\n\\t\\t\\tvar object = this.parseObject( json.object, geometries, materials );\\n\\n\\t\\t\\tif ( json.animations ) {\\n\\n\\t\\t\\t\\tobject.animations = this.parseAnimations( json.animations );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( json.images === undefined || json.images.length === 0 ) {\\n\\n\\t\\t\\t\\tif ( onLoad !== undefined ) onLoad( object );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn object;\\n\\n\\t\\t},\\n\\n\\t\\tparseShape: function ( json ) {\\n\\n\\t\\t\\tvar shapes = {};\\n\\n\\t\\t\\tif ( json !== undefined ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = json.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar shape = new Shape().fromJSON( json[ i ] );\\n\\n\\t\\t\\t\\t\\tshapes[ shape.uuid ] = shape;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn shapes;\\n\\n\\t\\t},\\n\\n\\t\\tparseGeometries: function ( json, shapes ) {\\n\\n\\t\\t\\tvar geometries = {};\\n\\n\\t\\t\\tif ( json !== undefined ) {\\n\\n\\t\\t\\t\\tvar geometryLoader = new JSONLoader();\\n\\t\\t\\t\\tvar bufferGeometryLoader = new BufferGeometryLoader();\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = json.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar geometry;\\n\\t\\t\\t\\t\\tvar data = json[ i ];\\n\\n\\t\\t\\t\\t\\tswitch ( data.type ) {\\n\\n\\t\\t\\t\\t\\t\\tcase 'PlaneGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'PlaneBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.width,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.height,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.widthSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.heightSegments\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'BoxGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'BoxBufferGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'CubeGeometry': // backwards compatible\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.width,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.height,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.depth,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.widthSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.heightSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.depthSegments\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'CircleGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'CircleBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.segments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaStart,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaLength\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'CylinderGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'CylinderBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radiusTop,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radiusBottom,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.height,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radialSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.heightSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.openEnded,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaStart,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaLength\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'ConeGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'ConeBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.height,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radialSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.heightSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.openEnded,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaStart,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaLength\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'SphereGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'SphereBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.widthSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.heightSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.phiStart,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.phiLength,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaStart,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaLength\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'DodecahedronGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'DodecahedronBufferGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'IcosahedronGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'IcosahedronBufferGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'OctahedronGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'OctahedronBufferGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'TetrahedronGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'TetrahedronBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.detail\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'RingGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'RingBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.innerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.outerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.phiSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaStart,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaLength\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'TorusGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'TorusBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.tube,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radialSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.tubularSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.arc\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'TorusKnotGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'TorusKnotBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.tube,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.tubularSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radialSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.p,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.q\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'LatheGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'LatheBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.points,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.segments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.phiStart,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.phiLength\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'PolyhedronGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'PolyhedronBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.vertices,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.indices,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.details\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'ShapeGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'ShapeBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tvar geometryShapes = [];\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var i = 0, l = data.shapes.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tvar shape = shapes[ data.shapes[ i ] ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgeometryShapes.push( shape );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tgeometryShapes,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.curveSegments\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'BufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = bufferGeometryLoader.parse( data );\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'Geometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = geometryLoader.parse( data, this.texturePath ).geometry;\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tdefault:\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.ObjectLoader: Unsupported geometry type \\\"' + data.type + '\\\"' );\\n\\n\\t\\t\\t\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tgeometry.uuid = data.uuid;\\n\\n\\t\\t\\t\\t\\tif ( data.name !== undefined ) geometry.name = data.name;\\n\\n\\t\\t\\t\\t\\tgeometries[ data.uuid ] = geometry;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn geometries;\\n\\n\\t\\t},\\n\\n\\t\\tparseMaterials: function ( json, textures ) {\\n\\n\\t\\t\\tvar materials = {};\\n\\n\\t\\t\\tif ( json !== undefined ) {\\n\\n\\t\\t\\t\\tvar loader = new MaterialLoader();\\n\\t\\t\\t\\tloader.setTextures( textures );\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = json.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar data = json[ i ];\\n\\n\\t\\t\\t\\t\\tif ( data.type === 'MultiMaterial' ) {\\n\\n\\t\\t\\t\\t\\t\\t// Deprecated\\n\\n\\t\\t\\t\\t\\t\\tvar array = [];\\n\\n\\t\\t\\t\\t\\t\\tfor ( var j = 0; j < data.materials.length; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tarray.push( loader.parse( data.materials[ j ] ) );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tmaterials[ data.uuid ] = array;\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tmaterials[ data.uuid ] = loader.parse( data );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn materials;\\n\\n\\t\\t},\\n\\n\\t\\tparseAnimations: function ( json ) {\\n\\n\\t\\t\\tvar animations = [];\\n\\n\\t\\t\\tfor ( var i = 0; i < json.length; i ++ ) {\\n\\n\\t\\t\\t\\tvar clip = AnimationClip.parse( json[ i ] );\\n\\n\\t\\t\\t\\tanimations.push( clip );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn animations;\\n\\n\\t\\t},\\n\\n\\t\\tparseImages: function ( json, onLoad ) {\\n\\n\\t\\t\\tvar scope = this;\\n\\t\\t\\tvar images = {};\\n\\n\\t\\t\\tfunction loadImage( url ) {\\n\\n\\t\\t\\t\\tscope.manager.itemStart( url );\\n\\n\\t\\t\\t\\treturn loader.load( url, function () {\\n\\n\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t\\t}, undefined, function () {\\n\\n\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\t\\t\\t\\t\\tscope.manager.itemError( url );\\n\\n\\t\\t\\t\\t} );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( json !== undefined && json.length > 0 ) {\\n\\n\\t\\t\\t\\tvar manager = new LoadingManager( onLoad );\\n\\n\\t\\t\\t\\tvar loader = new ImageLoader( manager );\\n\\t\\t\\t\\tloader.setCrossOrigin( this.crossOrigin );\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = json.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar image = json[ i ];\\n\\t\\t\\t\\t\\tvar path = /^(\\\\/\\\\/)|([a-z]+:(\\\\/\\\\/)?)/i.test( image.url ) ? image.url : scope.texturePath + image.url;\\n\\n\\t\\t\\t\\t\\timages[ image.uuid ] = loadImage( path );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn images;\\n\\n\\t\\t},\\n\\n\\t\\tparseTextures: function ( json, images ) {\\n\\n\\t\\t\\tfunction parseConstant( value, type ) {\\n\\n\\t\\t\\t\\tif ( typeof value === 'number' ) return value;\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.ObjectLoader.parseTexture: Constant should be in numeric form.', value );\\n\\n\\t\\t\\t\\treturn type[ value ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar textures = {};\\n\\n\\t\\t\\tif ( json !== undefined ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = json.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar data = json[ i ];\\n\\n\\t\\t\\t\\t\\tif ( data.image === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.ObjectLoader: No \\\"image\\\" specified for', data.uuid );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( images[ data.image ] === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.ObjectLoader: Undefined image', data.image );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tvar texture = new Texture( images[ data.image ] );\\n\\t\\t\\t\\t\\ttexture.needsUpdate = true;\\n\\n\\t\\t\\t\\t\\ttexture.uuid = data.uuid;\\n\\n\\t\\t\\t\\t\\tif ( data.name !== undefined ) texture.name = data.name;\\n\\n\\t\\t\\t\\t\\tif ( data.mapping !== undefined ) texture.mapping = parseConstant( data.mapping, TEXTURE_MAPPING );\\n\\n\\t\\t\\t\\t\\tif ( data.offset !== undefined ) texture.offset.fromArray( data.offset );\\n\\t\\t\\t\\t\\tif ( data.repeat !== undefined ) texture.repeat.fromArray( data.repeat );\\n\\t\\t\\t\\t\\tif ( data.center !== undefined ) texture.center.fromArray( data.center );\\n\\t\\t\\t\\t\\tif ( data.rotation !== undefined ) texture.rotation = data.rotation;\\n\\n\\t\\t\\t\\t\\tif ( data.wrap !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\ttexture.wrapS = parseConstant( data.wrap[ 0 ], TEXTURE_WRAPPING );\\n\\t\\t\\t\\t\\t\\ttexture.wrapT = parseConstant( data.wrap[ 1 ], TEXTURE_WRAPPING );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( data.minFilter !== undefined ) texture.minFilter = parseConstant( data.minFilter, TEXTURE_FILTER );\\n\\t\\t\\t\\t\\tif ( data.magFilter !== undefined ) texture.magFilter = parseConstant( data.magFilter, TEXTURE_FILTER );\\n\\t\\t\\t\\t\\tif ( data.anisotropy !== undefined ) texture.anisotropy = data.anisotropy;\\n\\n\\t\\t\\t\\t\\tif ( data.flipY !== undefined ) texture.flipY = data.flipY;\\n\\n\\t\\t\\t\\t\\ttextures[ data.uuid ] = texture;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn textures;\\n\\n\\t\\t},\\n\\n\\t\\tparseObject: function () {\\n\\n\\t\\t\\tvar matrix = new Matrix4();\\n\\n\\t\\t\\treturn function parseObject( data, geometries, materials ) {\\n\\n\\t\\t\\t\\tvar object;\\n\\n\\t\\t\\t\\tfunction getGeometry( name ) {\\n\\n\\t\\t\\t\\t\\tif ( geometries[ name ] === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.ObjectLoader: Undefined geometry', name );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\treturn geometries[ name ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfunction getMaterial( name ) {\\n\\n\\t\\t\\t\\t\\tif ( name === undefined ) return undefined;\\n\\n\\t\\t\\t\\t\\tif ( Array.isArray( name ) ) {\\n\\n\\t\\t\\t\\t\\t\\tvar array = [];\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, l = name.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar uuid = name[ i ];\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( materials[ uuid ] === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.ObjectLoader: Undefined material', uuid );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\tarray.push( materials[ uuid ] );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\treturn array;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( materials[ name ] === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.ObjectLoader: Undefined material', name );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\treturn materials[ name ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tswitch ( data.type ) {\\n\\n\\t\\t\\t\\t\\tcase 'Scene':\\n\\n\\t\\t\\t\\t\\t\\tobject = new Scene();\\n\\n\\t\\t\\t\\t\\t\\tif ( data.background !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( Number.isInteger( data.background ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tobject.background = new Color( data.background );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tif ( data.fog !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( data.fog.type === 'Fog' ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tobject.fog = new Fog( data.fog.color, data.fog.near, data.fog.far );\\n\\n\\t\\t\\t\\t\\t\\t\\t} else if ( data.fog.type === 'FogExp2' ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tobject.fog = new FogExp2( data.fog.color, data.fog.density );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'PerspectiveCamera':\\n\\n\\t\\t\\t\\t\\t\\tobject = new PerspectiveCamera( data.fov, data.aspect, data.near, data.far );\\n\\n\\t\\t\\t\\t\\t\\tif ( data.focus !== undefined ) object.focus = data.focus;\\n\\t\\t\\t\\t\\t\\tif ( data.zoom !== undefined ) object.zoom = data.zoom;\\n\\t\\t\\t\\t\\t\\tif ( data.filmGauge !== undefined ) object.filmGauge = data.filmGauge;\\n\\t\\t\\t\\t\\t\\tif ( data.filmOffset !== undefined ) object.filmOffset = data.filmOffset;\\n\\t\\t\\t\\t\\t\\tif ( data.view !== undefined ) object.view = Object.assign( {}, data.view );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'OrthographicCamera':\\n\\n\\t\\t\\t\\t\\t\\tobject = new OrthographicCamera( data.left, data.right, data.top, data.bottom, data.near, data.far );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'AmbientLight':\\n\\n\\t\\t\\t\\t\\t\\tobject = new AmbientLight( data.color, data.intensity );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'DirectionalLight':\\n\\n\\t\\t\\t\\t\\t\\tobject = new DirectionalLight( data.color, data.intensity );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'PointLight':\\n\\n\\t\\t\\t\\t\\t\\tobject = new PointLight( data.color, data.intensity, data.distance, data.decay );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'RectAreaLight':\\n\\n\\t\\t\\t\\t\\t\\tobject = new RectAreaLight( data.color, data.intensity, data.width, data.height );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'SpotLight':\\n\\n\\t\\t\\t\\t\\t\\tobject = new SpotLight( data.color, data.intensity, data.distance, data.angle, data.penumbra, data.decay );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'HemisphereLight':\\n\\n\\t\\t\\t\\t\\t\\tobject = new HemisphereLight( data.color, data.groundColor, data.intensity );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'SkinnedMesh':\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.ObjectLoader.parseObject() does not support SkinnedMesh yet.' );\\n\\n\\t\\t\\t\\t\\tcase 'Mesh':\\n\\n\\t\\t\\t\\t\\t\\tvar geometry = getGeometry( data.geometry );\\n\\t\\t\\t\\t\\t\\tvar material = getMaterial( data.material );\\n\\n\\t\\t\\t\\t\\t\\tif ( geometry.bones && geometry.bones.length > 0 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tobject = new SkinnedMesh( geometry, material );\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tobject = new Mesh( geometry, material );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'LOD':\\n\\n\\t\\t\\t\\t\\t\\tobject = new LOD();\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'Line':\\n\\n\\t\\t\\t\\t\\t\\tobject = new Line( getGeometry( data.geometry ), getMaterial( data.material ), data.mode );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'LineLoop':\\n\\n\\t\\t\\t\\t\\t\\tobject = new LineLoop( getGeometry( data.geometry ), getMaterial( data.material ) );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'LineSegments':\\n\\n\\t\\t\\t\\t\\t\\tobject = new LineSegments( getGeometry( data.geometry ), getMaterial( data.material ) );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'PointCloud':\\n\\t\\t\\t\\t\\tcase 'Points':\\n\\n\\t\\t\\t\\t\\t\\tobject = new Points( getGeometry( data.geometry ), getMaterial( data.material ) );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'Sprite':\\n\\n\\t\\t\\t\\t\\t\\tobject = new Sprite( getMaterial( data.material ) );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'Group':\\n\\n\\t\\t\\t\\t\\t\\tobject = new Group();\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tdefault:\\n\\n\\t\\t\\t\\t\\t\\tobject = new Object3D();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tobject.uuid = data.uuid;\\n\\n\\t\\t\\t\\tif ( data.name !== undefined ) object.name = data.name;\\n\\t\\t\\t\\tif ( data.matrix !== undefined ) {\\n\\n\\t\\t\\t\\t\\tmatrix.fromArray( data.matrix );\\n\\t\\t\\t\\t\\tmatrix.decompose( object.position, object.quaternion, object.scale );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tif ( data.position !== undefined ) object.position.fromArray( data.position );\\n\\t\\t\\t\\t\\tif ( data.rotation !== undefined ) object.rotation.fromArray( data.rotation );\\n\\t\\t\\t\\t\\tif ( data.quaternion !== undefined ) object.quaternion.fromArray( data.quaternion );\\n\\t\\t\\t\\t\\tif ( data.scale !== undefined ) object.scale.fromArray( data.scale );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( data.castShadow !== undefined ) object.castShadow = data.castShadow;\\n\\t\\t\\t\\tif ( data.receiveShadow !== undefined ) object.receiveShadow = data.receiveShadow;\\n\\n\\t\\t\\t\\tif ( data.shadow ) {\\n\\n\\t\\t\\t\\t\\tif ( data.shadow.bias !== undefined ) object.shadow.bias = data.shadow.bias;\\n\\t\\t\\t\\t\\tif ( data.shadow.radius !== undefined ) object.shadow.radius = data.shadow.radius;\\n\\t\\t\\t\\t\\tif ( data.shadow.mapSize !== undefined ) object.shadow.mapSize.fromArray( data.shadow.mapSize );\\n\\t\\t\\t\\t\\tif ( data.shadow.camera !== undefined ) object.shadow.camera = this.parseObject( data.shadow.camera );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( data.visible !== undefined ) object.visible = data.visible;\\n\\t\\t\\t\\tif ( data.userData !== undefined ) object.userData = data.userData;\\n\\n\\t\\t\\t\\tif ( data.children !== undefined ) {\\n\\n\\t\\t\\t\\t\\tvar children = data.children;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < children.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tobject.add( this.parseObject( children[ i ], geometries, materials ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( data.type === 'LOD' ) {\\n\\n\\t\\t\\t\\t\\tvar levels = data.levels;\\n\\n\\t\\t\\t\\t\\tfor ( var l = 0; l < levels.length; l ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar level = levels[ l ];\\n\\t\\t\\t\\t\\t\\tvar child = object.getObjectByProperty( 'uuid', level.object );\\n\\n\\t\\t\\t\\t\\t\\tif ( child !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tobject.addLevel( child, level.distance );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn object;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}()\\n\\n\\t} );\\n\\n\\tvar TEXTURE_MAPPING = {\\n\\t\\tUVMapping: UVMapping,\\n\\t\\tCubeReflectionMapping: CubeReflectionMapping,\\n\\t\\tCubeRefractionMapping: CubeRefractionMapping,\\n\\t\\tEquirectangularReflectionMapping: EquirectangularReflectionMapping,\\n\\t\\tEquirectangularRefractionMapping: EquirectangularRefractionMapping,\\n\\t\\tSphericalReflectionMapping: SphericalReflectionMapping,\\n\\t\\tCubeUVReflectionMapping: CubeUVReflectionMapping,\\n\\t\\tCubeUVRefractionMapping: CubeUVRefractionMapping\\n\\t};\\n\\n\\tvar TEXTURE_WRAPPING = {\\n\\t\\tRepeatWrapping: RepeatWrapping,\\n\\t\\tClampToEdgeWrapping: ClampToEdgeWrapping,\\n\\t\\tMirroredRepeatWrapping: MirroredRepeatWrapping\\n\\t};\\n\\n\\tvar TEXTURE_FILTER = {\\n\\t\\tNearestFilter: NearestFilter,\\n\\t\\tNearestMipMapNearestFilter: NearestMipMapNearestFilter,\\n\\t\\tNearestMipMapLinearFilter: NearestMipMapLinearFilter,\\n\\t\\tLinearFilter: LinearFilter,\\n\\t\\tLinearMipMapNearestFilter: LinearMipMapNearestFilter,\\n\\t\\tLinearMipMapLinearFilter: LinearMipMapLinearFilter\\n\\t};\\n\\n\\t/**\\n\\t * @author thespite / http://clicktorelease.com/\\n\\t */\\n\\n\\tfunction ImageBitmapLoader( manager ) {\\n\\n\\t\\tif ( typeof createImageBitmap === 'undefined' ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.ImageBitmapLoader: createImageBitmap() not supported.' );\\n\\n\\t\\t}\\n\\n\\t\\tif ( typeof fetch === 'undefined' ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.ImageBitmapLoader: fetch() not supported.' );\\n\\n\\t\\t}\\n\\n\\t\\tthis.manager = manager !== undefined ? manager : DefaultLoadingManager;\\n\\t\\tthis.options = undefined;\\n\\n\\t}\\n\\n\\tImageBitmapLoader.prototype = {\\n\\n\\t\\tconstructor: ImageBitmapLoader,\\n\\n\\t\\tsetOptions: function setOptions( options ) {\\n\\n\\t\\t\\tthis.options = options;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tload: function load( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tif ( url === undefined ) url = '';\\n\\n\\t\\t\\tif ( this.path !== undefined ) url = this.path + url;\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar cached = Cache.get( url );\\n\\n\\t\\t\\tif ( cached !== undefined ) {\\n\\n\\t\\t\\t\\tscope.manager.itemStart( url );\\n\\n\\t\\t\\t\\tsetTimeout( function () {\\n\\n\\t\\t\\t\\t\\tif ( onLoad ) onLoad( cached );\\n\\n\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t\\t}, 0 );\\n\\n\\t\\t\\t\\treturn cached;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfetch( url ).then( function ( res ) {\\n\\n\\t\\t\\t\\treturn res.blob();\\n\\n\\t\\t\\t} ).then( function ( blob ) {\\n\\n\\t\\t\\t\\treturn createImageBitmap( blob, scope.options );\\n\\n\\t\\t\\t} ).then( function ( imageBitmap ) {\\n\\n\\t\\t\\t\\tCache.add( url, imageBitmap );\\n\\n\\t\\t\\t\\tif ( onLoad ) onLoad( imageBitmap );\\n\\n\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t} ).catch( function ( e ) {\\n\\n\\t\\t\\t\\tif ( onError ) onError( e );\\n\\n\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\t\\t\\t\\tscope.manager.itemError( url );\\n\\n\\t\\t\\t} );\\n\\n\\t\\t},\\n\\n\\t\\tsetCrossOrigin: function ( /* value */ ) {\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetPath: function ( value ) {\\n\\n\\t\\t\\tthis.path = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t * minimal class for proxing functions to Path. Replaces old \\\"extractSubpaths()\\\"\\n\\t **/\\n\\n\\tfunction ShapePath() {\\n\\n\\t\\tthis.type = 'ShapePath';\\n\\n\\t\\tthis.subPaths = [];\\n\\t\\tthis.currentPath = null;\\n\\n\\t}\\n\\n\\tObject.assign( ShapePath.prototype, {\\n\\n\\t\\tmoveTo: function ( x, y ) {\\n\\n\\t\\t\\tthis.currentPath = new Path();\\n\\t\\t\\tthis.subPaths.push( this.currentPath );\\n\\t\\t\\tthis.currentPath.moveTo( x, y );\\n\\n\\t\\t},\\n\\n\\t\\tlineTo: function ( x, y ) {\\n\\n\\t\\t\\tthis.currentPath.lineTo( x, y );\\n\\n\\t\\t},\\n\\n\\t\\tquadraticCurveTo: function ( aCPx, aCPy, aX, aY ) {\\n\\n\\t\\t\\tthis.currentPath.quadraticCurveTo( aCPx, aCPy, aX, aY );\\n\\n\\t\\t},\\n\\n\\t\\tbezierCurveTo: function ( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY ) {\\n\\n\\t\\t\\tthis.currentPath.bezierCurveTo( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY );\\n\\n\\t\\t},\\n\\n\\t\\tsplineThru: function ( pts ) {\\n\\n\\t\\t\\tthis.currentPath.splineThru( pts );\\n\\n\\t\\t},\\n\\n\\t\\ttoShapes: function ( isCCW, noHoles ) {\\n\\n\\t\\t\\tfunction toShapesNoHoles( inSubpaths ) {\\n\\n\\t\\t\\t\\tvar shapes = [];\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = inSubpaths.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar tmpPath = inSubpaths[ i ];\\n\\n\\t\\t\\t\\t\\tvar tmpShape = new Shape();\\n\\t\\t\\t\\t\\ttmpShape.curves = tmpPath.curves;\\n\\n\\t\\t\\t\\t\\tshapes.push( tmpShape );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn shapes;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction isPointInsidePolygon( inPt, inPolygon ) {\\n\\n\\t\\t\\t\\tvar polyLen = inPolygon.length;\\n\\n\\t\\t\\t\\t// inPt on polygon contour => immediate success or\\n\\t\\t\\t\\t// toggling of inside/outside at every single! intersection point of an edge\\n\\t\\t\\t\\t// with the horizontal line through inPt, left of inPt\\n\\t\\t\\t\\t// not counting lowerY endpoints of edges and whole edges on that line\\n\\t\\t\\t\\tvar inside = false;\\n\\t\\t\\t\\tfor ( var p = polyLen - 1, q = 0; q < polyLen; p = q ++ ) {\\n\\n\\t\\t\\t\\t\\tvar edgeLowPt = inPolygon[ p ];\\n\\t\\t\\t\\t\\tvar edgeHighPt = inPolygon[ q ];\\n\\n\\t\\t\\t\\t\\tvar edgeDx = edgeHighPt.x - edgeLowPt.x;\\n\\t\\t\\t\\t\\tvar edgeDy = edgeHighPt.y - edgeLowPt.y;\\n\\n\\t\\t\\t\\t\\tif ( Math.abs( edgeDy ) > Number.EPSILON ) {\\n\\n\\t\\t\\t\\t\\t\\t// not parallel\\n\\t\\t\\t\\t\\t\\tif ( edgeDy < 0 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tedgeLowPt = inPolygon[ q ]; edgeDx = - edgeDx;\\n\\t\\t\\t\\t\\t\\t\\tedgeHighPt = inPolygon[ p ]; edgeDy = - edgeDy;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\tif ( ( inPt.y < edgeLowPt.y ) || ( inPt.y > edgeHighPt.y ) ) \\t\\tcontinue;\\n\\n\\t\\t\\t\\t\\t\\tif ( inPt.y === edgeLowPt.y ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( inPt.x === edgeLowPt.x )\\t\\treturn\\ttrue;\\t\\t// inPt is on contour ?\\n\\t\\t\\t\\t\\t\\t\\t// continue;\\t\\t\\t\\t// no intersection or edgeLowPt => doesn't count !!!\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar perpEdge = edgeDy * ( inPt.x - edgeLowPt.x ) - edgeDx * ( inPt.y - edgeLowPt.y );\\n\\t\\t\\t\\t\\t\\t\\tif ( perpEdge === 0 )\\t\\t\\t\\treturn\\ttrue;\\t\\t// inPt is on contour ?\\n\\t\\t\\t\\t\\t\\t\\tif ( perpEdge < 0 ) \\t\\t\\t\\tcontinue;\\n\\t\\t\\t\\t\\t\\t\\tinside = ! inside;\\t\\t// true intersection left of inPt\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t// parallel or collinear\\n\\t\\t\\t\\t\\t\\tif ( inPt.y !== edgeLowPt.y ) \\t\\tcontinue;\\t\\t\\t// parallel\\n\\t\\t\\t\\t\\t\\t// edge lies on the same horizontal line as inPt\\n\\t\\t\\t\\t\\t\\tif ( ( ( edgeHighPt.x <= inPt.x ) && ( inPt.x <= edgeLowPt.x ) ) ||\\n\\t\\t\\t\\t\\t\\t\\t ( ( edgeLowPt.x <= inPt.x ) && ( inPt.x <= edgeHighPt.x ) ) )\\t\\treturn\\ttrue;\\t// inPt: Point on contour !\\n\\t\\t\\t\\t\\t\\t// continue;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn\\tinside;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar isClockWise = ShapeUtils.isClockWise;\\n\\n\\t\\t\\tvar subPaths = this.subPaths;\\n\\t\\t\\tif ( subPaths.length === 0 ) return [];\\n\\n\\t\\t\\tif ( noHoles === true )\\treturn\\ttoShapesNoHoles( subPaths );\\n\\n\\n\\t\\t\\tvar solid, tmpPath, tmpShape, shapes = [];\\n\\n\\t\\t\\tif ( subPaths.length === 1 ) {\\n\\n\\t\\t\\t\\ttmpPath = subPaths[ 0 ];\\n\\t\\t\\t\\ttmpShape = new Shape();\\n\\t\\t\\t\\ttmpShape.curves = tmpPath.curves;\\n\\t\\t\\t\\tshapes.push( tmpShape );\\n\\t\\t\\t\\treturn shapes;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar holesFirst = ! isClockWise( subPaths[ 0 ].getPoints() );\\n\\t\\t\\tholesFirst = isCCW ? ! holesFirst : holesFirst;\\n\\n\\t\\t\\t// console.log(\\\"Holes first\\\", holesFirst);\\n\\n\\t\\t\\tvar betterShapeHoles = [];\\n\\t\\t\\tvar newShapes = [];\\n\\t\\t\\tvar newShapeHoles = [];\\n\\t\\t\\tvar mainIdx = 0;\\n\\t\\t\\tvar tmpPoints;\\n\\n\\t\\t\\tnewShapes[ mainIdx ] = undefined;\\n\\t\\t\\tnewShapeHoles[ mainIdx ] = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = subPaths.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\ttmpPath = subPaths[ i ];\\n\\t\\t\\t\\ttmpPoints = tmpPath.getPoints();\\n\\t\\t\\t\\tsolid = isClockWise( tmpPoints );\\n\\t\\t\\t\\tsolid = isCCW ? ! solid : solid;\\n\\n\\t\\t\\t\\tif ( solid ) {\\n\\n\\t\\t\\t\\t\\tif ( ( ! holesFirst ) && ( newShapes[ mainIdx ] ) )\\tmainIdx ++;\\n\\n\\t\\t\\t\\t\\tnewShapes[ mainIdx ] = { s: new Shape(), p: tmpPoints };\\n\\t\\t\\t\\t\\tnewShapes[ mainIdx ].s.curves = tmpPath.curves;\\n\\n\\t\\t\\t\\t\\tif ( holesFirst )\\tmainIdx ++;\\n\\t\\t\\t\\t\\tnewShapeHoles[ mainIdx ] = [];\\n\\n\\t\\t\\t\\t\\t//console.log('cw', i);\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tnewShapeHoles[ mainIdx ].push( { h: tmpPath, p: tmpPoints[ 0 ] } );\\n\\n\\t\\t\\t\\t\\t//console.log('ccw', i);\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// only Holes? -> probably all Shapes with wrong orientation\\n\\t\\t\\tif ( ! newShapes[ 0 ] )\\treturn\\ttoShapesNoHoles( subPaths );\\n\\n\\n\\t\\t\\tif ( newShapes.length > 1 ) {\\n\\n\\t\\t\\t\\tvar ambiguous = false;\\n\\t\\t\\t\\tvar toChange = [];\\n\\n\\t\\t\\t\\tfor ( var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) {\\n\\n\\t\\t\\t\\t\\tbetterShapeHoles[ sIdx ] = [];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfor ( var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) {\\n\\n\\t\\t\\t\\t\\tvar sho = newShapeHoles[ sIdx ];\\n\\n\\t\\t\\t\\t\\tfor ( var hIdx = 0; hIdx < sho.length; hIdx ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar ho = sho[ hIdx ];\\n\\t\\t\\t\\t\\t\\tvar hole_unassigned = true;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var s2Idx = 0; s2Idx < newShapes.length; s2Idx ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( isPointInsidePolygon( ho.p, newShapes[ s2Idx ].p ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( sIdx !== s2Idx )\\ttoChange.push( { froms: sIdx, tos: s2Idx, hole: hIdx } );\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( hole_unassigned ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\thole_unassigned = false;\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbetterShapeHoles[ s2Idx ].push( ho );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tambiguous = true;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\tif ( hole_unassigned ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tbetterShapeHoles[ sIdx ].push( ho );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\t// console.log(\\\"ambiguous: \\\", ambiguous);\\n\\t\\t\\t\\tif ( toChange.length > 0 ) {\\n\\n\\t\\t\\t\\t\\t// console.log(\\\"to change: \\\", toChange);\\n\\t\\t\\t\\t\\tif ( ! ambiguous )\\tnewShapeHoles = betterShapeHoles;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar tmpHoles;\\n\\n\\t\\t\\tfor ( var i = 0, il = newShapes.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\ttmpShape = newShapes[ i ].s;\\n\\t\\t\\t\\tshapes.push( tmpShape );\\n\\t\\t\\t\\ttmpHoles = newShapeHoles[ i ];\\n\\n\\t\\t\\t\\tfor ( var j = 0, jl = tmpHoles.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\ttmpShape.holes.push( tmpHoles[ j ].h );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//console.log(\\\"shape\\\", shapes);\\n\\n\\t\\t\\treturn shapes;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Font( data ) {\\n\\n\\t\\tthis.type = 'Font';\\n\\n\\t\\tthis.data = data;\\n\\n\\t}\\n\\n\\tObject.assign( Font.prototype, {\\n\\n\\t\\tisFont: true,\\n\\n\\t\\tgenerateShapes: function ( text, size, divisions ) {\\n\\n\\t\\t\\tfunction createPaths( text ) {\\n\\n\\t\\t\\t\\tvar chars = String( text ).split( '' );\\n\\t\\t\\t\\tvar scale = size / data.resolution;\\n\\t\\t\\t\\tvar line_height = ( data.boundingBox.yMax - data.boundingBox.yMin + data.underlineThickness ) * scale;\\n\\n\\t\\t\\t\\tvar offsetX = 0, offsetY = 0;\\n\\n\\t\\t\\t\\tvar paths = [];\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < chars.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar char = chars[ i ];\\n\\n\\t\\t\\t\\t\\tif ( char === '\\\\n' ) {\\n\\n\\t\\t\\t\\t\\t\\toffsetX = 0;\\n\\t\\t\\t\\t\\t\\toffsetY -= line_height;\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tvar ret = createPath( char, scale, offsetX, offsetY );\\n\\t\\t\\t\\t\\t\\toffsetX += ret.offsetX;\\n\\t\\t\\t\\t\\t\\tpaths.push( ret.path );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn paths;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction createPath( c, scale, offsetX, offsetY ) {\\n\\n\\t\\t\\t\\tvar glyph = data.glyphs[ c ] || data.glyphs[ '?' ];\\n\\n\\t\\t\\t\\tif ( ! glyph ) return;\\n\\n\\t\\t\\t\\tvar path = new ShapePath();\\n\\n\\t\\t\\t\\tvar pts = [];\\n\\t\\t\\t\\tvar x, y, cpx, cpy, cpx0, cpy0, cpx1, cpy1, cpx2, cpy2, laste;\\n\\n\\t\\t\\t\\tif ( glyph.o ) {\\n\\n\\t\\t\\t\\t\\tvar outline = glyph._cachedOutline || ( glyph._cachedOutline = glyph.o.split( ' ' ) );\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, l = outline.length; i < l; ) {\\n\\n\\t\\t\\t\\t\\t\\tvar action = outline[ i ++ ];\\n\\n\\t\\t\\t\\t\\t\\tswitch ( action ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tcase 'm': // moveTo\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tx = outline[ i ++ ] * scale + offsetX;\\n\\t\\t\\t\\t\\t\\t\\t\\ty = outline[ i ++ ] * scale + offsetY;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tpath.moveTo( x, y );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\tcase 'l': // lineTo\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tx = outline[ i ++ ] * scale + offsetX;\\n\\t\\t\\t\\t\\t\\t\\t\\ty = outline[ i ++ ] * scale + offsetY;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tpath.lineTo( x, y );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\tcase 'q': // quadraticCurveTo\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcpx = outline[ i ++ ] * scale + offsetX;\\n\\t\\t\\t\\t\\t\\t\\t\\tcpy = outline[ i ++ ] * scale + offsetY;\\n\\t\\t\\t\\t\\t\\t\\t\\tcpx1 = outline[ i ++ ] * scale + offsetX;\\n\\t\\t\\t\\t\\t\\t\\t\\tcpy1 = outline[ i ++ ] * scale + offsetY;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tpath.quadraticCurveTo( cpx1, cpy1, cpx, cpy );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tlaste = pts[ pts.length - 1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( laste ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcpx0 = laste.x;\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcpy0 = laste.y;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\tcase 'b': // bezierCurveTo\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcpx = outline[ i ++ ] * scale + offsetX;\\n\\t\\t\\t\\t\\t\\t\\t\\tcpy = outline[ i ++ ] * scale + offsetY;\\n\\t\\t\\t\\t\\t\\t\\t\\tcpx1 = outline[ i ++ ] * scale + offsetX;\\n\\t\\t\\t\\t\\t\\t\\t\\tcpy1 = outline[ i ++ ] * scale + offsetY;\\n\\t\\t\\t\\t\\t\\t\\t\\tcpx2 = outline[ i ++ ] * scale + offsetX;\\n\\t\\t\\t\\t\\t\\t\\t\\tcpy2 = outline[ i ++ ] * scale + offsetY;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tpath.bezierCurveTo( cpx1, cpy1, cpx2, cpy2, cpx, cpy );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tlaste = pts[ pts.length - 1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( laste ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcpx0 = laste.x;\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcpy0 = laste.y;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn { offsetX: glyph.ha * scale, path: path };\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tif ( size === undefined ) size = 100;\\n\\t\\t\\tif ( divisions === undefined ) divisions = 4;\\n\\n\\t\\t\\tvar data = this.data;\\n\\n\\t\\t\\tvar paths = createPaths( text );\\n\\t\\t\\tvar shapes = [];\\n\\n\\t\\t\\tfor ( var p = 0, pl = paths.length; p < pl; p ++ ) {\\n\\n\\t\\t\\t\\tArray.prototype.push.apply( shapes, paths[ p ].toShapes() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn shapes;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction FontLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t}\\n\\n\\tObject.assign( FontLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar loader = new FileLoader( this.manager );\\n\\t\\t\\tloader.setPath( this.path );\\n\\t\\t\\tloader.load( url, function ( text ) {\\n\\n\\t\\t\\t\\tvar json;\\n\\n\\t\\t\\t\\ttry {\\n\\n\\t\\t\\t\\t\\tjson = JSON.parse( text );\\n\\n\\t\\t\\t\\t} catch ( e ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.FontLoader: typeface.js support is being deprecated. Use typeface.json instead.' );\\n\\t\\t\\t\\t\\tjson = JSON.parse( text.substring( 65, text.length - 2 ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar font = scope.parse( json );\\n\\n\\t\\t\\t\\tif ( onLoad ) onLoad( font );\\n\\n\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t},\\n\\n\\t\\tparse: function ( json ) {\\n\\n\\t\\t\\treturn new Font( json );\\n\\n\\t\\t},\\n\\n\\t\\tsetPath: function ( value ) {\\n\\n\\t\\t\\tthis.path = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tvar context;\\n\\n\\tvar AudioContext = {\\n\\n\\t\\tgetContext: function () {\\n\\n\\t\\t\\tif ( context === undefined ) {\\n\\n\\t\\t\\t\\tcontext = new ( window.AudioContext || window.webkitAudioContext )();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn context;\\n\\n\\t\\t},\\n\\n\\t\\tsetContext: function ( value ) {\\n\\n\\t\\t\\tcontext = value;\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author Reece Aaron Lecrivain / http://reecenotes.com/\\n\\t */\\n\\n\\tfunction AudioLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t}\\n\\n\\tObject.assign( AudioLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar loader = new FileLoader( this.manager );\\n\\t\\t\\tloader.setResponseType( 'arraybuffer' );\\n\\t\\t\\tloader.load( url, function ( buffer ) {\\n\\n\\t\\t\\t\\tvar context = AudioContext.getContext();\\n\\n\\t\\t\\t\\tcontext.decodeAudioData( buffer, function ( audioBuffer ) {\\n\\n\\t\\t\\t\\t\\tonLoad( audioBuffer );\\n\\n\\t\\t\\t\\t} );\\n\\n\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction StereoCamera() {\\n\\n\\t\\tthis.type = 'StereoCamera';\\n\\n\\t\\tthis.aspect = 1;\\n\\n\\t\\tthis.eyeSep = 0.064;\\n\\n\\t\\tthis.cameraL = new PerspectiveCamera();\\n\\t\\tthis.cameraL.layers.enable( 1 );\\n\\t\\tthis.cameraL.matrixAutoUpdate = false;\\n\\n\\t\\tthis.cameraR = new PerspectiveCamera();\\n\\t\\tthis.cameraR.layers.enable( 2 );\\n\\t\\tthis.cameraR.matrixAutoUpdate = false;\\n\\n\\t}\\n\\n\\tObject.assign( StereoCamera.prototype, {\\n\\n\\t\\tupdate: ( function () {\\n\\n\\t\\t\\tvar instance, focus, fov, aspect, near, far, zoom, eyeSep;\\n\\n\\t\\t\\tvar eyeRight = new Matrix4();\\n\\t\\t\\tvar eyeLeft = new Matrix4();\\n\\n\\t\\t\\treturn function update( camera ) {\\n\\n\\t\\t\\t\\tvar needsUpdate = instance !== this || focus !== camera.focus || fov !== camera.fov ||\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\taspect !== camera.aspect * this.aspect || near !== camera.near ||\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfar !== camera.far || zoom !== camera.zoom || eyeSep !== this.eyeSep;\\n\\n\\t\\t\\t\\tif ( needsUpdate ) {\\n\\n\\t\\t\\t\\t\\tinstance = this;\\n\\t\\t\\t\\t\\tfocus = camera.focus;\\n\\t\\t\\t\\t\\tfov = camera.fov;\\n\\t\\t\\t\\t\\taspect = camera.aspect * this.aspect;\\n\\t\\t\\t\\t\\tnear = camera.near;\\n\\t\\t\\t\\t\\tfar = camera.far;\\n\\t\\t\\t\\t\\tzoom = camera.zoom;\\n\\n\\t\\t\\t\\t\\t// Off-axis stereoscopic effect based on\\n\\t\\t\\t\\t\\t// http://paulbourke.net/stereographics/stereorender/\\n\\n\\t\\t\\t\\t\\tvar projectionMatrix = camera.projectionMatrix.clone();\\n\\t\\t\\t\\t\\teyeSep = this.eyeSep / 2;\\n\\t\\t\\t\\t\\tvar eyeSepOnProjection = eyeSep * near / focus;\\n\\t\\t\\t\\t\\tvar ymax = ( near * Math.tan( _Math.DEG2RAD * fov * 0.5 ) ) / zoom;\\n\\t\\t\\t\\t\\tvar xmin, xmax;\\n\\n\\t\\t\\t\\t\\t// translate xOffset\\n\\n\\t\\t\\t\\t\\teyeLeft.elements[ 12 ] = - eyeSep;\\n\\t\\t\\t\\t\\teyeRight.elements[ 12 ] = eyeSep;\\n\\n\\t\\t\\t\\t\\t// for left eye\\n\\n\\t\\t\\t\\t\\txmin = - ymax * aspect + eyeSepOnProjection;\\n\\t\\t\\t\\t\\txmax = ymax * aspect + eyeSepOnProjection;\\n\\n\\t\\t\\t\\t\\tprojectionMatrix.elements[ 0 ] = 2 * near / ( xmax - xmin );\\n\\t\\t\\t\\t\\tprojectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin );\\n\\n\\t\\t\\t\\t\\tthis.cameraL.projectionMatrix.copy( projectionMatrix );\\n\\n\\t\\t\\t\\t\\t// for right eye\\n\\n\\t\\t\\t\\t\\txmin = - ymax * aspect - eyeSepOnProjection;\\n\\t\\t\\t\\t\\txmax = ymax * aspect - eyeSepOnProjection;\\n\\n\\t\\t\\t\\t\\tprojectionMatrix.elements[ 0 ] = 2 * near / ( xmax - xmin );\\n\\t\\t\\t\\t\\tprojectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin );\\n\\n\\t\\t\\t\\t\\tthis.cameraR.projectionMatrix.copy( projectionMatrix );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.cameraL.matrixWorld.copy( camera.matrixWorld ).multiply( eyeLeft );\\n\\t\\t\\t\\tthis.cameraR.matrixWorld.copy( camera.matrixWorld ).multiply( eyeRight );\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )()\\n\\n\\t} );\\n\\n\\t/**\\n\\t * Camera for rendering cube maps\\n\\t *\\t- renders scene into axis-aligned cube\\n\\t *\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction CubeCamera( near, far, cubeResolution ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'CubeCamera';\\n\\n\\t\\tvar fov = 90, aspect = 1;\\n\\n\\t\\tvar cameraPX = new PerspectiveCamera( fov, aspect, near, far );\\n\\t\\tcameraPX.up.set( 0, - 1, 0 );\\n\\t\\tcameraPX.lookAt( new Vector3( 1, 0, 0 ) );\\n\\t\\tthis.add( cameraPX );\\n\\n\\t\\tvar cameraNX = new PerspectiveCamera( fov, aspect, near, far );\\n\\t\\tcameraNX.up.set( 0, - 1, 0 );\\n\\t\\tcameraNX.lookAt( new Vector3( - 1, 0, 0 ) );\\n\\t\\tthis.add( cameraNX );\\n\\n\\t\\tvar cameraPY = new PerspectiveCamera( fov, aspect, near, far );\\n\\t\\tcameraPY.up.set( 0, 0, 1 );\\n\\t\\tcameraPY.lookAt( new Vector3( 0, 1, 0 ) );\\n\\t\\tthis.add( cameraPY );\\n\\n\\t\\tvar cameraNY = new PerspectiveCamera( fov, aspect, near, far );\\n\\t\\tcameraNY.up.set( 0, 0, - 1 );\\n\\t\\tcameraNY.lookAt( new Vector3( 0, - 1, 0 ) );\\n\\t\\tthis.add( cameraNY );\\n\\n\\t\\tvar cameraPZ = new PerspectiveCamera( fov, aspect, near, far );\\n\\t\\tcameraPZ.up.set( 0, - 1, 0 );\\n\\t\\tcameraPZ.lookAt( new Vector3( 0, 0, 1 ) );\\n\\t\\tthis.add( cameraPZ );\\n\\n\\t\\tvar cameraNZ = new PerspectiveCamera( fov, aspect, near, far );\\n\\t\\tcameraNZ.up.set( 0, - 1, 0 );\\n\\t\\tcameraNZ.lookAt( new Vector3( 0, 0, - 1 ) );\\n\\t\\tthis.add( cameraNZ );\\n\\n\\t\\tvar options = { format: RGBFormat, magFilter: LinearFilter, minFilter: LinearFilter };\\n\\n\\t\\tthis.renderTarget = new WebGLRenderTargetCube( cubeResolution, cubeResolution, options );\\n\\t\\tthis.renderTarget.texture.name = \\\"CubeCamera\\\";\\n\\n\\t\\tthis.update = function ( renderer, scene ) {\\n\\n\\t\\t\\tif ( this.parent === null ) this.updateMatrixWorld();\\n\\n\\t\\t\\tvar renderTarget = this.renderTarget;\\n\\t\\t\\tvar generateMipmaps = renderTarget.texture.generateMipmaps;\\n\\n\\t\\t\\trenderTarget.texture.generateMipmaps = false;\\n\\n\\t\\t\\trenderTarget.activeCubeFace = 0;\\n\\t\\t\\trenderer.render( scene, cameraPX, renderTarget );\\n\\n\\t\\t\\trenderTarget.activeCubeFace = 1;\\n\\t\\t\\trenderer.render( scene, cameraNX, renderTarget );\\n\\n\\t\\t\\trenderTarget.activeCubeFace = 2;\\n\\t\\t\\trenderer.render( scene, cameraPY, renderTarget );\\n\\n\\t\\t\\trenderTarget.activeCubeFace = 3;\\n\\t\\t\\trenderer.render( scene, cameraNY, renderTarget );\\n\\n\\t\\t\\trenderTarget.activeCubeFace = 4;\\n\\t\\t\\trenderer.render( scene, cameraPZ, renderTarget );\\n\\n\\t\\t\\trenderTarget.texture.generateMipmaps = generateMipmaps;\\n\\n\\t\\t\\trenderTarget.activeCubeFace = 5;\\n\\t\\t\\trenderer.render( scene, cameraNZ, renderTarget );\\n\\n\\t\\t\\trenderer.setRenderTarget( null );\\n\\n\\t\\t};\\n\\n\\t\\tthis.clear = function ( renderer, color, depth, stencil ) {\\n\\n\\t\\t\\tvar renderTarget = this.renderTarget;\\n\\n\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\trenderTarget.activeCubeFace = i;\\n\\t\\t\\t\\trenderer.setRenderTarget( renderTarget );\\n\\n\\t\\t\\t\\trenderer.clear( color, depth, stencil );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\trenderer.setRenderTarget( null );\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\tCubeCamera.prototype = Object.create( Object3D.prototype );\\n\\tCubeCamera.prototype.constructor = CubeCamera;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction AudioListener() {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'AudioListener';\\n\\n\\t\\tthis.context = AudioContext.getContext();\\n\\n\\t\\tthis.gain = this.context.createGain();\\n\\t\\tthis.gain.connect( this.context.destination );\\n\\n\\t\\tthis.filter = null;\\n\\n\\t}\\n\\n\\tAudioListener.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: AudioListener,\\n\\n\\t\\tgetInput: function () {\\n\\n\\t\\t\\treturn this.gain;\\n\\n\\t\\t},\\n\\n\\t\\tremoveFilter: function ( ) {\\n\\n\\t\\t\\tif ( this.filter !== null ) {\\n\\n\\t\\t\\t\\tthis.gain.disconnect( this.filter );\\n\\t\\t\\t\\tthis.filter.disconnect( this.context.destination );\\n\\t\\t\\t\\tthis.gain.connect( this.context.destination );\\n\\t\\t\\t\\tthis.filter = null;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tgetFilter: function () {\\n\\n\\t\\t\\treturn this.filter;\\n\\n\\t\\t},\\n\\n\\t\\tsetFilter: function ( value ) {\\n\\n\\t\\t\\tif ( this.filter !== null ) {\\n\\n\\t\\t\\t\\tthis.gain.disconnect( this.filter );\\n\\t\\t\\t\\tthis.filter.disconnect( this.context.destination );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.gain.disconnect( this.context.destination );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.filter = value;\\n\\t\\t\\tthis.gain.connect( this.filter );\\n\\t\\t\\tthis.filter.connect( this.context.destination );\\n\\n\\t\\t},\\n\\n\\t\\tgetMasterVolume: function () {\\n\\n\\t\\t\\treturn this.gain.gain.value;\\n\\n\\t\\t},\\n\\n\\t\\tsetMasterVolume: function ( value ) {\\n\\n\\t\\t\\tthis.gain.gain.value = value;\\n\\n\\t\\t},\\n\\n\\t\\tupdateMatrixWorld: ( function () {\\n\\n\\t\\t\\tvar position = new Vector3();\\n\\t\\t\\tvar quaternion = new Quaternion();\\n\\t\\t\\tvar scale = new Vector3();\\n\\n\\t\\t\\tvar orientation = new Vector3();\\n\\n\\t\\t\\treturn function updateMatrixWorld( force ) {\\n\\n\\t\\t\\t\\tObject3D.prototype.updateMatrixWorld.call( this, force );\\n\\n\\t\\t\\t\\tvar listener = this.context.listener;\\n\\t\\t\\t\\tvar up = this.up;\\n\\n\\t\\t\\t\\tthis.matrixWorld.decompose( position, quaternion, scale );\\n\\n\\t\\t\\t\\torientation.set( 0, 0, - 1 ).applyQuaternion( quaternion );\\n\\n\\t\\t\\t\\tif ( listener.positionX ) {\\n\\n\\t\\t\\t\\t\\tlistener.positionX.setValueAtTime( position.x, this.context.currentTime );\\n\\t\\t\\t\\t\\tlistener.positionY.setValueAtTime( position.y, this.context.currentTime );\\n\\t\\t\\t\\t\\tlistener.positionZ.setValueAtTime( position.z, this.context.currentTime );\\n\\t\\t\\t\\t\\tlistener.forwardX.setValueAtTime( orientation.x, this.context.currentTime );\\n\\t\\t\\t\\t\\tlistener.forwardY.setValueAtTime( orientation.y, this.context.currentTime );\\n\\t\\t\\t\\t\\tlistener.forwardZ.setValueAtTime( orientation.z, this.context.currentTime );\\n\\t\\t\\t\\t\\tlistener.upX.setValueAtTime( up.x, this.context.currentTime );\\n\\t\\t\\t\\t\\tlistener.upY.setValueAtTime( up.y, this.context.currentTime );\\n\\t\\t\\t\\t\\tlistener.upZ.setValueAtTime( up.z, this.context.currentTime );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tlistener.setPosition( position.x, position.y, position.z );\\n\\t\\t\\t\\t\\tlistener.setOrientation( orientation.x, orientation.y, orientation.z, up.x, up.y, up.z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )()\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Reece Aaron Lecrivain / http://reecenotes.com/\\n\\t */\\n\\n\\tfunction Audio( listener ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Audio';\\n\\n\\t\\tthis.context = listener.context;\\n\\n\\t\\tthis.gain = this.context.createGain();\\n\\t\\tthis.gain.connect( listener.getInput() );\\n\\n\\t\\tthis.autoplay = false;\\n\\n\\t\\tthis.buffer = null;\\n\\t\\tthis.loop = false;\\n\\t\\tthis.startTime = 0;\\n\\t\\tthis.offset = 0;\\n\\t\\tthis.playbackRate = 1;\\n\\t\\tthis.isPlaying = false;\\n\\t\\tthis.hasPlaybackControl = true;\\n\\t\\tthis.sourceType = 'empty';\\n\\n\\t\\tthis.filters = [];\\n\\n\\t}\\n\\n\\tAudio.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Audio,\\n\\n\\t\\tgetOutput: function () {\\n\\n\\t\\t\\treturn this.gain;\\n\\n\\t\\t},\\n\\n\\t\\tsetNodeSource: function ( audioNode ) {\\n\\n\\t\\t\\tthis.hasPlaybackControl = false;\\n\\t\\t\\tthis.sourceType = 'audioNode';\\n\\t\\t\\tthis.source = audioNode;\\n\\t\\t\\tthis.connect();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetBuffer: function ( audioBuffer ) {\\n\\n\\t\\t\\tthis.buffer = audioBuffer;\\n\\t\\t\\tthis.sourceType = 'buffer';\\n\\n\\t\\t\\tif ( this.autoplay ) this.play();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tplay: function () {\\n\\n\\t\\t\\tif ( this.isPlaying === true ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Audio: Audio is already playing.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.hasPlaybackControl === false ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar source = this.context.createBufferSource();\\n\\n\\t\\t\\tsource.buffer = this.buffer;\\n\\t\\t\\tsource.loop = this.loop;\\n\\t\\t\\tsource.onended = this.onEnded.bind( this );\\n\\t\\t\\tsource.playbackRate.setValueAtTime( this.playbackRate, this.startTime );\\n\\t\\t\\tthis.startTime = this.context.currentTime;\\n\\t\\t\\tsource.start( this.startTime, this.offset );\\n\\n\\t\\t\\tthis.isPlaying = true;\\n\\n\\t\\t\\tthis.source = source;\\n\\n\\t\\t\\treturn this.connect();\\n\\n\\t\\t},\\n\\n\\t\\tpause: function () {\\n\\n\\t\\t\\tif ( this.hasPlaybackControl === false ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.isPlaying === true ) {\\n\\n\\t\\t\\t\\tthis.source.stop();\\n\\t\\t\\t\\tthis.offset += ( this.context.currentTime - this.startTime ) * this.playbackRate;\\n\\t\\t\\t\\tthis.isPlaying = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tstop: function () {\\n\\n\\t\\t\\tif ( this.hasPlaybackControl === false ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.source.stop();\\n\\t\\t\\tthis.offset = 0;\\n\\t\\t\\tthis.isPlaying = false;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tconnect: function () {\\n\\n\\t\\t\\tif ( this.filters.length > 0 ) {\\n\\n\\t\\t\\t\\tthis.source.connect( this.filters[ 0 ] );\\n\\n\\t\\t\\t\\tfor ( var i = 1, l = this.filters.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tthis.filters[ i - 1 ].connect( this.filters[ i ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.filters[ this.filters.length - 1 ].connect( this.getOutput() );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.source.connect( this.getOutput() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdisconnect: function () {\\n\\n\\t\\t\\tif ( this.filters.length > 0 ) {\\n\\n\\t\\t\\t\\tthis.source.disconnect( this.filters[ 0 ] );\\n\\n\\t\\t\\t\\tfor ( var i = 1, l = this.filters.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tthis.filters[ i - 1 ].disconnect( this.filters[ i ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.filters[ this.filters.length - 1 ].disconnect( this.getOutput() );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.source.disconnect( this.getOutput() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetFilters: function () {\\n\\n\\t\\t\\treturn this.filters;\\n\\n\\t\\t},\\n\\n\\t\\tsetFilters: function ( value ) {\\n\\n\\t\\t\\tif ( ! value ) value = [];\\n\\n\\t\\t\\tif ( this.isPlaying === true ) {\\n\\n\\t\\t\\t\\tthis.disconnect();\\n\\t\\t\\t\\tthis.filters = value;\\n\\t\\t\\t\\tthis.connect();\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.filters = value;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetFilter: function () {\\n\\n\\t\\t\\treturn this.getFilters()[ 0 ];\\n\\n\\t\\t},\\n\\n\\t\\tsetFilter: function ( filter ) {\\n\\n\\t\\t\\treturn this.setFilters( filter ? [ filter ] : [] );\\n\\n\\t\\t},\\n\\n\\t\\tsetPlaybackRate: function ( value ) {\\n\\n\\t\\t\\tif ( this.hasPlaybackControl === false ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.playbackRate = value;\\n\\n\\t\\t\\tif ( this.isPlaying === true ) {\\n\\n\\t\\t\\t\\tthis.source.playbackRate.setValueAtTime( this.playbackRate, this.context.currentTime );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetPlaybackRate: function () {\\n\\n\\t\\t\\treturn this.playbackRate;\\n\\n\\t\\t},\\n\\n\\t\\tonEnded: function () {\\n\\n\\t\\t\\tthis.isPlaying = false;\\n\\n\\t\\t},\\n\\n\\t\\tgetLoop: function () {\\n\\n\\t\\t\\tif ( this.hasPlaybackControl === false ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\\n\\t\\t\\t\\treturn false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this.loop;\\n\\n\\t\\t},\\n\\n\\t\\tsetLoop: function ( value ) {\\n\\n\\t\\t\\tif ( this.hasPlaybackControl === false ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.loop = value;\\n\\n\\t\\t\\tif ( this.isPlaying === true ) {\\n\\n\\t\\t\\t\\tthis.source.loop = this.loop;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetVolume: function () {\\n\\n\\t\\t\\treturn this.gain.gain.value;\\n\\n\\t\\t},\\n\\n\\t\\tsetVolume: function ( value ) {\\n\\n\\t\\t\\tthis.gain.gain.value = value;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction PositionalAudio( listener ) {\\n\\n\\t\\tAudio.call( this, listener );\\n\\n\\t\\tthis.panner = this.context.createPanner();\\n\\t\\tthis.panner.connect( this.gain );\\n\\n\\t}\\n\\n\\tPositionalAudio.prototype = Object.assign( Object.create( Audio.prototype ), {\\n\\n\\t\\tconstructor: PositionalAudio,\\n\\n\\t\\tgetOutput: function () {\\n\\n\\t\\t\\treturn this.panner;\\n\\n\\t\\t},\\n\\n\\t\\tgetRefDistance: function () {\\n\\n\\t\\t\\treturn this.panner.refDistance;\\n\\n\\t\\t},\\n\\n\\t\\tsetRefDistance: function ( value ) {\\n\\n\\t\\t\\tthis.panner.refDistance = value;\\n\\n\\t\\t},\\n\\n\\t\\tgetRolloffFactor: function () {\\n\\n\\t\\t\\treturn this.panner.rolloffFactor;\\n\\n\\t\\t},\\n\\n\\t\\tsetRolloffFactor: function ( value ) {\\n\\n\\t\\t\\tthis.panner.rolloffFactor = value;\\n\\n\\t\\t},\\n\\n\\t\\tgetDistanceModel: function () {\\n\\n\\t\\t\\treturn this.panner.distanceModel;\\n\\n\\t\\t},\\n\\n\\t\\tsetDistanceModel: function ( value ) {\\n\\n\\t\\t\\tthis.panner.distanceModel = value;\\n\\n\\t\\t},\\n\\n\\t\\tgetMaxDistance: function () {\\n\\n\\t\\t\\treturn this.panner.maxDistance;\\n\\n\\t\\t},\\n\\n\\t\\tsetMaxDistance: function ( value ) {\\n\\n\\t\\t\\tthis.panner.maxDistance = value;\\n\\n\\t\\t},\\n\\n\\t\\tupdateMatrixWorld: ( function () {\\n\\n\\t\\t\\tvar position = new Vector3();\\n\\n\\t\\t\\treturn function updateMatrixWorld( force ) {\\n\\n\\t\\t\\t\\tObject3D.prototype.updateMatrixWorld.call( this, force );\\n\\n\\t\\t\\t\\tposition.setFromMatrixPosition( this.matrixWorld );\\n\\n\\t\\t\\t\\tthis.panner.setPosition( position.x, position.y, position.z );\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )()\\n\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction AudioAnalyser( audio, fftSize ) {\\n\\n\\t\\tthis.analyser = audio.context.createAnalyser();\\n\\t\\tthis.analyser.fftSize = fftSize !== undefined ? fftSize : 2048;\\n\\n\\t\\tthis.data = new Uint8Array( this.analyser.frequencyBinCount );\\n\\n\\t\\taudio.getOutput().connect( this.analyser );\\n\\n\\t}\\n\\n\\tObject.assign( AudioAnalyser.prototype, {\\n\\n\\t\\tgetFrequencyData: function () {\\n\\n\\t\\t\\tthis.analyser.getByteFrequencyData( this.data );\\n\\n\\t\\t\\treturn this.data;\\n\\n\\t\\t},\\n\\n\\t\\tgetAverageFrequency: function () {\\n\\n\\t\\t\\tvar value = 0, data = this.getFrequencyData();\\n\\n\\t\\t\\tfor ( var i = 0; i < data.length; i ++ ) {\\n\\n\\t\\t\\t\\tvalue += data[ i ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn value / data.length;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * Buffered scene graph property that allows weighted accumulation.\\n\\t *\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction PropertyMixer( binding, typeName, valueSize ) {\\n\\n\\t\\tthis.binding = binding;\\n\\t\\tthis.valueSize = valueSize;\\n\\n\\t\\tvar bufferType = Float64Array,\\n\\t\\t\\tmixFunction;\\n\\n\\t\\tswitch ( typeName ) {\\n\\n\\t\\t\\tcase 'quaternion':\\n\\t\\t\\t\\tmixFunction = this._slerp;\\n\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\tcase 'string':\\n\\t\\t\\tcase 'bool':\\n\\t\\t\\t\\tbufferType = Array;\\n\\t\\t\\t\\tmixFunction = this._select;\\n\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\tdefault:\\n\\t\\t\\t\\tmixFunction = this._lerp;\\n\\n\\t\\t}\\n\\n\\t\\tthis.buffer = new bufferType( valueSize * 4 );\\n\\t\\t// layout: [ incoming | accu0 | accu1 | orig ]\\n\\t\\t//\\n\\t\\t// interpolators can use .buffer as their .result\\n\\t\\t// the data then goes to 'incoming'\\n\\t\\t//\\n\\t\\t// 'accu0' and 'accu1' are used frame-interleaved for\\n\\t\\t// the cumulative result and are compared to detect\\n\\t\\t// changes\\n\\t\\t//\\n\\t\\t// 'orig' stores the original state of the property\\n\\n\\t\\tthis._mixBufferRegion = mixFunction;\\n\\n\\t\\tthis.cumulativeWeight = 0;\\n\\n\\t\\tthis.useCount = 0;\\n\\t\\tthis.referenceCount = 0;\\n\\n\\t}\\n\\n\\tObject.assign( PropertyMixer.prototype, {\\n\\n\\t\\t// accumulate data in the 'incoming' region into 'accu'\\n\\t\\taccumulate: function ( accuIndex, weight ) {\\n\\n\\t\\t\\t// note: happily accumulating nothing when weight = 0, the caller knows\\n\\t\\t\\t// the weight and shouldn't have made the call in the first place\\n\\n\\t\\t\\tvar buffer = this.buffer,\\n\\t\\t\\t\\tstride = this.valueSize,\\n\\t\\t\\t\\toffset = accuIndex * stride + stride,\\n\\n\\t\\t\\t\\tcurrentWeight = this.cumulativeWeight;\\n\\n\\t\\t\\tif ( currentWeight === 0 ) {\\n\\n\\t\\t\\t\\t// accuN := incoming * weight\\n\\n\\t\\t\\t\\tfor ( var i = 0; i !== stride; ++ i ) {\\n\\n\\t\\t\\t\\t\\tbuffer[ offset + i ] = buffer[ i ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tcurrentWeight = weight;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// accuN := accuN + incoming * weight\\n\\n\\t\\t\\t\\tcurrentWeight += weight;\\n\\t\\t\\t\\tvar mix = weight / currentWeight;\\n\\t\\t\\t\\tthis._mixBufferRegion( buffer, offset, 0, mix, stride );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.cumulativeWeight = currentWeight;\\n\\n\\t\\t},\\n\\n\\t\\t// apply the state of 'accu' to the binding when accus differ\\n\\t\\tapply: function ( accuIndex ) {\\n\\n\\t\\t\\tvar stride = this.valueSize,\\n\\t\\t\\t\\tbuffer = this.buffer,\\n\\t\\t\\t\\toffset = accuIndex * stride + stride,\\n\\n\\t\\t\\t\\tweight = this.cumulativeWeight,\\n\\n\\t\\t\\t\\tbinding = this.binding;\\n\\n\\t\\t\\tthis.cumulativeWeight = 0;\\n\\n\\t\\t\\tif ( weight < 1 ) {\\n\\n\\t\\t\\t\\t// accuN := accuN + original * ( 1 - cumulativeWeight )\\n\\n\\t\\t\\t\\tvar originalValueOffset = stride * 3;\\n\\n\\t\\t\\t\\tthis._mixBufferRegion(\\n\\t\\t\\t\\t\\tbuffer, offset, originalValueOffset, 1 - weight, stride );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = stride, e = stride + stride; i !== e; ++ i ) {\\n\\n\\t\\t\\t\\tif ( buffer[ i ] !== buffer[ i + stride ] ) {\\n\\n\\t\\t\\t\\t\\t// value has changed -> update scene graph\\n\\n\\t\\t\\t\\t\\tbinding.setValue( buffer, offset );\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t// remember the state of the bound property and copy it to both accus\\n\\t\\tsaveOriginalState: function () {\\n\\n\\t\\t\\tvar binding = this.binding;\\n\\n\\t\\t\\tvar buffer = this.buffer,\\n\\t\\t\\t\\tstride = this.valueSize,\\n\\n\\t\\t\\t\\toriginalValueOffset = stride * 3;\\n\\n\\t\\t\\tbinding.getValue( buffer, originalValueOffset );\\n\\n\\t\\t\\t// accu[0..1] := orig -- initially detect changes against the original\\n\\t\\t\\tfor ( var i = stride, e = originalValueOffset; i !== e; ++ i ) {\\n\\n\\t\\t\\t\\tbuffer[ i ] = buffer[ originalValueOffset + ( i % stride ) ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.cumulativeWeight = 0;\\n\\n\\t\\t},\\n\\n\\t\\t// apply the state previously taken via 'saveOriginalState' to the binding\\n\\t\\trestoreOriginalState: function () {\\n\\n\\t\\t\\tvar originalValueOffset = this.valueSize * 3;\\n\\t\\t\\tthis.binding.setValue( this.buffer, originalValueOffset );\\n\\n\\t\\t},\\n\\n\\n\\t\\t// mix functions\\n\\n\\t\\t_select: function ( buffer, dstOffset, srcOffset, t, stride ) {\\n\\n\\t\\t\\tif ( t >= 0.5 ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0; i !== stride; ++ i ) {\\n\\n\\t\\t\\t\\t\\tbuffer[ dstOffset + i ] = buffer[ srcOffset + i ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t_slerp: function ( buffer, dstOffset, srcOffset, t ) {\\n\\n\\t\\t\\tQuaternion.slerpFlat( buffer, dstOffset, buffer, dstOffset, buffer, srcOffset, t );\\n\\n\\t\\t},\\n\\n\\t\\t_lerp: function ( buffer, dstOffset, srcOffset, t, stride ) {\\n\\n\\t\\t\\tvar s = 1 - t;\\n\\n\\t\\t\\tfor ( var i = 0; i !== stride; ++ i ) {\\n\\n\\t\\t\\t\\tvar j = dstOffset + i;\\n\\n\\t\\t\\t\\tbuffer[ j ] = buffer[ j ] * s + buffer[ srcOffset + i ] * t;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * A reference to a real property in the scene graph.\\n\\t *\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction Composite( targetGroup, path, optionalParsedPath ) {\\n\\n\\t\\tvar parsedPath = optionalParsedPath || PropertyBinding.parseTrackName( path );\\n\\n\\t\\tthis._targetGroup = targetGroup;\\n\\t\\tthis._bindings = targetGroup.subscribe_( path, parsedPath );\\n\\n\\t}\\n\\n\\tObject.assign( Composite.prototype, {\\n\\n\\t\\tgetValue: function ( array, offset ) {\\n\\n\\t\\t\\tthis.bind(); // bind all binding\\n\\n\\t\\t\\tvar firstValidIndex = this._targetGroup.nCachedObjects_,\\n\\t\\t\\t\\tbinding = this._bindings[ firstValidIndex ];\\n\\n\\t\\t\\t// and only call .getValue on the first\\n\\t\\t\\tif ( binding !== undefined ) binding.getValue( array, offset );\\n\\n\\t\\t},\\n\\n\\t\\tsetValue: function ( array, offset ) {\\n\\n\\t\\t\\tvar bindings = this._bindings;\\n\\n\\t\\t\\tfor ( var i = this._targetGroup.nCachedObjects_,\\n\\t\\t\\t\\t\\t n = bindings.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tbindings[ i ].setValue( array, offset );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tbind: function () {\\n\\n\\t\\t\\tvar bindings = this._bindings;\\n\\n\\t\\t\\tfor ( var i = this._targetGroup.nCachedObjects_,\\n\\t\\t\\t\\t\\t n = bindings.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tbindings[ i ].bind();\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tunbind: function () {\\n\\n\\t\\t\\tvar bindings = this._bindings;\\n\\n\\t\\t\\tfor ( var i = this._targetGroup.nCachedObjects_,\\n\\t\\t\\t\\t\\t n = bindings.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tbindings[ i ].unbind();\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\n\\tfunction PropertyBinding( rootNode, path, parsedPath ) {\\n\\n\\t\\tthis.path = path;\\n\\t\\tthis.parsedPath = parsedPath || PropertyBinding.parseTrackName( path );\\n\\n\\t\\tthis.node = PropertyBinding.findNode( rootNode, this.parsedPath.nodeName ) || rootNode;\\n\\n\\t\\tthis.rootNode = rootNode;\\n\\n\\t}\\n\\n\\tObject.assign( PropertyBinding, {\\n\\n\\t\\tComposite: Composite,\\n\\n\\t\\tcreate: function ( root, path, parsedPath ) {\\n\\n\\t\\t\\tif ( ! ( root && root.isAnimationObjectGroup ) ) {\\n\\n\\t\\t\\t\\treturn new PropertyBinding( root, path, parsedPath );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\treturn new PropertyBinding.Composite( root, path, parsedPath );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t/**\\n\\t\\t * Replaces spaces with underscores and removes unsupported characters from\\n\\t\\t * node names, to ensure compatibility with parseTrackName().\\n\\t\\t *\\n\\t\\t * @param {string} name Node name to be sanitized.\\n\\t\\t * @return {string}\\n\\t\\t */\\n\\t\\tsanitizeNodeName: function ( name ) {\\n\\n\\t\\t\\treturn name.replace( /\\\\s/g, '_' ).replace( /[^\\\\w-]/g, '' );\\n\\n\\t\\t},\\n\\n\\t\\tparseTrackName: function () {\\n\\n\\t\\t\\t// Parent directories, delimited by '/' or ':'. Currently unused, but must\\n\\t\\t\\t// be matched to parse the rest of the track name.\\n\\t\\t\\tvar directoryRe = /((?:[\\\\w-]+[\\\\/:])*)/;\\n\\n\\t\\t\\t// Target node. May contain word characters (a-zA-Z0-9_) and '.' or '-'.\\n\\t\\t\\tvar nodeRe = /([\\\\w-\\\\.]+)?/;\\n\\n\\t\\t\\t// Object on target node, and accessor. Name may contain only word\\n\\t\\t\\t// characters. Accessor may contain any character except closing bracket.\\n\\t\\t\\tvar objectRe = /(?:\\\\.([\\\\w-]+)(?:\\\\[(.+)\\\\])?)?/;\\n\\n\\t\\t\\t// Property and accessor. May contain only word characters. Accessor may\\n\\t\\t\\t// contain any non-bracket characters.\\n\\t\\t\\tvar propertyRe = /\\\\.([\\\\w-]+)(?:\\\\[(.+)\\\\])?/;\\n\\n\\t\\t\\tvar trackRe = new RegExp( ''\\n\\t\\t\\t\\t+ '^'\\n\\t\\t\\t\\t+ directoryRe.source\\n\\t\\t\\t\\t+ nodeRe.source\\n\\t\\t\\t\\t+ objectRe.source\\n\\t\\t\\t\\t+ propertyRe.source\\n\\t\\t\\t\\t+ '$'\\n\\t\\t\\t);\\n\\n\\t\\t\\tvar supportedObjectNames = [ 'material', 'materials', 'bones' ];\\n\\n\\t\\t\\treturn function ( trackName ) {\\n\\n\\t\\t\\t\\tvar matches = trackRe.exec( trackName );\\n\\n\\t\\t\\t\\tif ( ! matches ) {\\n\\n\\t\\t\\t\\t\\tthrow new Error( 'PropertyBinding: Cannot parse trackName: ' + trackName );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar results = {\\n\\t\\t\\t\\t\\t// directoryName: matches[ 1 ], // (tschw) currently unused\\n\\t\\t\\t\\t\\tnodeName: matches[ 2 ],\\n\\t\\t\\t\\t\\tobjectName: matches[ 3 ],\\n\\t\\t\\t\\t\\tobjectIndex: matches[ 4 ],\\n\\t\\t\\t\\t\\tpropertyName: matches[ 5 ], // required\\n\\t\\t\\t\\t\\tpropertyIndex: matches[ 6 ]\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\tvar lastDot = results.nodeName && results.nodeName.lastIndexOf( '.' );\\n\\n\\t\\t\\t\\tif ( lastDot !== undefined && lastDot !== - 1 ) {\\n\\n\\t\\t\\t\\t\\tvar objectName = results.nodeName.substring( lastDot + 1 );\\n\\n\\t\\t\\t\\t\\t// Object names must be checked against a whitelist. Otherwise, there\\n\\t\\t\\t\\t\\t// is no way to parse 'foo.bar.baz': 'baz' must be a property, but\\n\\t\\t\\t\\t\\t// 'bar' could be the objectName, or part of a nodeName (which can\\n\\t\\t\\t\\t\\t// include '.' characters).\\n\\t\\t\\t\\t\\tif ( supportedObjectNames.indexOf( objectName ) !== - 1 ) {\\n\\n\\t\\t\\t\\t\\t\\tresults.nodeName = results.nodeName.substring( 0, lastDot );\\n\\t\\t\\t\\t\\t\\tresults.objectName = objectName;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( results.propertyName === null || results.propertyName.length === 0 ) {\\n\\n\\t\\t\\t\\t\\tthrow new Error( 'PropertyBinding: can not parse propertyName from trackName: ' + trackName );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn results;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tfindNode: function ( root, nodeName ) {\\n\\n\\t\\t\\tif ( ! nodeName || nodeName === \\\"\\\" || nodeName === \\\"root\\\" || nodeName === \\\".\\\" || nodeName === - 1 || nodeName === root.name || nodeName === root.uuid ) {\\n\\n\\t\\t\\t\\treturn root;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// search into skeleton bones.\\n\\t\\t\\tif ( root.skeleton ) {\\n\\n\\t\\t\\t\\tvar searchSkeleton = function ( skeleton ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < skeleton.bones.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar bone = skeleton.bones[ i ];\\n\\n\\t\\t\\t\\t\\t\\tif ( bone.name === nodeName ) {\\n\\n\\t\\t\\t\\t\\t\\t\\treturn bone;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\tvar bone = searchSkeleton( root.skeleton );\\n\\n\\t\\t\\t\\tif ( bone ) {\\n\\n\\t\\t\\t\\t\\treturn bone;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// search into node subtree.\\n\\t\\t\\tif ( root.children ) {\\n\\n\\t\\t\\t\\tvar searchNodeSubtree = function ( children ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < children.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar childNode = children[ i ];\\n\\n\\t\\t\\t\\t\\t\\tif ( childNode.name === nodeName || childNode.uuid === nodeName ) {\\n\\n\\t\\t\\t\\t\\t\\t\\treturn childNode;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tvar result = searchNodeSubtree( childNode.children );\\n\\n\\t\\t\\t\\t\\t\\tif ( result ) return result;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\tvar subTreeNode = searchNodeSubtree( root.children );\\n\\n\\t\\t\\t\\tif ( subTreeNode ) {\\n\\n\\t\\t\\t\\t\\treturn subTreeNode;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn null;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( PropertyBinding.prototype, { // prototype, continued\\n\\n\\t\\t// these are used to \\\"bind\\\" a nonexistent property\\n\\t\\t_getValue_unavailable: function () {},\\n\\t\\t_setValue_unavailable: function () {},\\n\\n\\t\\tBindingType: {\\n\\t\\t\\tDirect: 0,\\n\\t\\t\\tEntireArray: 1,\\n\\t\\t\\tArrayElement: 2,\\n\\t\\t\\tHasFromToArray: 3\\n\\t\\t},\\n\\n\\t\\tVersioning: {\\n\\t\\t\\tNone: 0,\\n\\t\\t\\tNeedsUpdate: 1,\\n\\t\\t\\tMatrixWorldNeedsUpdate: 2\\n\\t\\t},\\n\\n\\t\\tGetterByBindingType: [\\n\\n\\t\\t\\tfunction getValue_direct( buffer, offset ) {\\n\\n\\t\\t\\t\\tbuffer[ offset ] = this.node[ this.propertyName ];\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tfunction getValue_array( buffer, offset ) {\\n\\n\\t\\t\\t\\tvar source = this.resolvedProperty;\\n\\n\\t\\t\\t\\tfor ( var i = 0, n = source.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\tbuffer[ offset ++ ] = source[ i ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tfunction getValue_arrayElement( buffer, offset ) {\\n\\n\\t\\t\\t\\tbuffer[ offset ] = this.resolvedProperty[ this.propertyIndex ];\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tfunction getValue_toArray( buffer, offset ) {\\n\\n\\t\\t\\t\\tthis.resolvedProperty.toArray( buffer, offset );\\n\\n\\t\\t\\t}\\n\\n\\t\\t],\\n\\n\\t\\tSetterByBindingTypeAndVersioning: [\\n\\n\\t\\t\\t[\\n\\t\\t\\t\\t// Direct\\n\\n\\t\\t\\t\\tfunction setValue_direct( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.targetObject[ this.propertyName ] = buffer[ offset ];\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfunction setValue_direct_setNeedsUpdate( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.targetObject[ this.propertyName ] = buffer[ offset ];\\n\\t\\t\\t\\t\\tthis.targetObject.needsUpdate = true;\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfunction setValue_direct_setMatrixWorldNeedsUpdate( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.targetObject[ this.propertyName ] = buffer[ offset ];\\n\\t\\t\\t\\t\\tthis.targetObject.matrixWorldNeedsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t], [\\n\\n\\t\\t\\t\\t// EntireArray\\n\\n\\t\\t\\t\\tfunction setValue_array( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tvar dest = this.resolvedProperty;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, n = dest.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\t\\tdest[ i ] = buffer[ offset ++ ];\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfunction setValue_array_setNeedsUpdate( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tvar dest = this.resolvedProperty;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, n = dest.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\t\\tdest[ i ] = buffer[ offset ++ ];\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tthis.targetObject.needsUpdate = true;\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfunction setValue_array_setMatrixWorldNeedsUpdate( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tvar dest = this.resolvedProperty;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, n = dest.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\t\\tdest[ i ] = buffer[ offset ++ ];\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tthis.targetObject.matrixWorldNeedsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t], [\\n\\n\\t\\t\\t\\t// ArrayElement\\n\\n\\t\\t\\t\\tfunction setValue_arrayElement( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfunction setValue_arrayElement_setNeedsUpdate( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];\\n\\t\\t\\t\\t\\tthis.targetObject.needsUpdate = true;\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfunction setValue_arrayElement_setMatrixWorldNeedsUpdate( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];\\n\\t\\t\\t\\t\\tthis.targetObject.matrixWorldNeedsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t], [\\n\\n\\t\\t\\t\\t// HasToFromArray\\n\\n\\t\\t\\t\\tfunction setValue_fromArray( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.resolvedProperty.fromArray( buffer, offset );\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfunction setValue_fromArray_setNeedsUpdate( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.resolvedProperty.fromArray( buffer, offset );\\n\\t\\t\\t\\t\\tthis.targetObject.needsUpdate = true;\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfunction setValue_fromArray_setMatrixWorldNeedsUpdate( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.resolvedProperty.fromArray( buffer, offset );\\n\\t\\t\\t\\t\\tthis.targetObject.matrixWorldNeedsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t]\\n\\n\\t\\t],\\n\\n\\t\\tgetValue: function getValue_unbound( targetArray, offset ) {\\n\\n\\t\\t\\tthis.bind();\\n\\t\\t\\tthis.getValue( targetArray, offset );\\n\\n\\t\\t\\t// Note: This class uses a State pattern on a per-method basis:\\n\\t\\t\\t// 'bind' sets 'this.getValue' / 'setValue' and shadows the\\n\\t\\t\\t// prototype version of these methods with one that represents\\n\\t\\t\\t// the bound state. When the property is not found, the methods\\n\\t\\t\\t// become no-ops.\\n\\n\\t\\t},\\n\\n\\t\\tsetValue: function getValue_unbound( sourceArray, offset ) {\\n\\n\\t\\t\\tthis.bind();\\n\\t\\t\\tthis.setValue( sourceArray, offset );\\n\\n\\t\\t},\\n\\n\\t\\t// create getter / setter pair for a property in the scene graph\\n\\t\\tbind: function () {\\n\\n\\t\\t\\tvar targetObject = this.node,\\n\\t\\t\\t\\tparsedPath = this.parsedPath,\\n\\n\\t\\t\\t\\tobjectName = parsedPath.objectName,\\n\\t\\t\\t\\tpropertyName = parsedPath.propertyName,\\n\\t\\t\\t\\tpropertyIndex = parsedPath.propertyIndex;\\n\\n\\t\\t\\tif ( ! targetObject ) {\\n\\n\\t\\t\\t\\ttargetObject = PropertyBinding.findNode( this.rootNode, parsedPath.nodeName ) || this.rootNode;\\n\\n\\t\\t\\t\\tthis.node = targetObject;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// set fail state so we can just 'return' on error\\n\\t\\t\\tthis.getValue = this._getValue_unavailable;\\n\\t\\t\\tthis.setValue = this._setValue_unavailable;\\n\\n\\t\\t\\t// ensure there is a value node\\n\\t\\t\\tif ( ! targetObject ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Trying to update node for track: ' + this.path + ' but it wasn\\\\'t found.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( objectName ) {\\n\\n\\t\\t\\t\\tvar objectIndex = parsedPath.objectIndex;\\n\\n\\t\\t\\t\\t// special cases were we need to reach deeper into the hierarchy to get the face materials....\\n\\t\\t\\t\\tswitch ( objectName ) {\\n\\n\\t\\t\\t\\t\\tcase 'materials':\\n\\n\\t\\t\\t\\t\\t\\tif ( ! targetObject.material ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Can not bind to material as node does not have a material.', this );\\n\\t\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tif ( ! targetObject.material.materials ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.', this );\\n\\t\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\ttargetObject = targetObject.material.materials;\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'bones':\\n\\n\\t\\t\\t\\t\\t\\tif ( ! targetObject.skeleton ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.', this );\\n\\t\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t// potential future optimization: skip this if propertyIndex is already an integer\\n\\t\\t\\t\\t\\t\\t// and convert the integer string to a true integer.\\n\\n\\t\\t\\t\\t\\t\\ttargetObject = targetObject.skeleton.bones;\\n\\n\\t\\t\\t\\t\\t\\t// support resolving morphTarget names into indices.\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0; i < targetObject.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( targetObject[ i ].name === objectIndex ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tobjectIndex = i;\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tdefault:\\n\\n\\t\\t\\t\\t\\t\\tif ( targetObject[ objectName ] === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Can not bind to objectName of node undefined.', this );\\n\\t\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\ttargetObject = targetObject[ objectName ];\\n\\n\\t\\t\\t\\t}\\n\\n\\n\\t\\t\\t\\tif ( objectIndex !== undefined ) {\\n\\n\\t\\t\\t\\t\\tif ( targetObject[ objectIndex ] === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.', this, targetObject );\\n\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\ttargetObject = targetObject[ objectIndex ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// resolve property\\n\\t\\t\\tvar nodeProperty = targetObject[ propertyName ];\\n\\n\\t\\t\\tif ( nodeProperty === undefined ) {\\n\\n\\t\\t\\t\\tvar nodeName = parsedPath.nodeName;\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Trying to update property for track: ' + nodeName +\\n\\t\\t\\t\\t\\t'.' + propertyName + ' but it wasn\\\\'t found.', targetObject );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// determine versioning scheme\\n\\t\\t\\tvar versioning = this.Versioning.None;\\n\\n\\t\\t\\tif ( targetObject.needsUpdate !== undefined ) { // material\\n\\n\\t\\t\\t\\tversioning = this.Versioning.NeedsUpdate;\\n\\t\\t\\t\\tthis.targetObject = targetObject;\\n\\n\\t\\t\\t} else if ( targetObject.matrixWorldNeedsUpdate !== undefined ) { // node transform\\n\\n\\t\\t\\t\\tversioning = this.Versioning.MatrixWorldNeedsUpdate;\\n\\t\\t\\t\\tthis.targetObject = targetObject;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// determine how the property gets bound\\n\\t\\t\\tvar bindingType = this.BindingType.Direct;\\n\\n\\t\\t\\tif ( propertyIndex !== undefined ) {\\n\\n\\t\\t\\t\\t// access a sub element of the property array (only primitives are supported right now)\\n\\n\\t\\t\\t\\tif ( propertyName === \\\"morphTargetInfluences\\\" ) {\\n\\n\\t\\t\\t\\t\\t// potential optimization, skip this if propertyIndex is already an integer, and convert the integer string to a true integer.\\n\\n\\t\\t\\t\\t\\t// support resolving morphTarget names into indices.\\n\\t\\t\\t\\t\\tif ( ! targetObject.geometry ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.', this );\\n\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( targetObject.geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( ! targetObject.geometry.morphAttributes ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.', this );\\n\\t\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0; i < this.node.geometry.morphAttributes.position.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( targetObject.geometry.morphAttributes.position[ i ].name === propertyIndex ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tpropertyIndex = i;\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tif ( ! targetObject.geometry.morphTargets ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphTargets.', this );\\n\\t\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0; i < this.node.geometry.morphTargets.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( targetObject.geometry.morphTargets[ i ].name === propertyIndex ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tpropertyIndex = i;\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tbindingType = this.BindingType.ArrayElement;\\n\\n\\t\\t\\t\\tthis.resolvedProperty = nodeProperty;\\n\\t\\t\\t\\tthis.propertyIndex = propertyIndex;\\n\\n\\t\\t\\t} else if ( nodeProperty.fromArray !== undefined && nodeProperty.toArray !== undefined ) {\\n\\n\\t\\t\\t\\t// must use copy for Object3D.Euler/Quaternion\\n\\n\\t\\t\\t\\tbindingType = this.BindingType.HasFromToArray;\\n\\n\\t\\t\\t\\tthis.resolvedProperty = nodeProperty;\\n\\n\\t\\t\\t} else if ( Array.isArray( nodeProperty ) ) {\\n\\n\\t\\t\\t\\tbindingType = this.BindingType.EntireArray;\\n\\n\\t\\t\\t\\tthis.resolvedProperty = nodeProperty;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.propertyName = propertyName;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// select getter / setter\\n\\t\\t\\tthis.getValue = this.GetterByBindingType[ bindingType ];\\n\\t\\t\\tthis.setValue = this.SetterByBindingTypeAndVersioning[ bindingType ][ versioning ];\\n\\n\\t\\t},\\n\\n\\t\\tunbind: function () {\\n\\n\\t\\t\\tthis.node = null;\\n\\n\\t\\t\\t// back to the prototype version of getValue / setValue\\n\\t\\t\\t// note: avoiding to mutate the shape of 'this' via 'delete'\\n\\t\\t\\tthis.getValue = this._getValue_unbound;\\n\\t\\t\\tthis.setValue = this._setValue_unbound;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//!\\\\ DECLARE ALIAS AFTER assign prototype !\\n\\tObject.assign( PropertyBinding.prototype, {\\n\\n\\t\\t// initial state of these methods that calls 'bind'\\n\\t\\t_getValue_unbound: PropertyBinding.prototype.getValue,\\n\\t\\t_setValue_unbound: PropertyBinding.prototype.setValue,\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * A group of objects that receives a shared animation state.\\n\\t *\\n\\t * Usage:\\n\\t *\\n\\t * \\t-\\tAdd objects you would otherwise pass as 'root' to the\\n\\t * \\t\\tconstructor or the .clipAction method of AnimationMixer.\\n\\t *\\n\\t * \\t-\\tInstead pass this object as 'root'.\\n\\t *\\n\\t * \\t-\\tYou can also add and remove objects later when the mixer\\n\\t * \\t\\tis running.\\n\\t *\\n\\t * Note:\\n\\t *\\n\\t * \\tObjects of this class appear as one object to the mixer,\\n\\t * \\tso cache control of the individual objects must be done\\n\\t * \\ton the group.\\n\\t *\\n\\t * Limitation:\\n\\t *\\n\\t * \\t- \\tThe animated properties must be compatible among the\\n\\t * \\t\\tall objects in the group.\\n\\t *\\n\\t * -\\tA single property can either be controlled through a\\n\\t * \\ttarget group or directly, but not both.\\n\\t *\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction AnimationObjectGroup() {\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\t// cached objects followed by the active ones\\n\\t\\tthis._objects = Array.prototype.slice.call( arguments );\\n\\n\\t\\tthis.nCachedObjects_ = 0;\\t\\t\\t// threshold\\n\\t\\t// note: read by PropertyBinding.Composite\\n\\n\\t\\tvar indices = {};\\n\\t\\tthis._indicesByUUID = indices;\\t\\t// for bookkeeping\\n\\n\\t\\tfor ( var i = 0, n = arguments.length; i !== n; ++ i ) {\\n\\n\\t\\t\\tindices[ arguments[ i ].uuid ] = i;\\n\\n\\t\\t}\\n\\n\\t\\tthis._paths = [];\\t\\t\\t\\t\\t// inside: string\\n\\t\\tthis._parsedPaths = [];\\t\\t\\t\\t// inside: { we don't care, here }\\n\\t\\tthis._bindings = []; \\t\\t\\t\\t// inside: Array< PropertyBinding >\\n\\t\\tthis._bindingsIndicesByPath = {}; \\t// inside: indices in these arrays\\n\\n\\t\\tvar scope = this;\\n\\n\\t\\tthis.stats = {\\n\\n\\t\\t\\tobjects: {\\n\\t\\t\\t\\tget total() {\\n\\n\\t\\t\\t\\t\\treturn scope._objects.length;\\n\\n\\t\\t\\t\\t},\\n\\t\\t\\t\\tget inUse() {\\n\\n\\t\\t\\t\\t\\treturn this.total - scope.nCachedObjects_;\\n\\n\\t\\t\\t\\t}\\n\\t\\t\\t},\\n\\t\\t\\tget bindingsPerObject() {\\n\\n\\t\\t\\t\\treturn scope._bindings.length;\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\tObject.assign( AnimationObjectGroup.prototype, {\\n\\n\\t\\tisAnimationObjectGroup: true,\\n\\n\\t\\tadd: function () {\\n\\n\\t\\t\\tvar objects = this._objects,\\n\\t\\t\\t\\tnObjects = objects.length,\\n\\t\\t\\t\\tnCachedObjects = this.nCachedObjects_,\\n\\t\\t\\t\\tindicesByUUID = this._indicesByUUID,\\n\\t\\t\\t\\tpaths = this._paths,\\n\\t\\t\\t\\tparsedPaths = this._parsedPaths,\\n\\t\\t\\t\\tbindings = this._bindings,\\n\\t\\t\\t\\tnBindings = bindings.length;\\n\\n\\t\\t\\tfor ( var i = 0, n = arguments.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tvar object = arguments[ i ],\\n\\t\\t\\t\\t\\tuuid = object.uuid,\\n\\t\\t\\t\\t\\tindex = indicesByUUID[ uuid ],\\n\\t\\t\\t\\t\\tknownObject = undefined;\\n\\n\\t\\t\\t\\tif ( index === undefined ) {\\n\\n\\t\\t\\t\\t\\t// unknown object -> add it to the ACTIVE region\\n\\n\\t\\t\\t\\t\\tindex = nObjects ++;\\n\\t\\t\\t\\t\\tindicesByUUID[ uuid ] = index;\\n\\t\\t\\t\\t\\tobjects.push( object );\\n\\n\\t\\t\\t\\t\\t// accounting is done, now do the same for all bindings\\n\\n\\t\\t\\t\\t\\tfor ( var j = 0, m = nBindings; j !== m; ++ j ) {\\n\\n\\t\\t\\t\\t\\t\\tbindings[ j ].push( new PropertyBinding( object, paths[ j ], parsedPaths[ j ] ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( index < nCachedObjects ) {\\n\\n\\t\\t\\t\\t\\tknownObject = objects[ index ];\\n\\n\\t\\t\\t\\t\\t// move existing object to the ACTIVE region\\n\\n\\t\\t\\t\\t\\tvar firstActiveIndex = -- nCachedObjects,\\n\\t\\t\\t\\t\\t\\tlastCachedObject = objects[ firstActiveIndex ];\\n\\n\\t\\t\\t\\t\\tindicesByUUID[ lastCachedObject.uuid ] = index;\\n\\t\\t\\t\\t\\tobjects[ index ] = lastCachedObject;\\n\\n\\t\\t\\t\\t\\tindicesByUUID[ uuid ] = firstActiveIndex;\\n\\t\\t\\t\\t\\tobjects[ firstActiveIndex ] = object;\\n\\n\\t\\t\\t\\t\\t// accounting is done, now do the same for all bindings\\n\\n\\t\\t\\t\\t\\tfor ( var j = 0, m = nBindings; j !== m; ++ j ) {\\n\\n\\t\\t\\t\\t\\t\\tvar bindingsForPath = bindings[ j ],\\n\\t\\t\\t\\t\\t\\t\\tlastCached = bindingsForPath[ firstActiveIndex ],\\n\\t\\t\\t\\t\\t\\t\\tbinding = bindingsForPath[ index ];\\n\\n\\t\\t\\t\\t\\t\\tbindingsForPath[ index ] = lastCached;\\n\\n\\t\\t\\t\\t\\t\\tif ( binding === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// since we do not bother to create new bindings\\n\\t\\t\\t\\t\\t\\t\\t// for objects that are cached, the binding may\\n\\t\\t\\t\\t\\t\\t\\t// or may not exist\\n\\n\\t\\t\\t\\t\\t\\t\\tbinding = new PropertyBinding( object, paths[ j ], parsedPaths[ j ] );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tbindingsForPath[ firstActiveIndex ] = binding;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( objects[ index ] !== knownObject ) {\\n\\n\\t\\t\\t\\t\\tconsole.error( 'THREE.AnimationObjectGroup: Different objects with the same UUID ' +\\n\\t\\t\\t\\t\\t\\t\\t'detected. Clean the caches or recreate your infrastructure when reloading scenes.' );\\n\\n\\t\\t\\t\\t} // else the object is already where we want it to be\\n\\n\\t\\t\\t} // for arguments\\n\\n\\t\\t\\tthis.nCachedObjects_ = nCachedObjects;\\n\\n\\t\\t},\\n\\n\\t\\tremove: function () {\\n\\n\\t\\t\\tvar objects = this._objects,\\n\\t\\t\\t\\tnCachedObjects = this.nCachedObjects_,\\n\\t\\t\\t\\tindicesByUUID = this._indicesByUUID,\\n\\t\\t\\t\\tbindings = this._bindings,\\n\\t\\t\\t\\tnBindings = bindings.length;\\n\\n\\t\\t\\tfor ( var i = 0, n = arguments.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tvar object = arguments[ i ],\\n\\t\\t\\t\\t\\tuuid = object.uuid,\\n\\t\\t\\t\\t\\tindex = indicesByUUID[ uuid ];\\n\\n\\t\\t\\t\\tif ( index !== undefined && index >= nCachedObjects ) {\\n\\n\\t\\t\\t\\t\\t// move existing object into the CACHED region\\n\\n\\t\\t\\t\\t\\tvar lastCachedIndex = nCachedObjects ++,\\n\\t\\t\\t\\t\\t\\tfirstActiveObject = objects[ lastCachedIndex ];\\n\\n\\t\\t\\t\\t\\tindicesByUUID[ firstActiveObject.uuid ] = index;\\n\\t\\t\\t\\t\\tobjects[ index ] = firstActiveObject;\\n\\n\\t\\t\\t\\t\\tindicesByUUID[ uuid ] = lastCachedIndex;\\n\\t\\t\\t\\t\\tobjects[ lastCachedIndex ] = object;\\n\\n\\t\\t\\t\\t\\t// accounting is done, now do the same for all bindings\\n\\n\\t\\t\\t\\t\\tfor ( var j = 0, m = nBindings; j !== m; ++ j ) {\\n\\n\\t\\t\\t\\t\\t\\tvar bindingsForPath = bindings[ j ],\\n\\t\\t\\t\\t\\t\\t\\tfirstActive = bindingsForPath[ lastCachedIndex ],\\n\\t\\t\\t\\t\\t\\t\\tbinding = bindingsForPath[ index ];\\n\\n\\t\\t\\t\\t\\t\\tbindingsForPath[ index ] = firstActive;\\n\\t\\t\\t\\t\\t\\tbindingsForPath[ lastCachedIndex ] = binding;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} // for arguments\\n\\n\\t\\t\\tthis.nCachedObjects_ = nCachedObjects;\\n\\n\\t\\t},\\n\\n\\t\\t// remove & forget\\n\\t\\tuncache: function () {\\n\\n\\t\\t\\tvar objects = this._objects,\\n\\t\\t\\t\\tnObjects = objects.length,\\n\\t\\t\\t\\tnCachedObjects = this.nCachedObjects_,\\n\\t\\t\\t\\tindicesByUUID = this._indicesByUUID,\\n\\t\\t\\t\\tbindings = this._bindings,\\n\\t\\t\\t\\tnBindings = bindings.length;\\n\\n\\t\\t\\tfor ( var i = 0, n = arguments.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tvar object = arguments[ i ],\\n\\t\\t\\t\\t\\tuuid = object.uuid,\\n\\t\\t\\t\\t\\tindex = indicesByUUID[ uuid ];\\n\\n\\t\\t\\t\\tif ( index !== undefined ) {\\n\\n\\t\\t\\t\\t\\tdelete indicesByUUID[ uuid ];\\n\\n\\t\\t\\t\\t\\tif ( index < nCachedObjects ) {\\n\\n\\t\\t\\t\\t\\t\\t// object is cached, shrink the CACHED region\\n\\n\\t\\t\\t\\t\\t\\tvar firstActiveIndex = -- nCachedObjects,\\n\\t\\t\\t\\t\\t\\t\\tlastCachedObject = objects[ firstActiveIndex ],\\n\\t\\t\\t\\t\\t\\t\\tlastIndex = -- nObjects,\\n\\t\\t\\t\\t\\t\\t\\tlastObject = objects[ lastIndex ];\\n\\n\\t\\t\\t\\t\\t\\t// last cached object takes this object's place\\n\\t\\t\\t\\t\\t\\tindicesByUUID[ lastCachedObject.uuid ] = index;\\n\\t\\t\\t\\t\\t\\tobjects[ index ] = lastCachedObject;\\n\\n\\t\\t\\t\\t\\t\\t// last object goes to the activated slot and pop\\n\\t\\t\\t\\t\\t\\tindicesByUUID[ lastObject.uuid ] = firstActiveIndex;\\n\\t\\t\\t\\t\\t\\tobjects[ firstActiveIndex ] = lastObject;\\n\\t\\t\\t\\t\\t\\tobjects.pop();\\n\\n\\t\\t\\t\\t\\t\\t// accounting is done, now do the same for all bindings\\n\\n\\t\\t\\t\\t\\t\\tfor ( var j = 0, m = nBindings; j !== m; ++ j ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar bindingsForPath = bindings[ j ],\\n\\t\\t\\t\\t\\t\\t\\t\\tlastCached = bindingsForPath[ firstActiveIndex ],\\n\\t\\t\\t\\t\\t\\t\\t\\tlast = bindingsForPath[ lastIndex ];\\n\\n\\t\\t\\t\\t\\t\\t\\tbindingsForPath[ index ] = lastCached;\\n\\t\\t\\t\\t\\t\\t\\tbindingsForPath[ firstActiveIndex ] = last;\\n\\t\\t\\t\\t\\t\\t\\tbindingsForPath.pop();\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t// object is active, just swap with the last and pop\\n\\n\\t\\t\\t\\t\\t\\tvar lastIndex = -- nObjects,\\n\\t\\t\\t\\t\\t\\t\\tlastObject = objects[ lastIndex ];\\n\\n\\t\\t\\t\\t\\t\\tindicesByUUID[ lastObject.uuid ] = index;\\n\\t\\t\\t\\t\\t\\tobjects[ index ] = lastObject;\\n\\t\\t\\t\\t\\t\\tobjects.pop();\\n\\n\\t\\t\\t\\t\\t\\t// accounting is done, now do the same for all bindings\\n\\n\\t\\t\\t\\t\\t\\tfor ( var j = 0, m = nBindings; j !== m; ++ j ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar bindingsForPath = bindings[ j ];\\n\\n\\t\\t\\t\\t\\t\\t\\tbindingsForPath[ index ] = bindingsForPath[ lastIndex ];\\n\\t\\t\\t\\t\\t\\t\\tbindingsForPath.pop();\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} // cached or active\\n\\n\\t\\t\\t\\t} // if object is known\\n\\n\\t\\t\\t} // for arguments\\n\\n\\t\\t\\tthis.nCachedObjects_ = nCachedObjects;\\n\\n\\t\\t},\\n\\n\\t\\t// Internal interface used by befriended PropertyBinding.Composite:\\n\\n\\t\\tsubscribe_: function ( path, parsedPath ) {\\n\\n\\t\\t\\t// returns an array of bindings for the given path that is changed\\n\\t\\t\\t// according to the contained objects in the group\\n\\n\\t\\t\\tvar indicesByPath = this._bindingsIndicesByPath,\\n\\t\\t\\t\\tindex = indicesByPath[ path ],\\n\\t\\t\\t\\tbindings = this._bindings;\\n\\n\\t\\t\\tif ( index !== undefined ) return bindings[ index ];\\n\\n\\t\\t\\tvar paths = this._paths,\\n\\t\\t\\t\\tparsedPaths = this._parsedPaths,\\n\\t\\t\\t\\tobjects = this._objects,\\n\\t\\t\\t\\tnObjects = objects.length,\\n\\t\\t\\t\\tnCachedObjects = this.nCachedObjects_,\\n\\t\\t\\t\\tbindingsForPath = new Array( nObjects );\\n\\n\\t\\t\\tindex = bindings.length;\\n\\n\\t\\t\\tindicesByPath[ path ] = index;\\n\\n\\t\\t\\tpaths.push( path );\\n\\t\\t\\tparsedPaths.push( parsedPath );\\n\\t\\t\\tbindings.push( bindingsForPath );\\n\\n\\t\\t\\tfor ( var i = nCachedObjects, n = objects.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tvar object = objects[ i ];\\n\\t\\t\\t\\tbindingsForPath[ i ] = new PropertyBinding( object, path, parsedPath );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn bindingsForPath;\\n\\n\\t\\t},\\n\\n\\t\\tunsubscribe_: function ( path ) {\\n\\n\\t\\t\\t// tells the group to forget about a property path and no longer\\n\\t\\t\\t// update the array previously obtained with 'subscribe_'\\n\\n\\t\\t\\tvar indicesByPath = this._bindingsIndicesByPath,\\n\\t\\t\\t\\tindex = indicesByPath[ path ];\\n\\n\\t\\t\\tif ( index !== undefined ) {\\n\\n\\t\\t\\t\\tvar paths = this._paths,\\n\\t\\t\\t\\t\\tparsedPaths = this._parsedPaths,\\n\\t\\t\\t\\t\\tbindings = this._bindings,\\n\\t\\t\\t\\t\\tlastBindingsIndex = bindings.length - 1,\\n\\t\\t\\t\\t\\tlastBindings = bindings[ lastBindingsIndex ],\\n\\t\\t\\t\\t\\tlastBindingsPath = path[ lastBindingsIndex ];\\n\\n\\t\\t\\t\\tindicesByPath[ lastBindingsPath ] = index;\\n\\n\\t\\t\\t\\tbindings[ index ] = lastBindings;\\n\\t\\t\\t\\tbindings.pop();\\n\\n\\t\\t\\t\\tparsedPaths[ index ] = parsedPaths[ lastBindingsIndex ];\\n\\t\\t\\t\\tparsedPaths.pop();\\n\\n\\t\\t\\t\\tpaths[ index ] = paths[ lastBindingsIndex ];\\n\\t\\t\\t\\tpaths.pop();\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * Action provided by AnimationMixer for scheduling clip playback on specific\\n\\t * objects.\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t *\\n\\t */\\n\\n\\tfunction AnimationAction( mixer, clip, localRoot ) {\\n\\n\\t\\tthis._mixer = mixer;\\n\\t\\tthis._clip = clip;\\n\\t\\tthis._localRoot = localRoot || null;\\n\\n\\t\\tvar tracks = clip.tracks,\\n\\t\\t\\tnTracks = tracks.length,\\n\\t\\t\\tinterpolants = new Array( nTracks );\\n\\n\\t\\tvar interpolantSettings = {\\n\\t\\t\\tendingStart: ZeroCurvatureEnding,\\n\\t\\t\\tendingEnd: ZeroCurvatureEnding\\n\\t\\t};\\n\\n\\t\\tfor ( var i = 0; i !== nTracks; ++ i ) {\\n\\n\\t\\t\\tvar interpolant = tracks[ i ].createInterpolant( null );\\n\\t\\t\\tinterpolants[ i ] = interpolant;\\n\\t\\t\\tinterpolant.settings = interpolantSettings;\\n\\n\\t\\t}\\n\\n\\t\\tthis._interpolantSettings = interpolantSettings;\\n\\n\\t\\tthis._interpolants = interpolants;\\t// bound by the mixer\\n\\n\\t\\t// inside: PropertyMixer (managed by the mixer)\\n\\t\\tthis._propertyBindings = new Array( nTracks );\\n\\n\\t\\tthis._cacheIndex = null;\\t\\t\\t// for the memory manager\\n\\t\\tthis._byClipCacheIndex = null;\\t\\t// for the memory manager\\n\\n\\t\\tthis._timeScaleInterpolant = null;\\n\\t\\tthis._weightInterpolant = null;\\n\\n\\t\\tthis.loop = LoopRepeat;\\n\\t\\tthis._loopCount = - 1;\\n\\n\\t\\t// global mixer time when the action is to be started\\n\\t\\t// it's set back to 'null' upon start of the action\\n\\t\\tthis._startTime = null;\\n\\n\\t\\t// scaled local time of the action\\n\\t\\t// gets clamped or wrapped to 0..clip.duration according to loop\\n\\t\\tthis.time = 0;\\n\\n\\t\\tthis.timeScale = 1;\\n\\t\\tthis._effectiveTimeScale = 1;\\n\\n\\t\\tthis.weight = 1;\\n\\t\\tthis._effectiveWeight = 1;\\n\\n\\t\\tthis.repetitions = Infinity; \\t\\t// no. of repetitions when looping\\n\\n\\t\\tthis.paused = false;\\t\\t\\t\\t// true -> zero effective time scale\\n\\t\\tthis.enabled = true;\\t\\t\\t\\t// false -> zero effective weight\\n\\n\\t\\tthis.clampWhenFinished \\t= false;\\t// keep feeding the last frame?\\n\\n\\t\\tthis.zeroSlopeAtStart \\t= true;\\t\\t// for smooth interpolation w/o separate\\n\\t\\tthis.zeroSlopeAtEnd\\t\\t= true;\\t\\t// clips for start, loop and end\\n\\n\\t}\\n\\n\\tObject.assign( AnimationAction.prototype, {\\n\\n\\t\\t// State & Scheduling\\n\\n\\t\\tplay: function () {\\n\\n\\t\\t\\tthis._mixer._activateAction( this );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tstop: function () {\\n\\n\\t\\t\\tthis._mixer._deactivateAction( this );\\n\\n\\t\\t\\treturn this.reset();\\n\\n\\t\\t},\\n\\n\\t\\treset: function () {\\n\\n\\t\\t\\tthis.paused = false;\\n\\t\\t\\tthis.enabled = true;\\n\\n\\t\\t\\tthis.time = 0;\\t\\t\\t// restart clip\\n\\t\\t\\tthis._loopCount = - 1;\\t// forget previous loops\\n\\t\\t\\tthis._startTime = null;\\t// forget scheduling\\n\\n\\t\\t\\treturn this.stopFading().stopWarping();\\n\\n\\t\\t},\\n\\n\\t\\tisRunning: function () {\\n\\n\\t\\t\\treturn this.enabled && ! this.paused && this.timeScale !== 0 &&\\n\\t\\t\\t\\t\\tthis._startTime === null && this._mixer._isActiveAction( this );\\n\\n\\t\\t},\\n\\n\\t\\t// return true when play has been called\\n\\t\\tisScheduled: function () {\\n\\n\\t\\t\\treturn this._mixer._isActiveAction( this );\\n\\n\\t\\t},\\n\\n\\t\\tstartAt: function ( time ) {\\n\\n\\t\\t\\tthis._startTime = time;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetLoop: function ( mode, repetitions ) {\\n\\n\\t\\t\\tthis.loop = mode;\\n\\t\\t\\tthis.repetitions = repetitions;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// Weight\\n\\n\\t\\t// set the weight stopping any scheduled fading\\n\\t\\t// although .enabled = false yields an effective weight of zero, this\\n\\t\\t// method does *not* change .enabled, because it would be confusing\\n\\t\\tsetEffectiveWeight: function ( weight ) {\\n\\n\\t\\t\\tthis.weight = weight;\\n\\n\\t\\t\\t// note: same logic as when updated at runtime\\n\\t\\t\\tthis._effectiveWeight = this.enabled ? weight : 0;\\n\\n\\t\\t\\treturn this.stopFading();\\n\\n\\t\\t},\\n\\n\\t\\t// return the weight considering fading and .enabled\\n\\t\\tgetEffectiveWeight: function () {\\n\\n\\t\\t\\treturn this._effectiveWeight;\\n\\n\\t\\t},\\n\\n\\t\\tfadeIn: function ( duration ) {\\n\\n\\t\\t\\treturn this._scheduleFading( duration, 0, 1 );\\n\\n\\t\\t},\\n\\n\\t\\tfadeOut: function ( duration ) {\\n\\n\\t\\t\\treturn this._scheduleFading( duration, 1, 0 );\\n\\n\\t\\t},\\n\\n\\t\\tcrossFadeFrom: function ( fadeOutAction, duration, warp ) {\\n\\n\\t\\t\\tfadeOutAction.fadeOut( duration );\\n\\t\\t\\tthis.fadeIn( duration );\\n\\n\\t\\t\\tif ( warp ) {\\n\\n\\t\\t\\t\\tvar fadeInDuration = this._clip.duration,\\n\\t\\t\\t\\t\\tfadeOutDuration = fadeOutAction._clip.duration,\\n\\n\\t\\t\\t\\t\\tstartEndRatio = fadeOutDuration / fadeInDuration,\\n\\t\\t\\t\\t\\tendStartRatio = fadeInDuration / fadeOutDuration;\\n\\n\\t\\t\\t\\tfadeOutAction.warp( 1.0, startEndRatio, duration );\\n\\t\\t\\t\\tthis.warp( endStartRatio, 1.0, duration );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcrossFadeTo: function ( fadeInAction, duration, warp ) {\\n\\n\\t\\t\\treturn fadeInAction.crossFadeFrom( this, duration, warp );\\n\\n\\t\\t},\\n\\n\\t\\tstopFading: function () {\\n\\n\\t\\t\\tvar weightInterpolant = this._weightInterpolant;\\n\\n\\t\\t\\tif ( weightInterpolant !== null ) {\\n\\n\\t\\t\\t\\tthis._weightInterpolant = null;\\n\\t\\t\\t\\tthis._mixer._takeBackControlInterpolant( weightInterpolant );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// Time Scale Control\\n\\n\\t\\t// set the time scale stopping any scheduled warping\\n\\t\\t// although .paused = true yields an effective time scale of zero, this\\n\\t\\t// method does *not* change .paused, because it would be confusing\\n\\t\\tsetEffectiveTimeScale: function ( timeScale ) {\\n\\n\\t\\t\\tthis.timeScale = timeScale;\\n\\t\\t\\tthis._effectiveTimeScale = this.paused ? 0 : timeScale;\\n\\n\\t\\t\\treturn this.stopWarping();\\n\\n\\t\\t},\\n\\n\\t\\t// return the time scale considering warping and .paused\\n\\t\\tgetEffectiveTimeScale: function () {\\n\\n\\t\\t\\treturn this._effectiveTimeScale;\\n\\n\\t\\t},\\n\\n\\t\\tsetDuration: function ( duration ) {\\n\\n\\t\\t\\tthis.timeScale = this._clip.duration / duration;\\n\\n\\t\\t\\treturn this.stopWarping();\\n\\n\\t\\t},\\n\\n\\t\\tsyncWith: function ( action ) {\\n\\n\\t\\t\\tthis.time = action.time;\\n\\t\\t\\tthis.timeScale = action.timeScale;\\n\\n\\t\\t\\treturn this.stopWarping();\\n\\n\\t\\t},\\n\\n\\t\\thalt: function ( duration ) {\\n\\n\\t\\t\\treturn this.warp( this._effectiveTimeScale, 0, duration );\\n\\n\\t\\t},\\n\\n\\t\\twarp: function ( startTimeScale, endTimeScale, duration ) {\\n\\n\\t\\t\\tvar mixer = this._mixer, now = mixer.time,\\n\\t\\t\\t\\tinterpolant = this._timeScaleInterpolant,\\n\\n\\t\\t\\t\\ttimeScale = this.timeScale;\\n\\n\\t\\t\\tif ( interpolant === null ) {\\n\\n\\t\\t\\t\\tinterpolant = mixer._lendControlInterpolant();\\n\\t\\t\\t\\tthis._timeScaleInterpolant = interpolant;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar times = interpolant.parameterPositions,\\n\\t\\t\\t\\tvalues = interpolant.sampleValues;\\n\\n\\t\\t\\ttimes[ 0 ] = now;\\n\\t\\t\\ttimes[ 1 ] = now + duration;\\n\\n\\t\\t\\tvalues[ 0 ] = startTimeScale / timeScale;\\n\\t\\t\\tvalues[ 1 ] = endTimeScale / timeScale;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tstopWarping: function () {\\n\\n\\t\\t\\tvar timeScaleInterpolant = this._timeScaleInterpolant;\\n\\n\\t\\t\\tif ( timeScaleInterpolant !== null ) {\\n\\n\\t\\t\\t\\tthis._timeScaleInterpolant = null;\\n\\t\\t\\t\\tthis._mixer._takeBackControlInterpolant( timeScaleInterpolant );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// Object Accessors\\n\\n\\t\\tgetMixer: function () {\\n\\n\\t\\t\\treturn this._mixer;\\n\\n\\t\\t},\\n\\n\\t\\tgetClip: function () {\\n\\n\\t\\t\\treturn this._clip;\\n\\n\\t\\t},\\n\\n\\t\\tgetRoot: function () {\\n\\n\\t\\t\\treturn this._localRoot || this._mixer._root;\\n\\n\\t\\t},\\n\\n\\t\\t// Interna\\n\\n\\t\\t_update: function ( time, deltaTime, timeDirection, accuIndex ) {\\n\\n\\t\\t\\t// called by the mixer\\n\\n\\t\\t\\tif ( ! this.enabled ) {\\n\\n\\t\\t\\t\\t// call ._updateWeight() to update ._effectiveWeight\\n\\n\\t\\t\\t\\tthis._updateWeight( time );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar startTime = this._startTime;\\n\\n\\t\\t\\tif ( startTime !== null ) {\\n\\n\\t\\t\\t\\t// check for scheduled start of action\\n\\n\\t\\t\\t\\tvar timeRunning = ( time - startTime ) * timeDirection;\\n\\t\\t\\t\\tif ( timeRunning < 0 || timeDirection === 0 ) {\\n\\n\\t\\t\\t\\t\\treturn; // yet to come / don't decide when delta = 0\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// start\\n\\n\\t\\t\\t\\tthis._startTime = null; // unschedule\\n\\t\\t\\t\\tdeltaTime = timeDirection * timeRunning;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// apply time scale and advance time\\n\\n\\t\\t\\tdeltaTime *= this._updateTimeScale( time );\\n\\t\\t\\tvar clipTime = this._updateTime( deltaTime );\\n\\n\\t\\t\\t// note: _updateTime may disable the action resulting in\\n\\t\\t\\t// an effective weight of 0\\n\\n\\t\\t\\tvar weight = this._updateWeight( time );\\n\\n\\t\\t\\tif ( weight > 0 ) {\\n\\n\\t\\t\\t\\tvar interpolants = this._interpolants;\\n\\t\\t\\t\\tvar propertyMixers = this._propertyBindings;\\n\\n\\t\\t\\t\\tfor ( var j = 0, m = interpolants.length; j !== m; ++ j ) {\\n\\n\\t\\t\\t\\t\\tinterpolants[ j ].evaluate( clipTime );\\n\\t\\t\\t\\t\\tpropertyMixers[ j ].accumulate( accuIndex, weight );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t_updateWeight: function ( time ) {\\n\\n\\t\\t\\tvar weight = 0;\\n\\n\\t\\t\\tif ( this.enabled ) {\\n\\n\\t\\t\\t\\tweight = this.weight;\\n\\t\\t\\t\\tvar interpolant = this._weightInterpolant;\\n\\n\\t\\t\\t\\tif ( interpolant !== null ) {\\n\\n\\t\\t\\t\\t\\tvar interpolantValue = interpolant.evaluate( time )[ 0 ];\\n\\n\\t\\t\\t\\t\\tweight *= interpolantValue;\\n\\n\\t\\t\\t\\t\\tif ( time > interpolant.parameterPositions[ 1 ] ) {\\n\\n\\t\\t\\t\\t\\t\\tthis.stopFading();\\n\\n\\t\\t\\t\\t\\t\\tif ( interpolantValue === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// faded out, disable\\n\\t\\t\\t\\t\\t\\t\\tthis.enabled = false;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis._effectiveWeight = weight;\\n\\t\\t\\treturn weight;\\n\\n\\t\\t},\\n\\n\\t\\t_updateTimeScale: function ( time ) {\\n\\n\\t\\t\\tvar timeScale = 0;\\n\\n\\t\\t\\tif ( ! this.paused ) {\\n\\n\\t\\t\\t\\ttimeScale = this.timeScale;\\n\\n\\t\\t\\t\\tvar interpolant = this._timeScaleInterpolant;\\n\\n\\t\\t\\t\\tif ( interpolant !== null ) {\\n\\n\\t\\t\\t\\t\\tvar interpolantValue = interpolant.evaluate( time )[ 0 ];\\n\\n\\t\\t\\t\\t\\ttimeScale *= interpolantValue;\\n\\n\\t\\t\\t\\t\\tif ( time > interpolant.parameterPositions[ 1 ] ) {\\n\\n\\t\\t\\t\\t\\t\\tthis.stopWarping();\\n\\n\\t\\t\\t\\t\\t\\tif ( timeScale === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// motion has halted, pause\\n\\t\\t\\t\\t\\t\\t\\tthis.paused = true;\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t// warp done - apply final time scale\\n\\t\\t\\t\\t\\t\\t\\tthis.timeScale = timeScale;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis._effectiveTimeScale = timeScale;\\n\\t\\t\\treturn timeScale;\\n\\n\\t\\t},\\n\\n\\t\\t_updateTime: function ( deltaTime ) {\\n\\n\\t\\t\\tvar time = this.time + deltaTime;\\n\\n\\t\\t\\tif ( deltaTime === 0 ) return time;\\n\\n\\t\\t\\tvar duration = this._clip.duration,\\n\\n\\t\\t\\t\\tloop = this.loop,\\n\\t\\t\\t\\tloopCount = this._loopCount;\\n\\n\\t\\t\\tif ( loop === LoopOnce ) {\\n\\n\\t\\t\\t\\tif ( loopCount === - 1 ) {\\n\\n\\t\\t\\t\\t\\t// just started\\n\\n\\t\\t\\t\\t\\tthis._loopCount = 0;\\n\\t\\t\\t\\t\\tthis._setEndings( true, true, false );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\thandle_stop: {\\n\\n\\t\\t\\t\\t\\tif ( time >= duration ) {\\n\\n\\t\\t\\t\\t\\t\\ttime = duration;\\n\\n\\t\\t\\t\\t\\t} else if ( time < 0 ) {\\n\\n\\t\\t\\t\\t\\t\\ttime = 0;\\n\\n\\t\\t\\t\\t\\t} else break handle_stop;\\n\\n\\t\\t\\t\\t\\tif ( this.clampWhenFinished ) this.paused = true;\\n\\t\\t\\t\\t\\telse this.enabled = false;\\n\\n\\t\\t\\t\\t\\tthis._mixer.dispatchEvent( {\\n\\t\\t\\t\\t\\t\\ttype: 'finished', action: this,\\n\\t\\t\\t\\t\\t\\tdirection: deltaTime < 0 ? - 1 : 1\\n\\t\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else { // repetitive Repeat or PingPong\\n\\n\\t\\t\\t\\tvar pingPong = ( loop === LoopPingPong );\\n\\n\\t\\t\\t\\tif ( loopCount === - 1 ) {\\n\\n\\t\\t\\t\\t\\t// just started\\n\\n\\t\\t\\t\\t\\tif ( deltaTime >= 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tloopCount = 0;\\n\\n\\t\\t\\t\\t\\t\\tthis._setEndings( true, this.repetitions === 0, pingPong );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t// when looping in reverse direction, the initial\\n\\t\\t\\t\\t\\t\\t// transition through zero counts as a repetition,\\n\\t\\t\\t\\t\\t\\t// so leave loopCount at -1\\n\\n\\t\\t\\t\\t\\t\\tthis._setEndings( this.repetitions === 0, true, pingPong );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( time >= duration || time < 0 ) {\\n\\n\\t\\t\\t\\t\\t// wrap around\\n\\n\\t\\t\\t\\t\\tvar loopDelta = Math.floor( time / duration ); // signed\\n\\t\\t\\t\\t\\ttime -= duration * loopDelta;\\n\\n\\t\\t\\t\\t\\tloopCount += Math.abs( loopDelta );\\n\\n\\t\\t\\t\\t\\tvar pending = this.repetitions - loopCount;\\n\\n\\t\\t\\t\\t\\tif ( pending < 0 ) {\\n\\n\\t\\t\\t\\t\\t\\t// have to stop (switch state, clamp time, fire event)\\n\\n\\t\\t\\t\\t\\t\\tif ( this.clampWhenFinished ) this.paused = true;\\n\\t\\t\\t\\t\\t\\telse this.enabled = false;\\n\\n\\t\\t\\t\\t\\t\\ttime = deltaTime > 0 ? duration : 0;\\n\\n\\t\\t\\t\\t\\t\\tthis._mixer.dispatchEvent( {\\n\\t\\t\\t\\t\\t\\t\\ttype: 'finished', action: this,\\n\\t\\t\\t\\t\\t\\t\\tdirection: deltaTime > 0 ? 1 : - 1\\n\\t\\t\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t// keep running\\n\\n\\t\\t\\t\\t\\t\\tif ( pending === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// entering the last round\\n\\n\\t\\t\\t\\t\\t\\t\\tvar atStart = deltaTime < 0;\\n\\t\\t\\t\\t\\t\\t\\tthis._setEndings( atStart, ! atStart, pingPong );\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tthis._setEndings( false, false, pingPong );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tthis._loopCount = loopCount;\\n\\n\\t\\t\\t\\t\\t\\tthis._mixer.dispatchEvent( {\\n\\t\\t\\t\\t\\t\\t\\ttype: 'loop', action: this, loopDelta: loopDelta\\n\\t\\t\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( pingPong && ( loopCount & 1 ) === 1 ) {\\n\\n\\t\\t\\t\\t\\t// invert time for the \\\"pong round\\\"\\n\\n\\t\\t\\t\\t\\tthis.time = time;\\n\\t\\t\\t\\t\\treturn duration - time;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.time = time;\\n\\t\\t\\treturn time;\\n\\n\\t\\t},\\n\\n\\t\\t_setEndings: function ( atStart, atEnd, pingPong ) {\\n\\n\\t\\t\\tvar settings = this._interpolantSettings;\\n\\n\\t\\t\\tif ( pingPong ) {\\n\\n\\t\\t\\t\\tsettings.endingStart \\t= ZeroSlopeEnding;\\n\\t\\t\\t\\tsettings.endingEnd\\t\\t= ZeroSlopeEnding;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// assuming for LoopOnce atStart == atEnd == true\\n\\n\\t\\t\\t\\tif ( atStart ) {\\n\\n\\t\\t\\t\\t\\tsettings.endingStart = this.zeroSlopeAtStart ? ZeroSlopeEnding : ZeroCurvatureEnding;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tsettings.endingStart = WrapAroundEnding;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( atEnd ) {\\n\\n\\t\\t\\t\\t\\tsettings.endingEnd = this.zeroSlopeAtEnd ? ZeroSlopeEnding : ZeroCurvatureEnding;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tsettings.endingEnd \\t = WrapAroundEnding;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t_scheduleFading: function ( duration, weightNow, weightThen ) {\\n\\n\\t\\t\\tvar mixer = this._mixer, now = mixer.time,\\n\\t\\t\\t\\tinterpolant = this._weightInterpolant;\\n\\n\\t\\t\\tif ( interpolant === null ) {\\n\\n\\t\\t\\t\\tinterpolant = mixer._lendControlInterpolant();\\n\\t\\t\\t\\tthis._weightInterpolant = interpolant;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar times = interpolant.parameterPositions,\\n\\t\\t\\t\\tvalues = interpolant.sampleValues;\\n\\n\\t\\t\\ttimes[ 0 ] = now; \\t\\t\\t\\tvalues[ 0 ] = weightNow;\\n\\t\\t\\ttimes[ 1 ] = now + duration;\\tvalues[ 1 ] = weightThen;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * Player for AnimationClips.\\n\\t *\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction AnimationMixer( root ) {\\n\\n\\t\\tthis._root = root;\\n\\t\\tthis._initMemoryManager();\\n\\t\\tthis._accuIndex = 0;\\n\\n\\t\\tthis.time = 0;\\n\\n\\t\\tthis.timeScale = 1.0;\\n\\n\\t}\\n\\n\\tAnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {\\n\\n\\t\\tconstructor: AnimationMixer,\\n\\n\\t\\t_bindAction: function ( action, prototypeAction ) {\\n\\n\\t\\t\\tvar root = action._localRoot || this._root,\\n\\t\\t\\t\\ttracks = action._clip.tracks,\\n\\t\\t\\t\\tnTracks = tracks.length,\\n\\t\\t\\t\\tbindings = action._propertyBindings,\\n\\t\\t\\t\\tinterpolants = action._interpolants,\\n\\t\\t\\t\\trootUuid = root.uuid,\\n\\t\\t\\t\\tbindingsByRoot = this._bindingsByRootAndName,\\n\\t\\t\\t\\tbindingsByName = bindingsByRoot[ rootUuid ];\\n\\n\\t\\t\\tif ( bindingsByName === undefined ) {\\n\\n\\t\\t\\t\\tbindingsByName = {};\\n\\t\\t\\t\\tbindingsByRoot[ rootUuid ] = bindingsByName;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = 0; i !== nTracks; ++ i ) {\\n\\n\\t\\t\\t\\tvar track = tracks[ i ],\\n\\t\\t\\t\\t\\ttrackName = track.name,\\n\\t\\t\\t\\t\\tbinding = bindingsByName[ trackName ];\\n\\n\\t\\t\\t\\tif ( binding !== undefined ) {\\n\\n\\t\\t\\t\\t\\tbindings[ i ] = binding;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tbinding = bindings[ i ];\\n\\n\\t\\t\\t\\t\\tif ( binding !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t// existing binding, make sure the cache knows\\n\\n\\t\\t\\t\\t\\t\\tif ( binding._cacheIndex === null ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t++ binding.referenceCount;\\n\\t\\t\\t\\t\\t\\t\\tthis._addInactiveBinding( binding, rootUuid, trackName );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tvar path = prototypeAction && prototypeAction.\\n\\t\\t\\t\\t\\t\\t_propertyBindings[ i ].binding.parsedPath;\\n\\n\\t\\t\\t\\t\\tbinding = new PropertyMixer(\\n\\t\\t\\t\\t\\t\\tPropertyBinding.create( root, trackName, path ),\\n\\t\\t\\t\\t\\t\\ttrack.ValueTypeName, track.getValueSize() );\\n\\n\\t\\t\\t\\t\\t++ binding.referenceCount;\\n\\t\\t\\t\\t\\tthis._addInactiveBinding( binding, rootUuid, trackName );\\n\\n\\t\\t\\t\\t\\tbindings[ i ] = binding;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tinterpolants[ i ].resultBuffer = binding.buffer;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t_activateAction: function ( action ) {\\n\\n\\t\\t\\tif ( ! this._isActiveAction( action ) ) {\\n\\n\\t\\t\\t\\tif ( action._cacheIndex === null ) {\\n\\n\\t\\t\\t\\t\\t// this action has been forgotten by the cache, but the user\\n\\t\\t\\t\\t\\t// appears to be still using it -> rebind\\n\\n\\t\\t\\t\\t\\tvar rootUuid = ( action._localRoot || this._root ).uuid,\\n\\t\\t\\t\\t\\t\\tclipUuid = action._clip.uuid,\\n\\t\\t\\t\\t\\t\\tactionsForClip = this._actionsByClip[ clipUuid ];\\n\\n\\t\\t\\t\\t\\tthis._bindAction( action,\\n\\t\\t\\t\\t\\t\\tactionsForClip && actionsForClip.knownActions[ 0 ] );\\n\\n\\t\\t\\t\\t\\tthis._addInactiveAction( action, clipUuid, rootUuid );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar bindings = action._propertyBindings;\\n\\n\\t\\t\\t\\t// increment reference counts / sort out state\\n\\t\\t\\t\\tfor ( var i = 0, n = bindings.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\tvar binding = bindings[ i ];\\n\\n\\t\\t\\t\\t\\tif ( binding.useCount ++ === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tthis._lendBinding( binding );\\n\\t\\t\\t\\t\\t\\tbinding.saveOriginalState();\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis._lendAction( action );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t_deactivateAction: function ( action ) {\\n\\n\\t\\t\\tif ( this._isActiveAction( action ) ) {\\n\\n\\t\\t\\t\\tvar bindings = action._propertyBindings;\\n\\n\\t\\t\\t\\t// decrement reference counts / sort out state\\n\\t\\t\\t\\tfor ( var i = 0, n = bindings.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\tvar binding = bindings[ i ];\\n\\n\\t\\t\\t\\t\\tif ( -- binding.useCount === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tbinding.restoreOriginalState();\\n\\t\\t\\t\\t\\t\\tthis._takeBackBinding( binding );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis._takeBackAction( action );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t// Memory manager\\n\\n\\t\\t_initMemoryManager: function () {\\n\\n\\t\\t\\tthis._actions = []; // 'nActiveActions' followed by inactive ones\\n\\t\\t\\tthis._nActiveActions = 0;\\n\\n\\t\\t\\tthis._actionsByClip = {};\\n\\t\\t\\t// inside:\\n\\t\\t\\t// {\\n\\t\\t\\t// \\t\\tknownActions: Array< AnimationAction >\\t- used as prototypes\\n\\t\\t\\t// \\t\\tactionByRoot: AnimationAction\\t\\t\\t- lookup\\n\\t\\t\\t// }\\n\\n\\n\\t\\t\\tthis._bindings = []; // 'nActiveBindings' followed by inactive ones\\n\\t\\t\\tthis._nActiveBindings = 0;\\n\\n\\t\\t\\tthis._bindingsByRootAndName = {}; // inside: Map< name, PropertyMixer >\\n\\n\\n\\t\\t\\tthis._controlInterpolants = []; // same game as above\\n\\t\\t\\tthis._nActiveControlInterpolants = 0;\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tthis.stats = {\\n\\n\\t\\t\\t\\tactions: {\\n\\t\\t\\t\\t\\tget total() {\\n\\n\\t\\t\\t\\t\\t\\treturn scope._actions.length;\\n\\n\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\tget inUse() {\\n\\n\\t\\t\\t\\t\\t\\treturn scope._nActiveActions;\\n\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t},\\n\\t\\t\\t\\tbindings: {\\n\\t\\t\\t\\t\\tget total() {\\n\\n\\t\\t\\t\\t\\t\\treturn scope._bindings.length;\\n\\n\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\tget inUse() {\\n\\n\\t\\t\\t\\t\\t\\treturn scope._nActiveBindings;\\n\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t},\\n\\t\\t\\t\\tcontrolInterpolants: {\\n\\t\\t\\t\\t\\tget total() {\\n\\n\\t\\t\\t\\t\\t\\treturn scope._controlInterpolants.length;\\n\\n\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\tget inUse() {\\n\\n\\t\\t\\t\\t\\t\\treturn scope._nActiveControlInterpolants;\\n\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t},\\n\\n\\t\\t// Memory management for AnimationAction objects\\n\\n\\t\\t_isActiveAction: function ( action ) {\\n\\n\\t\\t\\tvar index = action._cacheIndex;\\n\\t\\t\\treturn index !== null && index < this._nActiveActions;\\n\\n\\t\\t},\\n\\n\\t\\t_addInactiveAction: function ( action, clipUuid, rootUuid ) {\\n\\n\\t\\t\\tvar actions = this._actions,\\n\\t\\t\\t\\tactionsByClip = this._actionsByClip,\\n\\t\\t\\t\\tactionsForClip = actionsByClip[ clipUuid ];\\n\\n\\t\\t\\tif ( actionsForClip === undefined ) {\\n\\n\\t\\t\\t\\tactionsForClip = {\\n\\n\\t\\t\\t\\t\\tknownActions: [ action ],\\n\\t\\t\\t\\t\\tactionByRoot: {}\\n\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\taction._byClipCacheIndex = 0;\\n\\n\\t\\t\\t\\tactionsByClip[ clipUuid ] = actionsForClip;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tvar knownActions = actionsForClip.knownActions;\\n\\n\\t\\t\\t\\taction._byClipCacheIndex = knownActions.length;\\n\\t\\t\\t\\tknownActions.push( action );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\taction._cacheIndex = actions.length;\\n\\t\\t\\tactions.push( action );\\n\\n\\t\\t\\tactionsForClip.actionByRoot[ rootUuid ] = action;\\n\\n\\t\\t},\\n\\n\\t\\t_removeInactiveAction: function ( action ) {\\n\\n\\t\\t\\tvar actions = this._actions,\\n\\t\\t\\t\\tlastInactiveAction = actions[ actions.length - 1 ],\\n\\t\\t\\t\\tcacheIndex = action._cacheIndex;\\n\\n\\t\\t\\tlastInactiveAction._cacheIndex = cacheIndex;\\n\\t\\t\\tactions[ cacheIndex ] = lastInactiveAction;\\n\\t\\t\\tactions.pop();\\n\\n\\t\\t\\taction._cacheIndex = null;\\n\\n\\n\\t\\t\\tvar clipUuid = action._clip.uuid,\\n\\t\\t\\t\\tactionsByClip = this._actionsByClip,\\n\\t\\t\\t\\tactionsForClip = actionsByClip[ clipUuid ],\\n\\t\\t\\t\\tknownActionsForClip = actionsForClip.knownActions,\\n\\n\\t\\t\\t\\tlastKnownAction =\\n\\t\\t\\t\\t\\tknownActionsForClip[ knownActionsForClip.length - 1 ],\\n\\n\\t\\t\\t\\tbyClipCacheIndex = action._byClipCacheIndex;\\n\\n\\t\\t\\tlastKnownAction._byClipCacheIndex = byClipCacheIndex;\\n\\t\\t\\tknownActionsForClip[ byClipCacheIndex ] = lastKnownAction;\\n\\t\\t\\tknownActionsForClip.pop();\\n\\n\\t\\t\\taction._byClipCacheIndex = null;\\n\\n\\n\\t\\t\\tvar actionByRoot = actionsForClip.actionByRoot,\\n\\t\\t\\t\\trootUuid = ( action._localRoot || this._root ).uuid;\\n\\n\\t\\t\\tdelete actionByRoot[ rootUuid ];\\n\\n\\t\\t\\tif ( knownActionsForClip.length === 0 ) {\\n\\n\\t\\t\\t\\tdelete actionsByClip[ clipUuid ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis._removeInactiveBindingsForAction( action );\\n\\n\\t\\t},\\n\\n\\t\\t_removeInactiveBindingsForAction: function ( action ) {\\n\\n\\t\\t\\tvar bindings = action._propertyBindings;\\n\\t\\t\\tfor ( var i = 0, n = bindings.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tvar binding = bindings[ i ];\\n\\n\\t\\t\\t\\tif ( -- binding.referenceCount === 0 ) {\\n\\n\\t\\t\\t\\t\\tthis._removeInactiveBinding( binding );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t_lendAction: function ( action ) {\\n\\n\\t\\t\\t// [ active actions | inactive actions ]\\n\\t\\t\\t// [ active actions >| inactive actions ]\\n\\t\\t\\t// s a\\n\\t\\t\\t// <-swap->\\n\\t\\t\\t// a s\\n\\n\\t\\t\\tvar actions = this._actions,\\n\\t\\t\\t\\tprevIndex = action._cacheIndex,\\n\\n\\t\\t\\t\\tlastActiveIndex = this._nActiveActions ++,\\n\\n\\t\\t\\t\\tfirstInactiveAction = actions[ lastActiveIndex ];\\n\\n\\t\\t\\taction._cacheIndex = lastActiveIndex;\\n\\t\\t\\tactions[ lastActiveIndex ] = action;\\n\\n\\t\\t\\tfirstInactiveAction._cacheIndex = prevIndex;\\n\\t\\t\\tactions[ prevIndex ] = firstInactiveAction;\\n\\n\\t\\t},\\n\\n\\t\\t_takeBackAction: function ( action ) {\\n\\n\\t\\t\\t// [ active actions | inactive actions ]\\n\\t\\t\\t// [ active actions |< inactive actions ]\\n\\t\\t\\t// a s\\n\\t\\t\\t// <-swap->\\n\\t\\t\\t// s a\\n\\n\\t\\t\\tvar actions = this._actions,\\n\\t\\t\\t\\tprevIndex = action._cacheIndex,\\n\\n\\t\\t\\t\\tfirstInactiveIndex = -- this._nActiveActions,\\n\\n\\t\\t\\t\\tlastActiveAction = actions[ firstInactiveIndex ];\\n\\n\\t\\t\\taction._cacheIndex = firstInactiveIndex;\\n\\t\\t\\tactions[ firstInactiveIndex ] = action;\\n\\n\\t\\t\\tlastActiveAction._cacheIndex = prevIndex;\\n\\t\\t\\tactions[ prevIndex ] = lastActiveAction;\\n\\n\\t\\t},\\n\\n\\t\\t// Memory management for PropertyMixer objects\\n\\n\\t\\t_addInactiveBinding: function ( binding, rootUuid, trackName ) {\\n\\n\\t\\t\\tvar bindingsByRoot = this._bindingsByRootAndName,\\n\\t\\t\\t\\tbindingByName = bindingsByRoot[ rootUuid ],\\n\\n\\t\\t\\t\\tbindings = this._bindings;\\n\\n\\t\\t\\tif ( bindingByName === undefined ) {\\n\\n\\t\\t\\t\\tbindingByName = {};\\n\\t\\t\\t\\tbindingsByRoot[ rootUuid ] = bindingByName;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tbindingByName[ trackName ] = binding;\\n\\n\\t\\t\\tbinding._cacheIndex = bindings.length;\\n\\t\\t\\tbindings.push( binding );\\n\\n\\t\\t},\\n\\n\\t\\t_removeInactiveBinding: function ( binding ) {\\n\\n\\t\\t\\tvar bindings = this._bindings,\\n\\t\\t\\t\\tpropBinding = binding.binding,\\n\\t\\t\\t\\trootUuid = propBinding.rootNode.uuid,\\n\\t\\t\\t\\ttrackName = propBinding.path,\\n\\t\\t\\t\\tbindingsByRoot = this._bindingsByRootAndName,\\n\\t\\t\\t\\tbindingByName = bindingsByRoot[ rootUuid ],\\n\\n\\t\\t\\t\\tlastInactiveBinding = bindings[ bindings.length - 1 ],\\n\\t\\t\\t\\tcacheIndex = binding._cacheIndex;\\n\\n\\t\\t\\tlastInactiveBinding._cacheIndex = cacheIndex;\\n\\t\\t\\tbindings[ cacheIndex ] = lastInactiveBinding;\\n\\t\\t\\tbindings.pop();\\n\\n\\t\\t\\tdelete bindingByName[ trackName ];\\n\\n\\t\\t\\tremove_empty_map: {\\n\\n\\t\\t\\t\\tfor ( var _ in bindingByName ) break remove_empty_map; // eslint-disable-line no-unused-vars\\n\\n\\t\\t\\t\\tdelete bindingsByRoot[ rootUuid ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t_lendBinding: function ( binding ) {\\n\\n\\t\\t\\tvar bindings = this._bindings,\\n\\t\\t\\t\\tprevIndex = binding._cacheIndex,\\n\\n\\t\\t\\t\\tlastActiveIndex = this._nActiveBindings ++,\\n\\n\\t\\t\\t\\tfirstInactiveBinding = bindings[ lastActiveIndex ];\\n\\n\\t\\t\\tbinding._cacheIndex = lastActiveIndex;\\n\\t\\t\\tbindings[ lastActiveIndex ] = binding;\\n\\n\\t\\t\\tfirstInactiveBinding._cacheIndex = prevIndex;\\n\\t\\t\\tbindings[ prevIndex ] = firstInactiveBinding;\\n\\n\\t\\t},\\n\\n\\t\\t_takeBackBinding: function ( binding ) {\\n\\n\\t\\t\\tvar bindings = this._bindings,\\n\\t\\t\\t\\tprevIndex = binding._cacheIndex,\\n\\n\\t\\t\\t\\tfirstInactiveIndex = -- this._nActiveBindings,\\n\\n\\t\\t\\t\\tlastActiveBinding = bindings[ firstInactiveIndex ];\\n\\n\\t\\t\\tbinding._cacheIndex = firstInactiveIndex;\\n\\t\\t\\tbindings[ firstInactiveIndex ] = binding;\\n\\n\\t\\t\\tlastActiveBinding._cacheIndex = prevIndex;\\n\\t\\t\\tbindings[ prevIndex ] = lastActiveBinding;\\n\\n\\t\\t},\\n\\n\\n\\t\\t// Memory management of Interpolants for weight and time scale\\n\\n\\t\\t_lendControlInterpolant: function () {\\n\\n\\t\\t\\tvar interpolants = this._controlInterpolants,\\n\\t\\t\\t\\tlastActiveIndex = this._nActiveControlInterpolants ++,\\n\\t\\t\\t\\tinterpolant = interpolants[ lastActiveIndex ];\\n\\n\\t\\t\\tif ( interpolant === undefined ) {\\n\\n\\t\\t\\t\\tinterpolant = new LinearInterpolant(\\n\\t\\t\\t\\t\\tnew Float32Array( 2 ), new Float32Array( 2 ),\\n\\t\\t\\t\\t\\t1, this._controlInterpolantsResultBuffer );\\n\\n\\t\\t\\t\\tinterpolant.__cacheIndex = lastActiveIndex;\\n\\t\\t\\t\\tinterpolants[ lastActiveIndex ] = interpolant;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn interpolant;\\n\\n\\t\\t},\\n\\n\\t\\t_takeBackControlInterpolant: function ( interpolant ) {\\n\\n\\t\\t\\tvar interpolants = this._controlInterpolants,\\n\\t\\t\\t\\tprevIndex = interpolant.__cacheIndex,\\n\\n\\t\\t\\t\\tfirstInactiveIndex = -- this._nActiveControlInterpolants,\\n\\n\\t\\t\\t\\tlastActiveInterpolant = interpolants[ firstInactiveIndex ];\\n\\n\\t\\t\\tinterpolant.__cacheIndex = firstInactiveIndex;\\n\\t\\t\\tinterpolants[ firstInactiveIndex ] = interpolant;\\n\\n\\t\\t\\tlastActiveInterpolant.__cacheIndex = prevIndex;\\n\\t\\t\\tinterpolants[ prevIndex ] = lastActiveInterpolant;\\n\\n\\t\\t},\\n\\n\\t\\t_controlInterpolantsResultBuffer: new Float32Array( 1 ),\\n\\n\\t\\t// return an action for a clip optionally using a custom root target\\n\\t\\t// object (this method allocates a lot of dynamic memory in case a\\n\\t\\t// previously unknown clip/root combination is specified)\\n\\t\\tclipAction: function ( clip, optionalRoot ) {\\n\\n\\t\\t\\tvar root = optionalRoot || this._root,\\n\\t\\t\\t\\trootUuid = root.uuid,\\n\\n\\t\\t\\t\\tclipObject = typeof clip === 'string' ?\\n\\t\\t\\t\\t\\tAnimationClip.findByName( root, clip ) : clip,\\n\\n\\t\\t\\t\\tclipUuid = clipObject !== null ? clipObject.uuid : clip,\\n\\n\\t\\t\\t\\tactionsForClip = this._actionsByClip[ clipUuid ],\\n\\t\\t\\t\\tprototypeAction = null;\\n\\n\\t\\t\\tif ( actionsForClip !== undefined ) {\\n\\n\\t\\t\\t\\tvar existingAction =\\n\\t\\t\\t\\t\\t\\tactionsForClip.actionByRoot[ rootUuid ];\\n\\n\\t\\t\\t\\tif ( existingAction !== undefined ) {\\n\\n\\t\\t\\t\\t\\treturn existingAction;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// we know the clip, so we don't have to parse all\\n\\t\\t\\t\\t// the bindings again but can just copy\\n\\t\\t\\t\\tprototypeAction = actionsForClip.knownActions[ 0 ];\\n\\n\\t\\t\\t\\t// also, take the clip from the prototype action\\n\\t\\t\\t\\tif ( clipObject === null )\\n\\t\\t\\t\\t\\tclipObject = prototypeAction._clip;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// clip must be known when specified via string\\n\\t\\t\\tif ( clipObject === null ) return null;\\n\\n\\t\\t\\t// allocate all resources required to run it\\n\\t\\t\\tvar newAction = new AnimationAction( this, clipObject, optionalRoot );\\n\\n\\t\\t\\tthis._bindAction( newAction, prototypeAction );\\n\\n\\t\\t\\t// and make the action known to the memory manager\\n\\t\\t\\tthis._addInactiveAction( newAction, clipUuid, rootUuid );\\n\\n\\t\\t\\treturn newAction;\\n\\n\\t\\t},\\n\\n\\t\\t// get an existing action\\n\\t\\texistingAction: function ( clip, optionalRoot ) {\\n\\n\\t\\t\\tvar root = optionalRoot || this._root,\\n\\t\\t\\t\\trootUuid = root.uuid,\\n\\n\\t\\t\\t\\tclipObject = typeof clip === 'string' ?\\n\\t\\t\\t\\t\\tAnimationClip.findByName( root, clip ) : clip,\\n\\n\\t\\t\\t\\tclipUuid = clipObject ? clipObject.uuid : clip,\\n\\n\\t\\t\\t\\tactionsForClip = this._actionsByClip[ clipUuid ];\\n\\n\\t\\t\\tif ( actionsForClip !== undefined ) {\\n\\n\\t\\t\\t\\treturn actionsForClip.actionByRoot[ rootUuid ] || null;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn null;\\n\\n\\t\\t},\\n\\n\\t\\t// deactivates all previously scheduled actions\\n\\t\\tstopAllAction: function () {\\n\\n\\t\\t\\tvar actions = this._actions,\\n\\t\\t\\t\\tnActions = this._nActiveActions,\\n\\t\\t\\t\\tbindings = this._bindings,\\n\\t\\t\\t\\tnBindings = this._nActiveBindings;\\n\\n\\t\\t\\tthis._nActiveActions = 0;\\n\\t\\t\\tthis._nActiveBindings = 0;\\n\\n\\t\\t\\tfor ( var i = 0; i !== nActions; ++ i ) {\\n\\n\\t\\t\\t\\tactions[ i ].reset();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = 0; i !== nBindings; ++ i ) {\\n\\n\\t\\t\\t\\tbindings[ i ].useCount = 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// advance the time and update apply the animation\\n\\t\\tupdate: function ( deltaTime ) {\\n\\n\\t\\t\\tdeltaTime *= this.timeScale;\\n\\n\\t\\t\\tvar actions = this._actions,\\n\\t\\t\\t\\tnActions = this._nActiveActions,\\n\\n\\t\\t\\t\\ttime = this.time += deltaTime,\\n\\t\\t\\t\\ttimeDirection = Math.sign( deltaTime ),\\n\\n\\t\\t\\t\\taccuIndex = this._accuIndex ^= 1;\\n\\n\\t\\t\\t// run active actions\\n\\n\\t\\t\\tfor ( var i = 0; i !== nActions; ++ i ) {\\n\\n\\t\\t\\t\\tvar action = actions[ i ];\\n\\n\\t\\t\\t\\taction._update( time, deltaTime, timeDirection, accuIndex );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// update scene graph\\n\\n\\t\\t\\tvar bindings = this._bindings,\\n\\t\\t\\t\\tnBindings = this._nActiveBindings;\\n\\n\\t\\t\\tfor ( var i = 0; i !== nBindings; ++ i ) {\\n\\n\\t\\t\\t\\tbindings[ i ].apply( accuIndex );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// return this mixer's root target object\\n\\t\\tgetRoot: function () {\\n\\n\\t\\t\\treturn this._root;\\n\\n\\t\\t},\\n\\n\\t\\t// free all resources specific to a particular clip\\n\\t\\tuncacheClip: function ( clip ) {\\n\\n\\t\\t\\tvar actions = this._actions,\\n\\t\\t\\t\\tclipUuid = clip.uuid,\\n\\t\\t\\t\\tactionsByClip = this._actionsByClip,\\n\\t\\t\\t\\tactionsForClip = actionsByClip[ clipUuid ];\\n\\n\\t\\t\\tif ( actionsForClip !== undefined ) {\\n\\n\\t\\t\\t\\t// note: just calling _removeInactiveAction would mess up the\\n\\t\\t\\t\\t// iteration state and also require updating the state we can\\n\\t\\t\\t\\t// just throw away\\n\\n\\t\\t\\t\\tvar actionsToRemove = actionsForClip.knownActions;\\n\\n\\t\\t\\t\\tfor ( var i = 0, n = actionsToRemove.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\tvar action = actionsToRemove[ i ];\\n\\n\\t\\t\\t\\t\\tthis._deactivateAction( action );\\n\\n\\t\\t\\t\\t\\tvar cacheIndex = action._cacheIndex,\\n\\t\\t\\t\\t\\t\\tlastInactiveAction = actions[ actions.length - 1 ];\\n\\n\\t\\t\\t\\t\\taction._cacheIndex = null;\\n\\t\\t\\t\\t\\taction._byClipCacheIndex = null;\\n\\n\\t\\t\\t\\t\\tlastInactiveAction._cacheIndex = cacheIndex;\\n\\t\\t\\t\\t\\tactions[ cacheIndex ] = lastInactiveAction;\\n\\t\\t\\t\\t\\tactions.pop();\\n\\n\\t\\t\\t\\t\\tthis._removeInactiveBindingsForAction( action );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tdelete actionsByClip[ clipUuid ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t// free all resources specific to a particular root target object\\n\\t\\tuncacheRoot: function ( root ) {\\n\\n\\t\\t\\tvar rootUuid = root.uuid,\\n\\t\\t\\t\\tactionsByClip = this._actionsByClip;\\n\\n\\t\\t\\tfor ( var clipUuid in actionsByClip ) {\\n\\n\\t\\t\\t\\tvar actionByRoot = actionsByClip[ clipUuid ].actionByRoot,\\n\\t\\t\\t\\t\\taction = actionByRoot[ rootUuid ];\\n\\n\\t\\t\\t\\tif ( action !== undefined ) {\\n\\n\\t\\t\\t\\t\\tthis._deactivateAction( action );\\n\\t\\t\\t\\t\\tthis._removeInactiveAction( action );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar bindingsByRoot = this._bindingsByRootAndName,\\n\\t\\t\\t\\tbindingByName = bindingsByRoot[ rootUuid ];\\n\\n\\t\\t\\tif ( bindingByName !== undefined ) {\\n\\n\\t\\t\\t\\tfor ( var trackName in bindingByName ) {\\n\\n\\t\\t\\t\\t\\tvar binding = bindingByName[ trackName ];\\n\\t\\t\\t\\t\\tbinding.restoreOriginalState();\\n\\t\\t\\t\\t\\tthis._removeInactiveBinding( binding );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t// remove a targeted clip from the cache\\n\\t\\tuncacheAction: function ( clip, optionalRoot ) {\\n\\n\\t\\t\\tvar action = this.existingAction( clip, optionalRoot );\\n\\n\\t\\t\\tif ( action !== null ) {\\n\\n\\t\\t\\t\\tthis._deactivateAction( action );\\n\\t\\t\\t\\tthis._removeInactiveAction( action );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Uniform( value ) {\\n\\n\\t\\tif ( typeof value === 'string' ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Uniform: Type parameter is no longer needed.' );\\n\\t\\t\\tvalue = arguments[ 1 ];\\n\\n\\t\\t}\\n\\n\\t\\tthis.value = value;\\n\\n\\t}\\n\\n\\tUniform.prototype.clone = function () {\\n\\n\\t\\treturn new Uniform( this.value.clone === undefined ? this.value : this.value.clone() );\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author benaadams / https://twitter.com/ben_a_adams\\n\\t */\\n\\n\\tfunction InstancedBufferGeometry() {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'InstancedBufferGeometry';\\n\\t\\tthis.maxInstancedCount = undefined;\\n\\n\\t}\\n\\n\\tInstancedBufferGeometry.prototype = Object.assign( Object.create( BufferGeometry.prototype ), {\\n\\n\\t\\tconstructor: InstancedBufferGeometry,\\n\\n\\t\\tisInstancedBufferGeometry: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tBufferGeometry.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.maxInstancedCount = source.maxInstancedCount;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author benaadams / https://twitter.com/ben_a_adams\\n\\t */\\n\\n\\tfunction InterleavedBufferAttribute( interleavedBuffer, itemSize, offset, normalized ) {\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.data = interleavedBuffer;\\n\\t\\tthis.itemSize = itemSize;\\n\\t\\tthis.offset = offset;\\n\\n\\t\\tthis.normalized = normalized === true;\\n\\n\\t}\\n\\n\\tObject.defineProperties( InterleavedBufferAttribute.prototype, {\\n\\n\\t\\tcount: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.data.count;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tarray: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.data.array;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( InterleavedBufferAttribute.prototype, {\\n\\n\\t\\tisInterleavedBufferAttribute: true,\\n\\n\\t\\tsetX: function ( index, x ) {\\n\\n\\t\\t\\tthis.data.array[ index * this.data.stride + this.offset ] = x;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetY: function ( index, y ) {\\n\\n\\t\\t\\tthis.data.array[ index * this.data.stride + this.offset + 1 ] = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetZ: function ( index, z ) {\\n\\n\\t\\t\\tthis.data.array[ index * this.data.stride + this.offset + 2 ] = z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetW: function ( index, w ) {\\n\\n\\t\\t\\tthis.data.array[ index * this.data.stride + this.offset + 3 ] = w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetX: function ( index ) {\\n\\n\\t\\t\\treturn this.data.array[ index * this.data.stride + this.offset ];\\n\\n\\t\\t},\\n\\n\\t\\tgetY: function ( index ) {\\n\\n\\t\\t\\treturn this.data.array[ index * this.data.stride + this.offset + 1 ];\\n\\n\\t\\t},\\n\\n\\t\\tgetZ: function ( index ) {\\n\\n\\t\\t\\treturn this.data.array[ index * this.data.stride + this.offset + 2 ];\\n\\n\\t\\t},\\n\\n\\t\\tgetW: function ( index ) {\\n\\n\\t\\t\\treturn this.data.array[ index * this.data.stride + this.offset + 3 ];\\n\\n\\t\\t},\\n\\n\\t\\tsetXY: function ( index, x, y ) {\\n\\n\\t\\t\\tindex = index * this.data.stride + this.offset;\\n\\n\\t\\t\\tthis.data.array[ index + 0 ] = x;\\n\\t\\t\\tthis.data.array[ index + 1 ] = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetXYZ: function ( index, x, y, z ) {\\n\\n\\t\\t\\tindex = index * this.data.stride + this.offset;\\n\\n\\t\\t\\tthis.data.array[ index + 0 ] = x;\\n\\t\\t\\tthis.data.array[ index + 1 ] = y;\\n\\t\\t\\tthis.data.array[ index + 2 ] = z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetXYZW: function ( index, x, y, z, w ) {\\n\\n\\t\\t\\tindex = index * this.data.stride + this.offset;\\n\\n\\t\\t\\tthis.data.array[ index + 0 ] = x;\\n\\t\\t\\tthis.data.array[ index + 1 ] = y;\\n\\t\\t\\tthis.data.array[ index + 2 ] = z;\\n\\t\\t\\tthis.data.array[ index + 3 ] = w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author benaadams / https://twitter.com/ben_a_adams\\n\\t */\\n\\n\\tfunction InterleavedBuffer( array, stride ) {\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.array = array;\\n\\t\\tthis.stride = stride;\\n\\t\\tthis.count = array !== undefined ? array.length / stride : 0;\\n\\n\\t\\tthis.dynamic = false;\\n\\t\\tthis.updateRange = { offset: 0, count: - 1 };\\n\\n\\t\\tthis.onUploadCallback = function () {};\\n\\n\\t\\tthis.version = 0;\\n\\n\\t}\\n\\n\\tObject.defineProperty( InterleavedBuffer.prototype, 'needsUpdate', {\\n\\n\\t\\tset: function ( value ) {\\n\\n\\t\\t\\tif ( value === true ) this.version ++;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( InterleavedBuffer.prototype, {\\n\\n\\t\\tisInterleavedBuffer: true,\\n\\n\\t\\tsetArray: function ( array ) {\\n\\n\\t\\t\\tif ( Array.isArray( array ) ) {\\n\\n\\t\\t\\t\\tthrow new TypeError( 'THREE.BufferAttribute: array should be a Typed Array.' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.count = array !== undefined ? array.length / this.stride : 0;\\n\\t\\t\\tthis.array = array;\\n\\n\\t\\t},\\n\\n\\t\\tsetDynamic: function ( value ) {\\n\\n\\t\\t\\tthis.dynamic = value;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tthis.array = new source.array.constructor( source.array );\\n\\t\\t\\tthis.count = source.count;\\n\\t\\t\\tthis.stride = source.stride;\\n\\t\\t\\tthis.dynamic = source.dynamic;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyAt: function ( index1, attribute, index2 ) {\\n\\n\\t\\t\\tindex1 *= this.stride;\\n\\t\\t\\tindex2 *= attribute.stride;\\n\\n\\t\\t\\tfor ( var i = 0, l = this.stride; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tthis.array[ index1 + i ] = attribute.array[ index2 + i ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tset: function ( value, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tthis.array.set( value, offset );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tonUpload: function ( callback ) {\\n\\n\\t\\t\\tthis.onUploadCallback = callback;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author benaadams / https://twitter.com/ben_a_adams\\n\\t */\\n\\n\\tfunction InstancedInterleavedBuffer( array, stride, meshPerAttribute ) {\\n\\n\\t\\tInterleavedBuffer.call( this, array, stride );\\n\\n\\t\\tthis.meshPerAttribute = meshPerAttribute || 1;\\n\\n\\t}\\n\\n\\tInstancedInterleavedBuffer.prototype = Object.assign( Object.create( InterleavedBuffer.prototype ), {\\n\\n\\t\\tconstructor: InstancedInterleavedBuffer,\\n\\n\\t\\tisInstancedInterleavedBuffer: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tInterleavedBuffer.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.meshPerAttribute = source.meshPerAttribute;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author benaadams / https://twitter.com/ben_a_adams\\n\\t */\\n\\n\\tfunction InstancedBufferAttribute( array, itemSize, meshPerAttribute ) {\\n\\n\\t\\tBufferAttribute.call( this, array, itemSize );\\n\\n\\t\\tthis.meshPerAttribute = meshPerAttribute || 1;\\n\\n\\t}\\n\\n\\tInstancedBufferAttribute.prototype = Object.assign( Object.create( BufferAttribute.prototype ), {\\n\\n\\t\\tconstructor: InstancedBufferAttribute,\\n\\n\\t\\tisInstancedBufferAttribute: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tBufferAttribute.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.meshPerAttribute = source.meshPerAttribute;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author bhouston / http://clara.io/\\n\\t * @author stephomi / http://stephaneginier.com/\\n\\t */\\n\\n\\tfunction Raycaster( origin, direction, near, far ) {\\n\\n\\t\\tthis.ray = new Ray( origin, direction );\\n\\t\\t// direction is assumed to be normalized (for accurate distance calculations)\\n\\n\\t\\tthis.near = near || 0;\\n\\t\\tthis.far = far || Infinity;\\n\\n\\t\\tthis.params = {\\n\\t\\t\\tMesh: {},\\n\\t\\t\\tLine: {},\\n\\t\\t\\tLOD: {},\\n\\t\\t\\tPoints: { threshold: 1 },\\n\\t\\t\\tSprite: {}\\n\\t\\t};\\n\\n\\t\\tObject.defineProperties( this.params, {\\n\\t\\t\\tPointCloud: {\\n\\t\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.Raycaster: params.PointCloud has been renamed to params.Points.' );\\n\\t\\t\\t\\t\\treturn this.Points;\\n\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t} );\\n\\n\\t}\\n\\n\\tfunction ascSort( a, b ) {\\n\\n\\t\\treturn a.distance - b.distance;\\n\\n\\t}\\n\\n\\tfunction intersectObject( object, raycaster, intersects, recursive ) {\\n\\n\\t\\tif ( object.visible === false ) return;\\n\\n\\t\\tobject.raycast( raycaster, intersects );\\n\\n\\t\\tif ( recursive === true ) {\\n\\n\\t\\t\\tvar children = object.children;\\n\\n\\t\\t\\tfor ( var i = 0, l = children.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tintersectObject( children[ i ], raycaster, intersects, true );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tObject.assign( Raycaster.prototype, {\\n\\n\\t\\tlinePrecision: 1,\\n\\n\\t\\tset: function ( origin, direction ) {\\n\\n\\t\\t\\t// direction is assumed to be normalized (for accurate distance calculations)\\n\\n\\t\\t\\tthis.ray.set( origin, direction );\\n\\n\\t\\t},\\n\\n\\t\\tsetFromCamera: function ( coords, camera ) {\\n\\n\\t\\t\\tif ( ( camera && camera.isPerspectiveCamera ) ) {\\n\\n\\t\\t\\t\\tthis.ray.origin.setFromMatrixPosition( camera.matrixWorld );\\n\\t\\t\\t\\tthis.ray.direction.set( coords.x, coords.y, 0.5 ).unproject( camera ).sub( this.ray.origin ).normalize();\\n\\n\\t\\t\\t} else if ( ( camera && camera.isOrthographicCamera ) ) {\\n\\n\\t\\t\\t\\tthis.ray.origin.set( coords.x, coords.y, ( camera.near + camera.far ) / ( camera.near - camera.far ) ).unproject( camera ); // set origin in plane of camera\\n\\t\\t\\t\\tthis.ray.direction.set( 0, 0, - 1 ).transformDirection( camera.matrixWorld );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.Raycaster: Unsupported camera type.' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tintersectObject: function ( object, recursive ) {\\n\\n\\t\\t\\tvar intersects = [];\\n\\n\\t\\t\\tintersectObject( object, this, intersects, recursive );\\n\\n\\t\\t\\tintersects.sort( ascSort );\\n\\n\\t\\t\\treturn intersects;\\n\\n\\t\\t},\\n\\n\\t\\tintersectObjects: function ( objects, recursive ) {\\n\\n\\t\\t\\tvar intersects = [];\\n\\n\\t\\t\\tif ( Array.isArray( objects ) === false ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Raycaster.intersectObjects: objects is not an Array.' );\\n\\t\\t\\t\\treturn intersects;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = 0, l = objects.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tintersectObject( objects[ i ], this, intersects, recursive );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tintersects.sort( ascSort );\\n\\n\\t\\t\\treturn intersects;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction Clock( autoStart ) {\\n\\n\\t\\tthis.autoStart = ( autoStart !== undefined ) ? autoStart : true;\\n\\n\\t\\tthis.startTime = 0;\\n\\t\\tthis.oldTime = 0;\\n\\t\\tthis.elapsedTime = 0;\\n\\n\\t\\tthis.running = false;\\n\\n\\t}\\n\\n\\tObject.assign( Clock.prototype, {\\n\\n\\t\\tstart: function () {\\n\\n\\t\\t\\tthis.startTime = ( typeof performance === 'undefined' ? Date : performance ).now(); // see #10732\\n\\n\\t\\t\\tthis.oldTime = this.startTime;\\n\\t\\t\\tthis.elapsedTime = 0;\\n\\t\\t\\tthis.running = true;\\n\\n\\t\\t},\\n\\n\\t\\tstop: function () {\\n\\n\\t\\t\\tthis.getElapsedTime();\\n\\t\\t\\tthis.running = false;\\n\\t\\t\\tthis.autoStart = false;\\n\\n\\t\\t},\\n\\n\\t\\tgetElapsedTime: function () {\\n\\n\\t\\t\\tthis.getDelta();\\n\\t\\t\\treturn this.elapsedTime;\\n\\n\\t\\t},\\n\\n\\t\\tgetDelta: function () {\\n\\n\\t\\t\\tvar diff = 0;\\n\\n\\t\\t\\tif ( this.autoStart && ! this.running ) {\\n\\n\\t\\t\\t\\tthis.start();\\n\\t\\t\\t\\treturn 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.running ) {\\n\\n\\t\\t\\t\\tvar newTime = ( typeof performance === 'undefined' ? Date : performance ).now();\\n\\n\\t\\t\\t\\tdiff = ( newTime - this.oldTime ) / 1000;\\n\\t\\t\\t\\tthis.oldTime = newTime;\\n\\n\\t\\t\\t\\tthis.elapsedTime += diff;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn diff;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author bhouston / http://clara.io\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t *\\n\\t * Ref: https://en.wikipedia.org/wiki/Spherical_coordinate_system\\n\\t *\\n\\t * The poles (phi) are at the positive and negative y axis.\\n\\t * The equator starts at positive z.\\n\\t */\\n\\n\\tfunction Spherical( radius, phi, theta ) {\\n\\n\\t\\tthis.radius = ( radius !== undefined ) ? radius : 1.0;\\n\\t\\tthis.phi = ( phi !== undefined ) ? phi : 0; // up / down towards top and bottom pole\\n\\t\\tthis.theta = ( theta !== undefined ) ? theta : 0; // around the equator of the sphere\\n\\n\\t\\treturn this;\\n\\n\\t}\\n\\n\\tObject.assign( Spherical.prototype, {\\n\\n\\t\\tset: function ( radius, phi, theta ) {\\n\\n\\t\\t\\tthis.radius = radius;\\n\\t\\t\\tthis.phi = phi;\\n\\t\\t\\tthis.theta = theta;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( other ) {\\n\\n\\t\\t\\tthis.radius = other.radius;\\n\\t\\t\\tthis.phi = other.phi;\\n\\t\\t\\tthis.theta = other.theta;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// restrict phi to be betwee EPS and PI-EPS\\n\\t\\tmakeSafe: function () {\\n\\n\\t\\t\\tvar EPS = 0.000001;\\n\\t\\t\\tthis.phi = Math.max( EPS, Math.min( Math.PI - EPS, this.phi ) );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromVector3: function ( vec3 ) {\\n\\n\\t\\t\\tthis.radius = vec3.length();\\n\\n\\t\\t\\tif ( this.radius === 0 ) {\\n\\n\\t\\t\\t\\tthis.theta = 0;\\n\\t\\t\\t\\tthis.phi = 0;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.theta = Math.atan2( vec3.x, vec3.z ); // equator angle around y-up axis\\n\\t\\t\\t\\tthis.phi = Math.acos( _Math.clamp( vec3.y / this.radius, - 1, 1 ) ); // polar angle\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t *\\n\\t * Ref: https://en.wikipedia.org/wiki/Cylindrical_coordinate_system\\n\\t *\\n\\t */\\n\\n\\tfunction Cylindrical( radius, theta, y ) {\\n\\n\\t\\tthis.radius = ( radius !== undefined ) ? radius : 1.0; // distance from the origin to a point in the x-z plane\\n\\t\\tthis.theta = ( theta !== undefined ) ? theta : 0; // counterclockwise angle in the x-z plane measured in radians from the positive z-axis\\n\\t\\tthis.y = ( y !== undefined ) ? y : 0; // height above the x-z plane\\n\\n\\t\\treturn this;\\n\\n\\t}\\n\\n\\tObject.assign( Cylindrical.prototype, {\\n\\n\\t\\tset: function ( radius, theta, y ) {\\n\\n\\t\\t\\tthis.radius = radius;\\n\\t\\t\\tthis.theta = theta;\\n\\t\\t\\tthis.y = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( other ) {\\n\\n\\t\\t\\tthis.radius = other.radius;\\n\\t\\t\\tthis.theta = other.theta;\\n\\t\\t\\tthis.y = other.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromVector3: function ( vec3 ) {\\n\\n\\t\\t\\tthis.radius = Math.sqrt( vec3.x * vec3.x + vec3.z * vec3.z );\\n\\t\\t\\tthis.theta = Math.atan2( vec3.x, vec3.z );\\n\\t\\t\\tthis.y = vec3.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction ImmediateRenderObject( material ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.material = material;\\n\\t\\tthis.render = function ( /* renderCallback */ ) {};\\n\\n\\t}\\n\\n\\tImmediateRenderObject.prototype = Object.create( Object3D.prototype );\\n\\tImmediateRenderObject.prototype.constructor = ImmediateRenderObject;\\n\\n\\tImmediateRenderObject.prototype.isImmediateRenderObject = true;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction VertexNormalsHelper( object, size, hex, linewidth ) {\\n\\n\\t\\tthis.object = object;\\n\\n\\t\\tthis.size = ( size !== undefined ) ? size : 1;\\n\\n\\t\\tvar color = ( hex !== undefined ) ? hex : 0xff0000;\\n\\n\\t\\tvar width = ( linewidth !== undefined ) ? linewidth : 1;\\n\\n\\t\\t//\\n\\n\\t\\tvar nNormals = 0;\\n\\n\\t\\tvar objGeometry = this.object.geometry;\\n\\n\\t\\tif ( objGeometry && objGeometry.isGeometry ) {\\n\\n\\t\\t\\tnNormals = objGeometry.faces.length * 3;\\n\\n\\t\\t} else if ( objGeometry && objGeometry.isBufferGeometry ) {\\n\\n\\t\\t\\tnNormals = objGeometry.attributes.normal.count;\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\n\\t\\tvar positions = new Float32BufferAttribute( nNormals * 2 * 3, 3 );\\n\\n\\t\\tgeometry.addAttribute( 'position', positions );\\n\\n\\t\\tLineSegments.call( this, geometry, new LineBasicMaterial( { color: color, linewidth: width } ) );\\n\\n\\t\\t//\\n\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t\\tthis.update();\\n\\n\\t}\\n\\n\\tVertexNormalsHelper.prototype = Object.create( LineSegments.prototype );\\n\\tVertexNormalsHelper.prototype.constructor = VertexNormalsHelper;\\n\\n\\tVertexNormalsHelper.prototype.update = ( function () {\\n\\n\\t\\tvar v1 = new Vector3();\\n\\t\\tvar v2 = new Vector3();\\n\\t\\tvar normalMatrix = new Matrix3();\\n\\n\\t\\treturn function update() {\\n\\n\\t\\t\\tvar keys = [ 'a', 'b', 'c' ];\\n\\n\\t\\t\\tthis.object.updateMatrixWorld( true );\\n\\n\\t\\t\\tnormalMatrix.getNormalMatrix( this.object.matrixWorld );\\n\\n\\t\\t\\tvar matrixWorld = this.object.matrixWorld;\\n\\n\\t\\t\\tvar position = this.geometry.attributes.position;\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar objGeometry = this.object.geometry;\\n\\n\\t\\t\\tif ( objGeometry && objGeometry.isGeometry ) {\\n\\n\\t\\t\\t\\tvar vertices = objGeometry.vertices;\\n\\n\\t\\t\\t\\tvar faces = objGeometry.faces;\\n\\n\\t\\t\\t\\tvar idx = 0;\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = faces.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar face = faces[ i ];\\n\\n\\t\\t\\t\\t\\tfor ( var j = 0, jl = face.vertexNormals.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar vertex = vertices[ face[ keys[ j ] ] ];\\n\\n\\t\\t\\t\\t\\t\\tvar normal = face.vertexNormals[ j ];\\n\\n\\t\\t\\t\\t\\t\\tv1.copy( vertex ).applyMatrix4( matrixWorld );\\n\\n\\t\\t\\t\\t\\t\\tv2.copy( normal ).applyMatrix3( normalMatrix ).normalize().multiplyScalar( this.size ).add( v1 );\\n\\n\\t\\t\\t\\t\\t\\tposition.setXYZ( idx, v1.x, v1.y, v1.z );\\n\\n\\t\\t\\t\\t\\t\\tidx = idx + 1;\\n\\n\\t\\t\\t\\t\\t\\tposition.setXYZ( idx, v2.x, v2.y, v2.z );\\n\\n\\t\\t\\t\\t\\t\\tidx = idx + 1;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( objGeometry && objGeometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\tvar objPos = objGeometry.attributes.position;\\n\\n\\t\\t\\t\\tvar objNorm = objGeometry.attributes.normal;\\n\\n\\t\\t\\t\\tvar idx = 0;\\n\\n\\t\\t\\t\\t// for simplicity, ignore index and drawcalls, and render every normal\\n\\n\\t\\t\\t\\tfor ( var j = 0, jl = objPos.count; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\tv1.set( objPos.getX( j ), objPos.getY( j ), objPos.getZ( j ) ).applyMatrix4( matrixWorld );\\n\\n\\t\\t\\t\\t\\tv2.set( objNorm.getX( j ), objNorm.getY( j ), objNorm.getZ( j ) );\\n\\n\\t\\t\\t\\t\\tv2.applyMatrix3( normalMatrix ).normalize().multiplyScalar( this.size ).add( v1 );\\n\\n\\t\\t\\t\\t\\tposition.setXYZ( idx, v1.x, v1.y, v1.z );\\n\\n\\t\\t\\t\\t\\tidx = idx + 1;\\n\\n\\t\\t\\t\\t\\tposition.setXYZ( idx, v2.x, v2.y, v2.z );\\n\\n\\t\\t\\t\\t\\tidx = idx + 1;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tposition.needsUpdate = true;\\n\\n\\t\\t};\\n\\n\\t}() );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction SpotLightHelper( light, color ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.light = light;\\n\\t\\tthis.light.updateMatrixWorld();\\n\\n\\t\\tthis.matrix = light.matrixWorld;\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t\\tthis.color = color;\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\n\\t\\tvar positions = [\\n\\t\\t\\t0, 0, 0, \\t0, 0, 1,\\n\\t\\t\\t0, 0, 0, \\t1, 0, 1,\\n\\t\\t\\t0, 0, 0,\\t- 1, 0, 1,\\n\\t\\t\\t0, 0, 0, \\t0, 1, 1,\\n\\t\\t\\t0, 0, 0, \\t0, - 1, 1\\n\\t\\t];\\n\\n\\t\\tfor ( var i = 0, j = 1, l = 32; i < l; i ++, j ++ ) {\\n\\n\\t\\t\\tvar p1 = ( i / l ) * Math.PI * 2;\\n\\t\\t\\tvar p2 = ( j / l ) * Math.PI * 2;\\n\\n\\t\\t\\tpositions.push(\\n\\t\\t\\t\\tMath.cos( p1 ), Math.sin( p1 ), 1,\\n\\t\\t\\t\\tMath.cos( p2 ), Math.sin( p2 ), 1\\n\\t\\t\\t);\\n\\n\\t\\t}\\n\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );\\n\\n\\t\\tvar material = new LineBasicMaterial( { fog: false } );\\n\\n\\t\\tthis.cone = new LineSegments( geometry, material );\\n\\t\\tthis.add( this.cone );\\n\\n\\t\\tthis.update();\\n\\n\\t}\\n\\n\\tSpotLightHelper.prototype = Object.create( Object3D.prototype );\\n\\tSpotLightHelper.prototype.constructor = SpotLightHelper;\\n\\n\\tSpotLightHelper.prototype.dispose = function () {\\n\\n\\t\\tthis.cone.geometry.dispose();\\n\\t\\tthis.cone.material.dispose();\\n\\n\\t};\\n\\n\\tSpotLightHelper.prototype.update = function () {\\n\\n\\t\\tvar vector = new Vector3();\\n\\t\\tvar vector2 = new Vector3();\\n\\n\\t\\treturn function update() {\\n\\n\\t\\t\\tthis.light.updateMatrixWorld();\\n\\n\\t\\t\\tvar coneLength = this.light.distance ? this.light.distance : 1000;\\n\\t\\t\\tvar coneWidth = coneLength * Math.tan( this.light.angle );\\n\\n\\t\\t\\tthis.cone.scale.set( coneWidth, coneWidth, coneLength );\\n\\n\\t\\t\\tvector.setFromMatrixPosition( this.light.matrixWorld );\\n\\t\\t\\tvector2.setFromMatrixPosition( this.light.target.matrixWorld );\\n\\n\\t\\t\\tthis.cone.lookAt( vector2.sub( vector ) );\\n\\n\\t\\t\\tif ( this.color !== undefined ) {\\n\\n\\t\\t\\t\\tthis.cone.material.color.set( this.color );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.cone.material.color.copy( this.light.color );\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t}();\\n\\n\\t/**\\n\\t * @author Sean Griffin / http://twitter.com/sgrif\\n\\t * @author Michael Guerrero / http://realitymeltdown.com\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author ikerr / http://verold.com\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\tfunction getBoneList( object ) {\\n\\n\\t\\tvar boneList = [];\\n\\n\\t\\tif ( object && object.isBone ) {\\n\\n\\t\\t\\tboneList.push( object );\\n\\n\\t\\t}\\n\\n\\t\\tfor ( var i = 0; i < object.children.length; i ++ ) {\\n\\n\\t\\t\\tboneList.push.apply( boneList, getBoneList( object.children[ i ] ) );\\n\\n\\t\\t}\\n\\n\\t\\treturn boneList;\\n\\n\\t}\\n\\n\\tfunction SkeletonHelper( object ) {\\n\\n\\t\\tvar bones = getBoneList( object );\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\n\\t\\tvar vertices = [];\\n\\t\\tvar colors = [];\\n\\n\\t\\tvar color1 = new Color( 0, 0, 1 );\\n\\t\\tvar color2 = new Color( 0, 1, 0 );\\n\\n\\t\\tfor ( var i = 0; i < bones.length; i ++ ) {\\n\\n\\t\\t\\tvar bone = bones[ i ];\\n\\n\\t\\t\\tif ( bone.parent && bone.parent.isBone ) {\\n\\n\\t\\t\\t\\tvertices.push( 0, 0, 0 );\\n\\t\\t\\t\\tvertices.push( 0, 0, 0 );\\n\\t\\t\\t\\tcolors.push( color1.r, color1.g, color1.b );\\n\\t\\t\\t\\tcolors.push( color2.r, color2.g, color2.b );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tgeometry.addAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );\\n\\n\\t\\tvar material = new LineBasicMaterial( { vertexColors: VertexColors, depthTest: false, depthWrite: false, transparent: true } );\\n\\n\\t\\tLineSegments.call( this, geometry, material );\\n\\n\\t\\tthis.root = object;\\n\\t\\tthis.bones = bones;\\n\\n\\t\\tthis.matrix = object.matrixWorld;\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t}\\n\\n\\tSkeletonHelper.prototype = Object.create( LineSegments.prototype );\\n\\tSkeletonHelper.prototype.constructor = SkeletonHelper;\\n\\n\\tSkeletonHelper.prototype.updateMatrixWorld = function () {\\n\\n\\t\\tvar vector = new Vector3();\\n\\n\\t\\tvar boneMatrix = new Matrix4();\\n\\t\\tvar matrixWorldInv = new Matrix4();\\n\\n\\t\\treturn function updateMatrixWorld( force ) {\\n\\n\\t\\t\\tvar bones = this.bones;\\n\\n\\t\\t\\tvar geometry = this.geometry;\\n\\t\\t\\tvar position = geometry.getAttribute( 'position' );\\n\\n\\t\\t\\tmatrixWorldInv.getInverse( this.root.matrixWorld );\\n\\n\\t\\t\\tfor ( var i = 0, j = 0; i < bones.length; i ++ ) {\\n\\n\\t\\t\\t\\tvar bone = bones[ i ];\\n\\n\\t\\t\\t\\tif ( bone.parent && bone.parent.isBone ) {\\n\\n\\t\\t\\t\\t\\tboneMatrix.multiplyMatrices( matrixWorldInv, bone.matrixWorld );\\n\\t\\t\\t\\t\\tvector.setFromMatrixPosition( boneMatrix );\\n\\t\\t\\t\\t\\tposition.setXYZ( j, vector.x, vector.y, vector.z );\\n\\n\\t\\t\\t\\t\\tboneMatrix.multiplyMatrices( matrixWorldInv, bone.parent.matrixWorld );\\n\\t\\t\\t\\t\\tvector.setFromMatrixPosition( boneMatrix );\\n\\t\\t\\t\\t\\tposition.setXYZ( j + 1, vector.x, vector.y, vector.z );\\n\\n\\t\\t\\t\\t\\tj += 2;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tgeometry.getAttribute( 'position' ).needsUpdate = true;\\n\\n\\t\\t\\tObject3D.prototype.updateMatrixWorld.call( this, force );\\n\\n\\t\\t};\\n\\n\\t}();\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction PointLightHelper( light, sphereSize, color ) {\\n\\n\\t\\tthis.light = light;\\n\\t\\tthis.light.updateMatrixWorld();\\n\\n\\t\\tthis.color = color;\\n\\n\\t\\tvar geometry = new SphereBufferGeometry( sphereSize, 4, 2 );\\n\\t\\tvar material = new MeshBasicMaterial( { wireframe: true, fog: false } );\\n\\n\\t\\tMesh.call( this, geometry, material );\\n\\n\\t\\tthis.matrix = this.light.matrixWorld;\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t\\tthis.update();\\n\\n\\n\\t\\t/*\\n\\t\\tvar distanceGeometry = new THREE.IcosahedronGeometry( 1, 2 );\\n\\t\\tvar distanceMaterial = new THREE.MeshBasicMaterial( { color: hexColor, fog: false, wireframe: true, opacity: 0.1, transparent: true } );\\n\\n\\t\\tthis.lightSphere = new THREE.Mesh( bulbGeometry, bulbMaterial );\\n\\t\\tthis.lightDistance = new THREE.Mesh( distanceGeometry, distanceMaterial );\\n\\n\\t\\tvar d = light.distance;\\n\\n\\t\\tif ( d === 0.0 ) {\\n\\n\\t\\t\\tthis.lightDistance.visible = false;\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tthis.lightDistance.scale.set( d, d, d );\\n\\n\\t\\t}\\n\\n\\t\\tthis.add( this.lightDistance );\\n\\t\\t*/\\n\\n\\t}\\n\\n\\tPointLightHelper.prototype = Object.create( Mesh.prototype );\\n\\tPointLightHelper.prototype.constructor = PointLightHelper;\\n\\n\\tPointLightHelper.prototype.dispose = function () {\\n\\n\\t\\tthis.geometry.dispose();\\n\\t\\tthis.material.dispose();\\n\\n\\t};\\n\\n\\tPointLightHelper.prototype.update = function () {\\n\\n\\t\\tif ( this.color !== undefined ) {\\n\\n\\t\\t\\tthis.material.color.set( this.color );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tthis.material.color.copy( this.light.color );\\n\\n\\t\\t}\\n\\n\\t\\t/*\\n\\t\\tvar d = this.light.distance;\\n\\n\\t\\tif ( d === 0.0 ) {\\n\\n\\t\\t\\tthis.lightDistance.visible = false;\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tthis.lightDistance.visible = true;\\n\\t\\t\\tthis.lightDistance.scale.set( d, d, d );\\n\\n\\t\\t}\\n\\t\\t*/\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author abelnation / http://github.com/abelnation\\n\\t * @author Mugen87 / http://github.com/Mugen87\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction RectAreaLightHelper( light, color ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.light = light;\\n\\t\\tthis.light.updateMatrixWorld();\\n\\n\\t\\tthis.matrix = light.matrixWorld;\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t\\tthis.color = color;\\n\\n\\t\\tvar material = new LineBasicMaterial( { fog: false } );\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\n\\t\\tgeometry.addAttribute( 'position', new BufferAttribute( new Float32Array( 5 * 3 ), 3 ) );\\n\\n\\t\\tthis.line = new Line( geometry, material );\\n\\t\\tthis.add( this.line );\\n\\n\\n\\t\\tthis.update();\\n\\n\\t}\\n\\n\\tRectAreaLightHelper.prototype = Object.create( Object3D.prototype );\\n\\tRectAreaLightHelper.prototype.constructor = RectAreaLightHelper;\\n\\n\\tRectAreaLightHelper.prototype.dispose = function () {\\n\\n\\t\\tthis.children[ 0 ].geometry.dispose();\\n\\t\\tthis.children[ 0 ].material.dispose();\\n\\n\\t};\\n\\n\\tRectAreaLightHelper.prototype.update = function () {\\n\\n\\t\\t// calculate new dimensions of the helper\\n\\n\\t\\tvar hx = this.light.width * 0.5;\\n\\t\\tvar hy = this.light.height * 0.5;\\n\\n\\t\\tvar position = this.line.geometry.attributes.position;\\n\\t\\tvar array = position.array;\\n\\n\\t\\t// update vertices\\n\\n\\t\\tarray[ 0 ] = hx; array[ 1 ] = - hy; array[ 2 ] = 0;\\n\\t\\tarray[ 3 ] = hx; array[ 4 ] = hy; array[ 5 ] = 0;\\n\\t\\tarray[ 6 ] = - hx; array[ 7 ] = hy; array[ 8 ] = 0;\\n\\t\\tarray[ 9 ] = - hx; array[ 10 ] = - hy; array[ 11 ] = 0;\\n\\t\\tarray[ 12 ] = hx; array[ 13 ] = - hy; array[ 14 ] = 0;\\n\\n\\t\\tposition.needsUpdate = true;\\n\\n\\t\\tif ( this.color !== undefined ) {\\n\\n\\t\\t\\tthis.line.material.color.set( this.color );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tthis.line.material.color.copy( this.light.color );\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\tfunction HemisphereLightHelper( light, size, color ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.light = light;\\n\\t\\tthis.light.updateMatrixWorld();\\n\\n\\t\\tthis.matrix = light.matrixWorld;\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t\\tthis.color = color;\\n\\n\\t\\tvar geometry = new OctahedronBufferGeometry( size );\\n\\t\\tgeometry.rotateY( Math.PI * 0.5 );\\n\\n\\t\\tthis.material = new MeshBasicMaterial( { wireframe: true, fog: false } );\\n\\t\\tif ( this.color === undefined ) this.material.vertexColors = VertexColors;\\n\\n\\t\\tvar position = geometry.getAttribute( 'position' );\\n\\t\\tvar colors = new Float32Array( position.count * 3 );\\n\\n\\t\\tgeometry.addAttribute( 'color', new BufferAttribute( colors, 3 ) );\\n\\n\\t\\tthis.add( new Mesh( geometry, this.material ) );\\n\\n\\t\\tthis.update();\\n\\n\\t}\\n\\n\\tHemisphereLightHelper.prototype = Object.create( Object3D.prototype );\\n\\tHemisphereLightHelper.prototype.constructor = HemisphereLightHelper;\\n\\n\\tHemisphereLightHelper.prototype.dispose = function () {\\n\\n\\t\\tthis.children[ 0 ].geometry.dispose();\\n\\t\\tthis.children[ 0 ].material.dispose();\\n\\n\\t};\\n\\n\\tHemisphereLightHelper.prototype.update = function () {\\n\\n\\t\\tvar vector = new Vector3();\\n\\n\\t\\tvar color1 = new Color();\\n\\t\\tvar color2 = new Color();\\n\\n\\t\\treturn function update() {\\n\\n\\t\\t\\tvar mesh = this.children[ 0 ];\\n\\n\\t\\t\\tif ( this.color !== undefined ) {\\n\\n\\t\\t\\t\\tthis.material.color.set( this.color );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tvar colors = mesh.geometry.getAttribute( 'color' );\\n\\n\\t\\t\\t\\tcolor1.copy( this.light.color );\\n\\t\\t\\t\\tcolor2.copy( this.light.groundColor );\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = colors.count; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar color = ( i < ( l / 2 ) ) ? color1 : color2;\\n\\n\\t\\t\\t\\t\\tcolors.setXYZ( i, color.r, color.g, color.b );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tcolors.needsUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tmesh.lookAt( vector.setFromMatrixPosition( this.light.matrixWorld ).negate() );\\n\\n\\t\\t};\\n\\n\\t}();\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction GridHelper( size, divisions, color1, color2 ) {\\n\\n\\t\\tsize = size || 10;\\n\\t\\tdivisions = divisions || 10;\\n\\t\\tcolor1 = new Color( color1 !== undefined ? color1 : 0x444444 );\\n\\t\\tcolor2 = new Color( color2 !== undefined ? color2 : 0x888888 );\\n\\n\\t\\tvar center = divisions / 2;\\n\\t\\tvar step = size / divisions;\\n\\t\\tvar halfSize = size / 2;\\n\\n\\t\\tvar vertices = [], colors = [];\\n\\n\\t\\tfor ( var i = 0, j = 0, k = - halfSize; i <= divisions; i ++, k += step ) {\\n\\n\\t\\t\\tvertices.push( - halfSize, 0, k, halfSize, 0, k );\\n\\t\\t\\tvertices.push( k, 0, - halfSize, k, 0, halfSize );\\n\\n\\t\\t\\tvar color = i === center ? color1 : color2;\\n\\n\\t\\t\\tcolor.toArray( colors, j ); j += 3;\\n\\t\\t\\tcolor.toArray( colors, j ); j += 3;\\n\\t\\t\\tcolor.toArray( colors, j ); j += 3;\\n\\t\\t\\tcolor.toArray( colors, j ); j += 3;\\n\\n\\t\\t}\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tgeometry.addAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );\\n\\n\\t\\tvar material = new LineBasicMaterial( { vertexColors: VertexColors } );\\n\\n\\t\\tLineSegments.call( this, geometry, material );\\n\\n\\t}\\n\\n\\tGridHelper.prototype = Object.create( LineSegments.prototype );\\n\\tGridHelper.prototype.constructor = GridHelper;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Mugen87 / http://github.com/Mugen87\\n\\t * @author Hectate / http://www.github.com/Hectate\\n\\t */\\n\\n\\tfunction PolarGridHelper( radius, radials, circles, divisions, color1, color2 ) {\\n\\n\\t\\tradius = radius || 10;\\n\\t\\tradials = radials || 16;\\n\\t\\tcircles = circles || 8;\\n\\t\\tdivisions = divisions || 64;\\n\\t\\tcolor1 = new Color( color1 !== undefined ? color1 : 0x444444 );\\n\\t\\tcolor2 = new Color( color2 !== undefined ? color2 : 0x888888 );\\n\\n\\t\\tvar vertices = [];\\n\\t\\tvar colors = [];\\n\\n\\t\\tvar x, z;\\n\\t\\tvar v, i, j, r, color;\\n\\n\\t\\t// create the radials\\n\\n\\t\\tfor ( i = 0; i <= radials; i ++ ) {\\n\\n\\t\\t\\tv = ( i / radials ) * ( Math.PI * 2 );\\n\\n\\t\\t\\tx = Math.sin( v ) * radius;\\n\\t\\t\\tz = Math.cos( v ) * radius;\\n\\n\\t\\t\\tvertices.push( 0, 0, 0 );\\n\\t\\t\\tvertices.push( x, 0, z );\\n\\n\\t\\t\\tcolor = ( i & 1 ) ? color1 : color2;\\n\\n\\t\\t\\tcolors.push( color.r, color.g, color.b );\\n\\t\\t\\tcolors.push( color.r, color.g, color.b );\\n\\n\\t\\t}\\n\\n\\t\\t// create the circles\\n\\n\\t\\tfor ( i = 0; i <= circles; i ++ ) {\\n\\n\\t\\t\\tcolor = ( i & 1 ) ? color1 : color2;\\n\\n\\t\\t\\tr = radius - ( radius / circles * i );\\n\\n\\t\\t\\tfor ( j = 0; j < divisions; j ++ ) {\\n\\n\\t\\t\\t\\t// first vertex\\n\\n\\t\\t\\t\\tv = ( j / divisions ) * ( Math.PI * 2 );\\n\\n\\t\\t\\t\\tx = Math.sin( v ) * r;\\n\\t\\t\\t\\tz = Math.cos( v ) * r;\\n\\n\\t\\t\\t\\tvertices.push( x, 0, z );\\n\\t\\t\\t\\tcolors.push( color.r, color.g, color.b );\\n\\n\\t\\t\\t\\t// second vertex\\n\\n\\t\\t\\t\\tv = ( ( j + 1 ) / divisions ) * ( Math.PI * 2 );\\n\\n\\t\\t\\t\\tx = Math.sin( v ) * r;\\n\\t\\t\\t\\tz = Math.cos( v ) * r;\\n\\n\\t\\t\\t\\tvertices.push( x, 0, z );\\n\\t\\t\\t\\tcolors.push( color.r, color.g, color.b );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tgeometry.addAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );\\n\\n\\t\\tvar material = new LineBasicMaterial( { vertexColors: VertexColors } );\\n\\n\\t\\tLineSegments.call( this, geometry, material );\\n\\n\\t}\\n\\n\\tPolarGridHelper.prototype = Object.create( LineSegments.prototype );\\n\\tPolarGridHelper.prototype.constructor = PolarGridHelper;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction FaceNormalsHelper( object, size, hex, linewidth ) {\\n\\n\\t\\t// FaceNormalsHelper only supports THREE.Geometry\\n\\n\\t\\tthis.object = object;\\n\\n\\t\\tthis.size = ( size !== undefined ) ? size : 1;\\n\\n\\t\\tvar color = ( hex !== undefined ) ? hex : 0xffff00;\\n\\n\\t\\tvar width = ( linewidth !== undefined ) ? linewidth : 1;\\n\\n\\t\\t//\\n\\n\\t\\tvar nNormals = 0;\\n\\n\\t\\tvar objGeometry = this.object.geometry;\\n\\n\\t\\tif ( objGeometry && objGeometry.isGeometry ) {\\n\\n\\t\\t\\tnNormals = objGeometry.faces.length;\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tconsole.warn( 'THREE.FaceNormalsHelper: only THREE.Geometry is supported. Use THREE.VertexNormalsHelper, instead.' );\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\n\\t\\tvar positions = new Float32BufferAttribute( nNormals * 2 * 3, 3 );\\n\\n\\t\\tgeometry.addAttribute( 'position', positions );\\n\\n\\t\\tLineSegments.call( this, geometry, new LineBasicMaterial( { color: color, linewidth: width } ) );\\n\\n\\t\\t//\\n\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\t\\tthis.update();\\n\\n\\t}\\n\\n\\tFaceNormalsHelper.prototype = Object.create( LineSegments.prototype );\\n\\tFaceNormalsHelper.prototype.constructor = FaceNormalsHelper;\\n\\n\\tFaceNormalsHelper.prototype.update = ( function () {\\n\\n\\t\\tvar v1 = new Vector3();\\n\\t\\tvar v2 = new Vector3();\\n\\t\\tvar normalMatrix = new Matrix3();\\n\\n\\t\\treturn function update() {\\n\\n\\t\\t\\tthis.object.updateMatrixWorld( true );\\n\\n\\t\\t\\tnormalMatrix.getNormalMatrix( this.object.matrixWorld );\\n\\n\\t\\t\\tvar matrixWorld = this.object.matrixWorld;\\n\\n\\t\\t\\tvar position = this.geometry.attributes.position;\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar objGeometry = this.object.geometry;\\n\\n\\t\\t\\tvar vertices = objGeometry.vertices;\\n\\n\\t\\t\\tvar faces = objGeometry.faces;\\n\\n\\t\\t\\tvar idx = 0;\\n\\n\\t\\t\\tfor ( var i = 0, l = faces.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar face = faces[ i ];\\n\\n\\t\\t\\t\\tvar normal = face.normal;\\n\\n\\t\\t\\t\\tv1.copy( vertices[ face.a ] )\\n\\t\\t\\t\\t\\t.add( vertices[ face.b ] )\\n\\t\\t\\t\\t\\t.add( vertices[ face.c ] )\\n\\t\\t\\t\\t\\t.divideScalar( 3 )\\n\\t\\t\\t\\t\\t.applyMatrix4( matrixWorld );\\n\\n\\t\\t\\t\\tv2.copy( normal ).applyMatrix3( normalMatrix ).normalize().multiplyScalar( this.size ).add( v1 );\\n\\n\\t\\t\\t\\tposition.setXYZ( idx, v1.x, v1.y, v1.z );\\n\\n\\t\\t\\t\\tidx = idx + 1;\\n\\n\\t\\t\\t\\tposition.setXYZ( idx, v2.x, v2.y, v2.z );\\n\\n\\t\\t\\t\\tidx = idx + 1;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tposition.needsUpdate = true;\\n\\n\\t\\t};\\n\\n\\t}() );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction DirectionalLightHelper( light, size, color ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.light = light;\\n\\t\\tthis.light.updateMatrixWorld();\\n\\n\\t\\tthis.matrix = light.matrixWorld;\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t\\tthis.color = color;\\n\\n\\t\\tif ( size === undefined ) size = 1;\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( [\\n\\t\\t\\t- size, size, 0,\\n\\t\\t\\tsize, size, 0,\\n\\t\\t\\tsize, - size, 0,\\n\\t\\t\\t- size, - size, 0,\\n\\t\\t\\t- size, size, 0\\n\\t\\t], 3 ) );\\n\\n\\t\\tvar material = new LineBasicMaterial( { fog: false } );\\n\\n\\t\\tthis.lightPlane = new Line( geometry, material );\\n\\t\\tthis.add( this.lightPlane );\\n\\n\\t\\tgeometry = new BufferGeometry();\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( [ 0, 0, 0, 0, 0, 1 ], 3 ) );\\n\\n\\t\\tthis.targetLine = new Line( geometry, material );\\n\\t\\tthis.add( this.targetLine );\\n\\n\\t\\tthis.update();\\n\\n\\t}\\n\\n\\tDirectionalLightHelper.prototype = Object.create( Object3D.prototype );\\n\\tDirectionalLightHelper.prototype.constructor = DirectionalLightHelper;\\n\\n\\tDirectionalLightHelper.prototype.dispose = function () {\\n\\n\\t\\tthis.lightPlane.geometry.dispose();\\n\\t\\tthis.lightPlane.material.dispose();\\n\\t\\tthis.targetLine.geometry.dispose();\\n\\t\\tthis.targetLine.material.dispose();\\n\\n\\t};\\n\\n\\tDirectionalLightHelper.prototype.update = function () {\\n\\n\\t\\tvar v1 = new Vector3();\\n\\t\\tvar v2 = new Vector3();\\n\\t\\tvar v3 = new Vector3();\\n\\n\\t\\treturn function update() {\\n\\n\\t\\t\\tv1.setFromMatrixPosition( this.light.matrixWorld );\\n\\t\\t\\tv2.setFromMatrixPosition( this.light.target.matrixWorld );\\n\\t\\t\\tv3.subVectors( v2, v1 );\\n\\n\\t\\t\\tthis.lightPlane.lookAt( v3 );\\n\\n\\t\\t\\tif ( this.color !== undefined ) {\\n\\n\\t\\t\\t\\tthis.lightPlane.material.color.set( this.color );\\n\\t\\t\\t\\tthis.targetLine.material.color.set( this.color );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.lightPlane.material.color.copy( this.light.color );\\n\\t\\t\\t\\tthis.targetLine.material.color.copy( this.light.color );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.targetLine.lookAt( v3 );\\n\\t\\t\\tthis.targetLine.scale.z = v3.length();\\n\\n\\t\\t};\\n\\n\\t}();\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t *\\n\\t *\\t- shows frustum, line of sight and up of the camera\\n\\t *\\t- suitable for fast updates\\n\\t * \\t- based on frustum visualization in lightgl.js shadowmap example\\n\\t *\\t\\thttp://evanw.github.com/lightgl.js/tests/shadowmap.html\\n\\t */\\n\\n\\tfunction CameraHelper( camera ) {\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\t\\tvar material = new LineBasicMaterial( { color: 0xffffff, vertexColors: FaceColors } );\\n\\n\\t\\tvar vertices = [];\\n\\t\\tvar colors = [];\\n\\n\\t\\tvar pointMap = {};\\n\\n\\t\\t// colors\\n\\n\\t\\tvar colorFrustum = new Color( 0xffaa00 );\\n\\t\\tvar colorCone = new Color( 0xff0000 );\\n\\t\\tvar colorUp = new Color( 0x00aaff );\\n\\t\\tvar colorTarget = new Color( 0xffffff );\\n\\t\\tvar colorCross = new Color( 0x333333 );\\n\\n\\t\\t// near\\n\\n\\t\\taddLine( 'n1', 'n2', colorFrustum );\\n\\t\\taddLine( 'n2', 'n4', colorFrustum );\\n\\t\\taddLine( 'n4', 'n3', colorFrustum );\\n\\t\\taddLine( 'n3', 'n1', colorFrustum );\\n\\n\\t\\t// far\\n\\n\\t\\taddLine( 'f1', 'f2', colorFrustum );\\n\\t\\taddLine( 'f2', 'f4', colorFrustum );\\n\\t\\taddLine( 'f4', 'f3', colorFrustum );\\n\\t\\taddLine( 'f3', 'f1', colorFrustum );\\n\\n\\t\\t// sides\\n\\n\\t\\taddLine( 'n1', 'f1', colorFrustum );\\n\\t\\taddLine( 'n2', 'f2', colorFrustum );\\n\\t\\taddLine( 'n3', 'f3', colorFrustum );\\n\\t\\taddLine( 'n4', 'f4', colorFrustum );\\n\\n\\t\\t// cone\\n\\n\\t\\taddLine( 'p', 'n1', colorCone );\\n\\t\\taddLine( 'p', 'n2', colorCone );\\n\\t\\taddLine( 'p', 'n3', colorCone );\\n\\t\\taddLine( 'p', 'n4', colorCone );\\n\\n\\t\\t// up\\n\\n\\t\\taddLine( 'u1', 'u2', colorUp );\\n\\t\\taddLine( 'u2', 'u3', colorUp );\\n\\t\\taddLine( 'u3', 'u1', colorUp );\\n\\n\\t\\t// target\\n\\n\\t\\taddLine( 'c', 't', colorTarget );\\n\\t\\taddLine( 'p', 'c', colorCross );\\n\\n\\t\\t// cross\\n\\n\\t\\taddLine( 'cn1', 'cn2', colorCross );\\n\\t\\taddLine( 'cn3', 'cn4', colorCross );\\n\\n\\t\\taddLine( 'cf1', 'cf2', colorCross );\\n\\t\\taddLine( 'cf3', 'cf4', colorCross );\\n\\n\\t\\tfunction addLine( a, b, color ) {\\n\\n\\t\\t\\taddPoint( a, color );\\n\\t\\t\\taddPoint( b, color );\\n\\n\\t\\t}\\n\\n\\t\\tfunction addPoint( id, color ) {\\n\\n\\t\\t\\tvertices.push( 0, 0, 0 );\\n\\t\\t\\tcolors.push( color.r, color.g, color.b );\\n\\n\\t\\t\\tif ( pointMap[ id ] === undefined ) {\\n\\n\\t\\t\\t\\tpointMap[ id ] = [];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tpointMap[ id ].push( ( vertices.length / 3 ) - 1 );\\n\\n\\t\\t}\\n\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tgeometry.addAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );\\n\\n\\t\\tLineSegments.call( this, geometry, material );\\n\\n\\t\\tthis.camera = camera;\\n\\t\\tif ( this.camera.updateProjectionMatrix ) this.camera.updateProjectionMatrix();\\n\\n\\t\\tthis.matrix = camera.matrixWorld;\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t\\tthis.pointMap = pointMap;\\n\\n\\t\\tthis.update();\\n\\n\\t}\\n\\n\\tCameraHelper.prototype = Object.create( LineSegments.prototype );\\n\\tCameraHelper.prototype.constructor = CameraHelper;\\n\\n\\tCameraHelper.prototype.update = function () {\\n\\n\\t\\tvar geometry, pointMap;\\n\\n\\t\\tvar vector = new Vector3();\\n\\t\\tvar camera = new Camera();\\n\\n\\t\\tfunction setPoint( point, x, y, z ) {\\n\\n\\t\\t\\tvector.set( x, y, z ).unproject( camera );\\n\\n\\t\\t\\tvar points = pointMap[ point ];\\n\\n\\t\\t\\tif ( points !== undefined ) {\\n\\n\\t\\t\\t\\tvar position = geometry.getAttribute( 'position' );\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = points.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tposition.setXYZ( points[ i ], vector.x, vector.y, vector.z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\treturn function update() {\\n\\n\\t\\t\\tgeometry = this.geometry;\\n\\t\\t\\tpointMap = this.pointMap;\\n\\n\\t\\t\\tvar w = 1, h = 1;\\n\\n\\t\\t\\t// we need just camera projection matrix\\n\\t\\t\\t// world matrix must be identity\\n\\n\\t\\t\\tcamera.projectionMatrix.copy( this.camera.projectionMatrix );\\n\\n\\t\\t\\t// center / target\\n\\n\\t\\t\\tsetPoint( 'c', 0, 0, - 1 );\\n\\t\\t\\tsetPoint( 't', 0, 0, 1 );\\n\\n\\t\\t\\t// near\\n\\n\\t\\t\\tsetPoint( 'n1', - w, - h, - 1 );\\n\\t\\t\\tsetPoint( 'n2', w, - h, - 1 );\\n\\t\\t\\tsetPoint( 'n3', - w, h, - 1 );\\n\\t\\t\\tsetPoint( 'n4', w, h, - 1 );\\n\\n\\t\\t\\t// far\\n\\n\\t\\t\\tsetPoint( 'f1', - w, - h, 1 );\\n\\t\\t\\tsetPoint( 'f2', w, - h, 1 );\\n\\t\\t\\tsetPoint( 'f3', - w, h, 1 );\\n\\t\\t\\tsetPoint( 'f4', w, h, 1 );\\n\\n\\t\\t\\t// up\\n\\n\\t\\t\\tsetPoint( 'u1', w * 0.7, h * 1.1, - 1 );\\n\\t\\t\\tsetPoint( 'u2', - w * 0.7, h * 1.1, - 1 );\\n\\t\\t\\tsetPoint( 'u3', 0, h * 2, - 1 );\\n\\n\\t\\t\\t// cross\\n\\n\\t\\t\\tsetPoint( 'cf1', - w, 0, 1 );\\n\\t\\t\\tsetPoint( 'cf2', w, 0, 1 );\\n\\t\\t\\tsetPoint( 'cf3', 0, - h, 1 );\\n\\t\\t\\tsetPoint( 'cf4', 0, h, 1 );\\n\\n\\t\\t\\tsetPoint( 'cn1', - w, 0, - 1 );\\n\\t\\t\\tsetPoint( 'cn2', w, 0, - 1 );\\n\\t\\t\\tsetPoint( 'cn3', 0, - h, - 1 );\\n\\t\\t\\tsetPoint( 'cn4', 0, h, - 1 );\\n\\n\\t\\t\\tgeometry.getAttribute( 'position' ).needsUpdate = true;\\n\\n\\t\\t};\\n\\n\\t}();\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Mugen87 / http://github.com/Mugen87\\n\\t */\\n\\n\\tfunction BoxHelper( object, color ) {\\n\\n\\t\\tthis.object = object;\\n\\n\\t\\tif ( color === undefined ) color = 0xffff00;\\n\\n\\t\\tvar indices = new Uint16Array( [ 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7 ] );\\n\\t\\tvar positions = new Float32Array( 8 * 3 );\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\t\\tgeometry.setIndex( new BufferAttribute( indices, 1 ) );\\n\\t\\tgeometry.addAttribute( 'position', new BufferAttribute( positions, 3 ) );\\n\\n\\t\\tLineSegments.call( this, geometry, new LineBasicMaterial( { color: color } ) );\\n\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t\\tthis.update();\\n\\n\\t}\\n\\n\\tBoxHelper.prototype = Object.create( LineSegments.prototype );\\n\\tBoxHelper.prototype.constructor = BoxHelper;\\n\\n\\tBoxHelper.prototype.update = ( function () {\\n\\n\\t\\tvar box = new Box3();\\n\\n\\t\\treturn function update( object ) {\\n\\n\\t\\t\\tif ( object !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.BoxHelper: .update() has no longer arguments.' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.object !== undefined ) {\\n\\n\\t\\t\\t\\tbox.setFromObject( this.object );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( box.isEmpty() ) return;\\n\\n\\t\\t\\tvar min = box.min;\\n\\t\\t\\tvar max = box.max;\\n\\n\\t\\t\\t/*\\n\\t\\t\\t 5____4\\n\\t\\t\\t1/___0/|\\n\\t\\t\\t| 6__|_7\\n\\t\\t\\t2/___3/\\n\\n\\t\\t\\t0: max.x, max.y, max.z\\n\\t\\t\\t1: min.x, max.y, max.z\\n\\t\\t\\t2: min.x, min.y, max.z\\n\\t\\t\\t3: max.x, min.y, max.z\\n\\t\\t\\t4: max.x, max.y, min.z\\n\\t\\t\\t5: min.x, max.y, min.z\\n\\t\\t\\t6: min.x, min.y, min.z\\n\\t\\t\\t7: max.x, min.y, min.z\\n\\t\\t\\t*/\\n\\n\\t\\t\\tvar position = this.geometry.attributes.position;\\n\\t\\t\\tvar array = position.array;\\n\\n\\t\\t\\tarray[ 0 ] = max.x; array[ 1 ] = max.y; array[ 2 ] = max.z;\\n\\t\\t\\tarray[ 3 ] = min.x; array[ 4 ] = max.y; array[ 5 ] = max.z;\\n\\t\\t\\tarray[ 6 ] = min.x; array[ 7 ] = min.y; array[ 8 ] = max.z;\\n\\t\\t\\tarray[ 9 ] = max.x; array[ 10 ] = min.y; array[ 11 ] = max.z;\\n\\t\\t\\tarray[ 12 ] = max.x; array[ 13 ] = max.y; array[ 14 ] = min.z;\\n\\t\\t\\tarray[ 15 ] = min.x; array[ 16 ] = max.y; array[ 17 ] = min.z;\\n\\t\\t\\tarray[ 18 ] = min.x; array[ 19 ] = min.y; array[ 20 ] = min.z;\\n\\t\\t\\tarray[ 21 ] = max.x; array[ 22 ] = min.y; array[ 23 ] = min.z;\\n\\n\\t\\t\\tposition.needsUpdate = true;\\n\\n\\t\\t\\tthis.geometry.computeBoundingSphere();\\n\\n\\t\\t};\\n\\n\\t} )();\\n\\n\\tBoxHelper.prototype.setFromObject = function ( object ) {\\n\\n\\t\\tthis.object = object;\\n\\t\\tthis.update();\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction Box3Helper( box, hex ) {\\n\\n\\t\\tthis.type = 'Box3Helper';\\n\\n\\t\\tthis.box = box;\\n\\n\\t\\tvar color = ( hex !== undefined ) ? hex : 0xffff00;\\n\\n\\t\\tvar indices = new Uint16Array( [ 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7 ] );\\n\\n\\t\\tvar positions = [ 1, 1, 1, - 1, 1, 1, - 1, - 1, 1, 1, - 1, 1, 1, 1, - 1, - 1, 1, - 1, - 1, - 1, - 1, 1, - 1, - 1 ];\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\n\\t\\tgeometry.setIndex( new BufferAttribute( indices, 1 ) );\\n\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );\\n\\n\\t\\tLineSegments.call( this, geometry, new LineBasicMaterial( { color: color } ) );\\n\\n\\t\\tthis.geometry.computeBoundingSphere();\\n\\n\\t}\\n\\n\\tBox3Helper.prototype = Object.create( LineSegments.prototype );\\n\\tBox3Helper.prototype.constructor = Box3Helper;\\n\\n\\tBox3Helper.prototype.updateMatrixWorld = function ( force ) {\\n\\n\\t\\tvar box = this.box;\\n\\n\\t\\tif ( box.isEmpty() ) return;\\n\\n\\t\\tbox.getCenter( this.position );\\n\\n\\t\\tbox.getSize( this.scale );\\n\\n\\t\\tthis.scale.multiplyScalar( 0.5 );\\n\\n\\t\\tObject3D.prototype.updateMatrixWorld.call( this, force );\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction PlaneHelper( plane, size, hex ) {\\n\\n\\t\\tthis.type = 'PlaneHelper';\\n\\n\\t\\tthis.plane = plane;\\n\\n\\t\\tthis.size = ( size === undefined ) ? 1 : size;\\n\\n\\t\\tvar color = ( hex !== undefined ) ? hex : 0xffff00;\\n\\n\\t\\tvar positions = [ 1, - 1, 1, - 1, 1, 1, - 1, - 1, 1, 1, 1, 1, - 1, 1, 1, - 1, - 1, 1, 1, - 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0 ];\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );\\n\\t\\tgeometry.computeBoundingSphere();\\n\\n\\t\\tLine.call( this, geometry, new LineBasicMaterial( { color: color } ) );\\n\\n\\t\\t//\\n\\n\\t\\tvar positions2 = [ 1, 1, 1, - 1, 1, 1, - 1, - 1, 1, 1, 1, 1, - 1, - 1, 1, 1, - 1, 1 ];\\n\\n\\t\\tvar geometry2 = new BufferGeometry();\\n\\t\\tgeometry2.addAttribute( 'position', new Float32BufferAttribute( positions2, 3 ) );\\n\\t\\tgeometry2.computeBoundingSphere();\\n\\n\\t\\tthis.add( new Mesh( geometry2, new MeshBasicMaterial( { color: color, opacity: 0.2, transparent: true, depthWrite: false } ) ) );\\n\\n\\t}\\n\\n\\tPlaneHelper.prototype = Object.create( Line.prototype );\\n\\tPlaneHelper.prototype.constructor = PlaneHelper;\\n\\n\\tPlaneHelper.prototype.updateMatrixWorld = function ( force ) {\\n\\n\\t\\tvar scale = - this.plane.constant;\\n\\n\\t\\tif ( Math.abs( scale ) < 1e-8 ) scale = 1e-8; // sign does not matter\\n\\n\\t\\tthis.scale.set( 0.5 * this.size, 0.5 * this.size, scale );\\n\\n\\t\\tthis.lookAt( this.plane.normal );\\n\\n\\t\\tObject3D.prototype.updateMatrixWorld.call( this, force );\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t * @author zz85 / http://github.com/zz85\\n\\t * @author bhouston / http://clara.io\\n\\t *\\n\\t * Creates an arrow for visualizing directions\\n\\t *\\n\\t * Parameters:\\n\\t * dir - Vector3\\n\\t * origin - Vector3\\n\\t * length - Number\\n\\t * color - color in hex value\\n\\t * headLength - Number\\n\\t * headWidth - Number\\n\\t */\\n\\n\\tvar lineGeometry;\\n\\tvar coneGeometry;\\n\\n\\tfunction ArrowHelper( dir, origin, length, color, headLength, headWidth ) {\\n\\n\\t\\t// dir is assumed to be normalized\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tif ( color === undefined ) color = 0xffff00;\\n\\t\\tif ( length === undefined ) length = 1;\\n\\t\\tif ( headLength === undefined ) headLength = 0.2 * length;\\n\\t\\tif ( headWidth === undefined ) headWidth = 0.2 * headLength;\\n\\n\\t\\tif ( lineGeometry === undefined ) {\\n\\n\\t\\t\\tlineGeometry = new BufferGeometry();\\n\\t\\t\\tlineGeometry.addAttribute( 'position', new Float32BufferAttribute( [ 0, 0, 0, 0, 1, 0 ], 3 ) );\\n\\n\\t\\t\\tconeGeometry = new CylinderBufferGeometry( 0, 0.5, 1, 5, 1 );\\n\\t\\t\\tconeGeometry.translate( 0, - 0.5, 0 );\\n\\n\\t\\t}\\n\\n\\t\\tthis.position.copy( origin );\\n\\n\\t\\tthis.line = new Line( lineGeometry, new LineBasicMaterial( { color: color } ) );\\n\\t\\tthis.line.matrixAutoUpdate = false;\\n\\t\\tthis.add( this.line );\\n\\n\\t\\tthis.cone = new Mesh( coneGeometry, new MeshBasicMaterial( { color: color } ) );\\n\\t\\tthis.cone.matrixAutoUpdate = false;\\n\\t\\tthis.add( this.cone );\\n\\n\\t\\tthis.setDirection( dir );\\n\\t\\tthis.setLength( length, headLength, headWidth );\\n\\n\\t}\\n\\n\\tArrowHelper.prototype = Object.create( Object3D.prototype );\\n\\tArrowHelper.prototype.constructor = ArrowHelper;\\n\\n\\tArrowHelper.prototype.setDirection = ( function () {\\n\\n\\t\\tvar axis = new Vector3();\\n\\t\\tvar radians;\\n\\n\\t\\treturn function setDirection( dir ) {\\n\\n\\t\\t\\t// dir is assumed to be normalized\\n\\n\\t\\t\\tif ( dir.y > 0.99999 ) {\\n\\n\\t\\t\\t\\tthis.quaternion.set( 0, 0, 0, 1 );\\n\\n\\t\\t\\t} else if ( dir.y < - 0.99999 ) {\\n\\n\\t\\t\\t\\tthis.quaternion.set( 1, 0, 0, 0 );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\taxis.set( dir.z, 0, - dir.x ).normalize();\\n\\n\\t\\t\\t\\tradians = Math.acos( dir.y );\\n\\n\\t\\t\\t\\tthis.quaternion.setFromAxisAngle( axis, radians );\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t}() );\\n\\n\\tArrowHelper.prototype.setLength = function ( length, headLength, headWidth ) {\\n\\n\\t\\tif ( headLength === undefined ) headLength = 0.2 * length;\\n\\t\\tif ( headWidth === undefined ) headWidth = 0.2 * headLength;\\n\\n\\t\\tthis.line.scale.set( 1, Math.max( 0, length - headLength ), 1 );\\n\\t\\tthis.line.updateMatrix();\\n\\n\\t\\tthis.cone.scale.set( headWidth, headLength, headWidth );\\n\\t\\tthis.cone.position.y = length;\\n\\t\\tthis.cone.updateMatrix();\\n\\n\\t};\\n\\n\\tArrowHelper.prototype.setColor = function ( color ) {\\n\\n\\t\\tthis.line.material.color.copy( color );\\n\\t\\tthis.cone.material.color.copy( color );\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author sroucheray / http://sroucheray.org/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction AxesHelper( size ) {\\n\\n\\t\\tsize = size || 1;\\n\\n\\t\\tvar vertices = [\\n\\t\\t\\t0, 0, 0,\\tsize, 0, 0,\\n\\t\\t\\t0, 0, 0,\\t0, size, 0,\\n\\t\\t\\t0, 0, 0,\\t0, 0, size\\n\\t\\t];\\n\\n\\t\\tvar colors = [\\n\\t\\t\\t1, 0, 0,\\t1, 0.6, 0,\\n\\t\\t\\t0, 1, 0,\\t0.6, 1, 0,\\n\\t\\t\\t0, 0, 1,\\t0, 0.6, 1\\n\\t\\t];\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tgeometry.addAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );\\n\\n\\t\\tvar material = new LineBasicMaterial( { vertexColors: VertexColors } );\\n\\n\\t\\tLineSegments.call( this, geometry, material );\\n\\n\\t}\\n\\n\\tAxesHelper.prototype = Object.create( LineSegments.prototype );\\n\\tAxesHelper.prototype.constructor = AxesHelper;\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tvar SceneUtils = {\\n\\n\\t\\tcreateMultiMaterialObject: function ( geometry, materials ) {\\n\\n\\t\\t\\tvar group = new Group();\\n\\n\\t\\t\\tfor ( var i = 0, l = materials.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tgroup.add( new Mesh( geometry, materials[ i ] ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn group;\\n\\n\\t\\t},\\n\\n\\t\\tdetach: function ( child, parent, scene ) {\\n\\n\\t\\t\\tchild.applyMatrix( parent.matrixWorld );\\n\\t\\t\\tparent.remove( child );\\n\\t\\t\\tscene.add( child );\\n\\n\\t\\t},\\n\\n\\t\\tattach: function ( child, scene, parent ) {\\n\\n\\t\\t\\tchild.applyMatrix( new Matrix4().getInverse( parent.matrixWorld ) );\\n\\n\\t\\t\\tscene.remove( child );\\n\\t\\t\\tparent.add( child );\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Face4( a, b, c, d, normal, color, materialIndex ) {\\n\\n\\t\\tconsole.warn( 'THREE.Face4 has been removed. A THREE.Face3 will be created instead.' );\\n\\t\\treturn new Face3( a, b, c, normal, color, materialIndex );\\n\\n\\t}\\n\\n\\tvar LineStrip = 0;\\n\\n\\tvar LinePieces = 1;\\n\\n\\tfunction MeshFaceMaterial( materials ) {\\n\\n\\t\\tconsole.warn( 'THREE.MeshFaceMaterial has been removed. Use an Array instead.' );\\n\\t\\treturn materials;\\n\\n\\t}\\n\\n\\tfunction MultiMaterial( materials ) {\\n\\n\\t\\tif ( materials === undefined ) materials = [];\\n\\n\\t\\tconsole.warn( 'THREE.MultiMaterial has been removed. Use an Array instead.' );\\n\\t\\tmaterials.isMultiMaterial = true;\\n\\t\\tmaterials.materials = materials;\\n\\t\\tmaterials.clone = function () {\\n\\n\\t\\t\\treturn materials.slice();\\n\\n\\t\\t};\\n\\t\\treturn materials;\\n\\n\\t}\\n\\n\\tfunction PointCloud( geometry, material ) {\\n\\n\\t\\tconsole.warn( 'THREE.PointCloud has been renamed to THREE.Points.' );\\n\\t\\treturn new Points( geometry, material );\\n\\n\\t}\\n\\n\\tfunction Particle( material ) {\\n\\n\\t\\tconsole.warn( 'THREE.Particle has been renamed to THREE.Sprite.' );\\n\\t\\treturn new Sprite( material );\\n\\n\\t}\\n\\n\\tfunction ParticleSystem( geometry, material ) {\\n\\n\\t\\tconsole.warn( 'THREE.ParticleSystem has been renamed to THREE.Points.' );\\n\\t\\treturn new Points( geometry, material );\\n\\n\\t}\\n\\n\\tfunction PointCloudMaterial( parameters ) {\\n\\n\\t\\tconsole.warn( 'THREE.PointCloudMaterial has been renamed to THREE.PointsMaterial.' );\\n\\t\\treturn new PointsMaterial( parameters );\\n\\n\\t}\\n\\n\\tfunction ParticleBasicMaterial( parameters ) {\\n\\n\\t\\tconsole.warn( 'THREE.ParticleBasicMaterial has been renamed to THREE.PointsMaterial.' );\\n\\t\\treturn new PointsMaterial( parameters );\\n\\n\\t}\\n\\n\\tfunction ParticleSystemMaterial( parameters ) {\\n\\n\\t\\tconsole.warn( 'THREE.ParticleSystemMaterial has been renamed to THREE.PointsMaterial.' );\\n\\t\\treturn new PointsMaterial( parameters );\\n\\n\\t}\\n\\n\\tfunction Vertex( x, y, z ) {\\n\\n\\t\\tconsole.warn( 'THREE.Vertex has been removed. Use THREE.Vector3 instead.' );\\n\\t\\treturn new Vector3( x, y, z );\\n\\n\\t}\\n\\n\\t//\\n\\n\\tfunction DynamicBufferAttribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.DynamicBufferAttribute has been removed. Use new THREE.BufferAttribute().setDynamic( true ) instead.' );\\n\\t\\treturn new BufferAttribute( array, itemSize ).setDynamic( true );\\n\\n\\t}\\n\\n\\tfunction Int8Attribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Int8Attribute has been removed. Use new THREE.Int8BufferAttribute() instead.' );\\n\\t\\treturn new Int8BufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\tfunction Uint8Attribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Uint8Attribute has been removed. Use new THREE.Uint8BufferAttribute() instead.' );\\n\\t\\treturn new Uint8BufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\tfunction Uint8ClampedAttribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Uint8ClampedAttribute has been removed. Use new THREE.Uint8ClampedBufferAttribute() instead.' );\\n\\t\\treturn new Uint8ClampedBufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\tfunction Int16Attribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Int16Attribute has been removed. Use new THREE.Int16BufferAttribute() instead.' );\\n\\t\\treturn new Int16BufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\tfunction Uint16Attribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Uint16Attribute has been removed. Use new THREE.Uint16BufferAttribute() instead.' );\\n\\t\\treturn new Uint16BufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\tfunction Int32Attribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Int32Attribute has been removed. Use new THREE.Int32BufferAttribute() instead.' );\\n\\t\\treturn new Int32BufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\tfunction Uint32Attribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Uint32Attribute has been removed. Use new THREE.Uint32BufferAttribute() instead.' );\\n\\t\\treturn new Uint32BufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\tfunction Float32Attribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Float32Attribute has been removed. Use new THREE.Float32BufferAttribute() instead.' );\\n\\t\\treturn new Float32BufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\tfunction Float64Attribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Float64Attribute has been removed. Use new THREE.Float64BufferAttribute() instead.' );\\n\\t\\treturn new Float64BufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\t//\\n\\n\\tCurve.create = function ( construct, getPoint ) {\\n\\n\\t\\tconsole.log( 'THREE.Curve.create() has been deprecated' );\\n\\n\\t\\tconstruct.prototype = Object.create( Curve.prototype );\\n\\t\\tconstruct.prototype.constructor = construct;\\n\\t\\tconstruct.prototype.getPoint = getPoint;\\n\\n\\t\\treturn construct;\\n\\n\\t};\\n\\n\\t//\\n\\n\\tObject.assign( CurvePath.prototype, {\\n\\n\\t\\tcreatePointsGeometry: function ( divisions ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.CurvePath: .createPointsGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.' );\\n\\n\\t\\t\\t// generate geometry from path points (for Line or Points objects)\\n\\n\\t\\t\\tvar pts = this.getPoints( divisions );\\n\\t\\t\\treturn this.createGeometry( pts );\\n\\n\\t\\t},\\n\\n\\t\\tcreateSpacedPointsGeometry: function ( divisions ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.CurvePath: .createSpacedPointsGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.' );\\n\\n\\t\\t\\t// generate geometry from equidistant sampling along the path\\n\\n\\t\\t\\tvar pts = this.getSpacedPoints( divisions );\\n\\t\\t\\treturn this.createGeometry( pts );\\n\\n\\t\\t},\\n\\n\\t\\tcreateGeometry: function ( points ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.CurvePath: .createGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.' );\\n\\n\\t\\t\\tvar geometry = new Geometry();\\n\\n\\t\\t\\tfor ( var i = 0, l = points.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar point = points[ i ];\\n\\t\\t\\t\\tgeometry.vertices.push( new Vector3( point.x, point.y, point.z || 0 ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn geometry;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tObject.assign( Path.prototype, {\\n\\n\\t\\tfromPoints: function ( points ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Path: .fromPoints() has been renamed to .setFromPoints().' );\\n\\t\\t\\tthis.setFromPoints( points );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tfunction ClosedSplineCurve3( points ) {\\n\\n\\t\\tconsole.warn( 'THREE.ClosedSplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead.' );\\n\\n\\t\\tCatmullRomCurve3.call( this, points );\\n\\t\\tthis.type = 'catmullrom';\\n\\t\\tthis.closed = true;\\n\\n\\t}\\n\\n\\tClosedSplineCurve3.prototype = Object.create( CatmullRomCurve3.prototype );\\n\\n\\t//\\n\\n\\tfunction SplineCurve3( points ) {\\n\\n\\t\\tconsole.warn( 'THREE.SplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead.' );\\n\\n\\t\\tCatmullRomCurve3.call( this, points );\\n\\t\\tthis.type = 'catmullrom';\\n\\n\\t}\\n\\n\\tSplineCurve3.prototype = Object.create( CatmullRomCurve3.prototype );\\n\\n\\t//\\n\\n\\tfunction Spline( points ) {\\n\\n\\t\\tconsole.warn( 'THREE.Spline has been removed. Use THREE.CatmullRomCurve3 instead.' );\\n\\n\\t\\tCatmullRomCurve3.call( this, points );\\n\\t\\tthis.type = 'catmullrom';\\n\\n\\t}\\n\\n\\tSpline.prototype = Object.create( CatmullRomCurve3.prototype );\\n\\n\\tObject.assign( Spline.prototype, {\\n\\n\\t\\tinitFromArray: function ( /* a */ ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Spline: .initFromArray() has been removed.' );\\n\\n\\t\\t},\\n\\t\\tgetControlPointsArray: function ( /* optionalTarget */ ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Spline: .getControlPointsArray() has been removed.' );\\n\\n\\t\\t},\\n\\t\\treparametrizeByArcLength: function ( /* samplingCoef */ ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Spline: .reparametrizeByArcLength() has been removed.' );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tfunction AxisHelper( size ) {\\n\\n\\t\\tconsole.warn( 'THREE.AxisHelper has been renamed to THREE.AxesHelper.' );\\n\\t\\treturn new AxesHelper( size );\\n\\n\\t}\\n\\n\\tfunction BoundingBoxHelper( object, color ) {\\n\\n\\t\\tconsole.warn( 'THREE.BoundingBoxHelper has been deprecated. Creating a THREE.BoxHelper instead.' );\\n\\t\\treturn new BoxHelper( object, color );\\n\\n\\t}\\n\\n\\tfunction EdgesHelper( object, hex ) {\\n\\n\\t\\tconsole.warn( 'THREE.EdgesHelper has been removed. Use THREE.EdgesGeometry instead.' );\\n\\t\\treturn new LineSegments( new EdgesGeometry( object.geometry ), new LineBasicMaterial( { color: hex !== undefined ? hex : 0xffffff } ) );\\n\\n\\t}\\n\\n\\tGridHelper.prototype.setColors = function () {\\n\\n\\t\\tconsole.error( 'THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.' );\\n\\n\\t};\\n\\n\\tSkeletonHelper.prototype.update = function () {\\n\\n\\t\\tconsole.error( 'THREE.SkeletonHelper: update() no longer needs to be called.' );\\n\\n\\t};\\n\\n\\tfunction WireframeHelper( object, hex ) {\\n\\n\\t\\tconsole.warn( 'THREE.WireframeHelper has been removed. Use THREE.WireframeGeometry instead.' );\\n\\t\\treturn new LineSegments( new WireframeGeometry( object.geometry ), new LineBasicMaterial( { color: hex !== undefined ? hex : 0xffffff } ) );\\n\\n\\t}\\n\\n\\t//\\n\\n\\tObject.assign( Loader.prototype, {\\n\\n\\t\\textractUrlBase: function ( url ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead.' );\\n\\t\\t\\treturn LoaderUtils.extractUrlBase( url );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tfunction XHRLoader( manager ) {\\n\\n\\t\\tconsole.warn( 'THREE.XHRLoader has been renamed to THREE.FileLoader.' );\\n\\t\\treturn new FileLoader( manager );\\n\\n\\t}\\n\\n\\tfunction BinaryTextureLoader( manager ) {\\n\\n\\t\\tconsole.warn( 'THREE.BinaryTextureLoader has been renamed to THREE.DataTextureLoader.' );\\n\\t\\treturn new DataTextureLoader( manager );\\n\\n\\t}\\n\\n\\t//\\n\\n\\tObject.assign( Box2.prototype, {\\n\\n\\t\\tcenter: function ( optionalTarget ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box2: .center() has been renamed to .getCenter().' );\\n\\t\\t\\treturn this.getCenter( optionalTarget );\\n\\n\\t\\t},\\n\\t\\tempty: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box2: .empty() has been renamed to .isEmpty().' );\\n\\t\\t\\treturn this.isEmpty();\\n\\n\\t\\t},\\n\\t\\tisIntersectionBox: function ( box ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox().' );\\n\\t\\t\\treturn this.intersectsBox( box );\\n\\n\\t\\t},\\n\\t\\tsize: function ( optionalTarget ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box2: .size() has been renamed to .getSize().' );\\n\\t\\t\\treturn this.getSize( optionalTarget );\\n\\n\\t\\t}\\n\\t} );\\n\\n\\tObject.assign( Box3.prototype, {\\n\\n\\t\\tcenter: function ( optionalTarget ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box3: .center() has been renamed to .getCenter().' );\\n\\t\\t\\treturn this.getCenter( optionalTarget );\\n\\n\\t\\t},\\n\\t\\tempty: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box3: .empty() has been renamed to .isEmpty().' );\\n\\t\\t\\treturn this.isEmpty();\\n\\n\\t\\t},\\n\\t\\tisIntersectionBox: function ( box ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox().' );\\n\\t\\t\\treturn this.intersectsBox( box );\\n\\n\\t\\t},\\n\\t\\tisIntersectionSphere: function ( sphere ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere().' );\\n\\t\\t\\treturn this.intersectsSphere( sphere );\\n\\n\\t\\t},\\n\\t\\tsize: function ( optionalTarget ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box3: .size() has been renamed to .getSize().' );\\n\\t\\t\\treturn this.getSize( optionalTarget );\\n\\n\\t\\t}\\n\\t} );\\n\\n\\tLine3.prototype.center = function ( optionalTarget ) {\\n\\n\\t\\tconsole.warn( 'THREE.Line3: .center() has been renamed to .getCenter().' );\\n\\t\\treturn this.getCenter( optionalTarget );\\n\\n\\t};\\n\\n\\tObject.assign( _Math, {\\n\\n\\t\\trandom16: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Math: .random16() has been deprecated. Use Math.random() instead.' );\\n\\t\\t\\treturn Math.random();\\n\\n\\t\\t},\\n\\n\\t\\tnearestPowerOfTwo: function ( value ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Math: .nearestPowerOfTwo() has been renamed to .floorPowerOfTwo().' );\\n\\t\\t\\treturn _Math.floorPowerOfTwo( value );\\n\\n\\t\\t},\\n\\n\\t\\tnextPowerOfTwo: function ( value ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Math: .nextPowerOfTwo() has been renamed to .ceilPowerOfTwo().' );\\n\\t\\t\\treturn _Math.ceilPowerOfTwo( value );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Matrix3.prototype, {\\n\\n\\t\\tflattenToArrayOffset: function ( array, offset ) {\\n\\n\\t\\t\\tconsole.warn( \\\"THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead.\\\" );\\n\\t\\t\\treturn this.toArray( array, offset );\\n\\n\\t\\t},\\n\\t\\tmultiplyVector3: function ( vector ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead.' );\\n\\t\\t\\treturn vector.applyMatrix3( this );\\n\\n\\t\\t},\\n\\t\\tmultiplyVector3Array: function ( /* a */ ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix3: .multiplyVector3Array() has been removed.' );\\n\\n\\t\\t},\\n\\t\\tapplyToBuffer: function ( buffer /*, offset, length */ ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix3: .applyToBuffer() has been removed. Use matrix.applyToBufferAttribute( attribute ) instead.' );\\n\\t\\t\\treturn this.applyToBufferAttribute( buffer );\\n\\n\\t\\t},\\n\\t\\tapplyToVector3Array: function ( /* array, offset, length */ ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix3: .applyToVector3Array() has been removed.' );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Matrix4.prototype, {\\n\\n\\t\\textractPosition: function ( m ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .extractPosition() has been renamed to .copyPosition().' );\\n\\t\\t\\treturn this.copyPosition( m );\\n\\n\\t\\t},\\n\\t\\tflattenToArrayOffset: function ( array, offset ) {\\n\\n\\t\\t\\tconsole.warn( \\\"THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead.\\\" );\\n\\t\\t\\treturn this.toArray( array, offset );\\n\\n\\t\\t},\\n\\t\\tgetPosition: function () {\\n\\n\\t\\t\\tvar v1;\\n\\n\\t\\t\\treturn function getPosition() {\\n\\n\\t\\t\\t\\tif ( v1 === undefined ) v1 = new Vector3();\\n\\t\\t\\t\\tconsole.warn( 'THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead.' );\\n\\t\\t\\t\\treturn v1.setFromMatrixColumn( this, 3 );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\t\\tsetRotationFromQuaternion: function ( q ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion().' );\\n\\t\\t\\treturn this.makeRotationFromQuaternion( q );\\n\\n\\t\\t},\\n\\t\\tmultiplyToArray: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .multiplyToArray() has been removed.' );\\n\\n\\t\\t},\\n\\t\\tmultiplyVector3: function ( vector ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead.' );\\n\\t\\t\\treturn vector.applyMatrix4( this );\\n\\n\\t\\t},\\n\\t\\tmultiplyVector4: function ( vector ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead.' );\\n\\t\\t\\treturn vector.applyMatrix4( this );\\n\\n\\t\\t},\\n\\t\\tmultiplyVector3Array: function ( /* a */ ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix4: .multiplyVector3Array() has been removed.' );\\n\\n\\t\\t},\\n\\t\\trotateAxis: function ( v ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead.' );\\n\\t\\t\\tv.transformDirection( this );\\n\\n\\t\\t},\\n\\t\\tcrossVector: function ( vector ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead.' );\\n\\t\\t\\treturn vector.applyMatrix4( this );\\n\\n\\t\\t},\\n\\t\\ttranslate: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix4: .translate() has been removed.' );\\n\\n\\t\\t},\\n\\t\\trotateX: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix4: .rotateX() has been removed.' );\\n\\n\\t\\t},\\n\\t\\trotateY: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix4: .rotateY() has been removed.' );\\n\\n\\t\\t},\\n\\t\\trotateZ: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix4: .rotateZ() has been removed.' );\\n\\n\\t\\t},\\n\\t\\trotateByAxis: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix4: .rotateByAxis() has been removed.' );\\n\\n\\t\\t},\\n\\t\\tapplyToBuffer: function ( buffer /*, offset, length */ ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .applyToBuffer() has been removed. Use matrix.applyToBufferAttribute( attribute ) instead.' );\\n\\t\\t\\treturn this.applyToBufferAttribute( buffer );\\n\\n\\t\\t},\\n\\t\\tapplyToVector3Array: function ( /* array, offset, length */ ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix4: .applyToVector3Array() has been removed.' );\\n\\n\\t\\t},\\n\\t\\tmakeFrustum: function ( left, right, bottom, top, near, far ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead.' );\\n\\t\\t\\treturn this.makePerspective( left, right, top, bottom, near, far );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tPlane.prototype.isIntersectionLine = function ( line ) {\\n\\n\\t\\tconsole.warn( 'THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine().' );\\n\\t\\treturn this.intersectsLine( line );\\n\\n\\t};\\n\\n\\tQuaternion.prototype.multiplyVector3 = function ( vector ) {\\n\\n\\t\\tconsole.warn( 'THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead.' );\\n\\t\\treturn vector.applyQuaternion( this );\\n\\n\\t};\\n\\n\\tObject.assign( Ray.prototype, {\\n\\n\\t\\tisIntersectionBox: function ( box ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox().' );\\n\\t\\t\\treturn this.intersectsBox( box );\\n\\n\\t\\t},\\n\\t\\tisIntersectionPlane: function ( plane ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane().' );\\n\\t\\t\\treturn this.intersectsPlane( plane );\\n\\n\\t\\t},\\n\\t\\tisIntersectionSphere: function ( sphere ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere().' );\\n\\t\\t\\treturn this.intersectsSphere( sphere );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Shape.prototype, {\\n\\n\\t\\textractAllPoints: function ( divisions ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead.' );\\n\\t\\t\\treturn this.extractPoints( divisions );\\n\\n\\t\\t},\\n\\t\\textrude: function ( options ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead.' );\\n\\t\\t\\treturn new ExtrudeGeometry( this, options );\\n\\n\\t\\t},\\n\\t\\tmakeGeometry: function ( options ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead.' );\\n\\t\\t\\treturn new ShapeGeometry( this, options );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Vector2.prototype, {\\n\\n\\t\\tfromAttribute: function ( attribute, index, offset ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute().' );\\n\\t\\t\\treturn this.fromBufferAttribute( attribute, index, offset );\\n\\n\\t\\t},\\n\\t\\tdistanceToManhattan: function ( v ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo().' );\\n\\t\\t\\treturn this.manhattanDistanceTo( v );\\n\\n\\t\\t},\\n\\t\\tlengthManhattan: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength().' );\\n\\t\\t\\treturn this.manhattanLength();\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Vector3.prototype, {\\n\\n\\t\\tsetEulerFromRotationMatrix: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.' );\\n\\n\\t\\t},\\n\\t\\tsetEulerFromQuaternion: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.' );\\n\\n\\t\\t},\\n\\t\\tgetPositionFromMatrix: function ( m ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition().' );\\n\\t\\t\\treturn this.setFromMatrixPosition( m );\\n\\n\\t\\t},\\n\\t\\tgetScaleFromMatrix: function ( m ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale().' );\\n\\t\\t\\treturn this.setFromMatrixScale( m );\\n\\n\\t\\t},\\n\\t\\tgetColumnFromMatrix: function ( index, matrix ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn().' );\\n\\t\\t\\treturn this.setFromMatrixColumn( matrix, index );\\n\\n\\t\\t},\\n\\t\\tapplyProjection: function ( m ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead.' );\\n\\t\\t\\treturn this.applyMatrix4( m );\\n\\n\\t\\t},\\n\\t\\tfromAttribute: function ( attribute, index, offset ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute().' );\\n\\t\\t\\treturn this.fromBufferAttribute( attribute, index, offset );\\n\\n\\t\\t},\\n\\t\\tdistanceToManhattan: function ( v ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo().' );\\n\\t\\t\\treturn this.manhattanDistanceTo( v );\\n\\n\\t\\t},\\n\\t\\tlengthManhattan: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength().' );\\n\\t\\t\\treturn this.manhattanLength();\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Vector4.prototype, {\\n\\n\\t\\tfromAttribute: function ( attribute, index, offset ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute().' );\\n\\t\\t\\treturn this.fromBufferAttribute( attribute, index, offset );\\n\\n\\t\\t},\\n\\t\\tlengthManhattan: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength().' );\\n\\t\\t\\treturn this.manhattanLength();\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tGeometry.prototype.computeTangents = function () {\\n\\n\\t\\tconsole.warn( 'THREE.Geometry: .computeTangents() has been removed.' );\\n\\n\\t};\\n\\n\\tObject.assign( Object3D.prototype, {\\n\\n\\t\\tgetChildByName: function ( name ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Object3D: .getChildByName() has been renamed to .getObjectByName().' );\\n\\t\\t\\treturn this.getObjectByName( name );\\n\\n\\t\\t},\\n\\t\\trenderDepth: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.' );\\n\\n\\t\\t},\\n\\t\\ttranslate: function ( distance, axis ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead.' );\\n\\t\\t\\treturn this.translateOnAxis( axis, distance );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperties( Object3D.prototype, {\\n\\n\\t\\teulerOrder: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Object3D: .eulerOrder is now .rotation.order.' );\\n\\t\\t\\t\\treturn this.rotation.order;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Object3D: .eulerOrder is now .rotation.order.' );\\n\\t\\t\\t\\tthis.rotation.order = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tuseQuaternion: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.' );\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.' );\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperties( LOD.prototype, {\\n\\n\\t\\tobjects: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.LOD: .objects has been renamed to .levels.' );\\n\\t\\t\\t\\treturn this.levels;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperty( Skeleton.prototype, 'useVertexTexture', {\\n\\n\\t\\tget: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Skeleton: useVertexTexture has been removed.' );\\n\\n\\t\\t},\\n\\t\\tset: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Skeleton: useVertexTexture has been removed.' );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperty( Curve.prototype, '__arcLengthDivisions', {\\n\\n\\t\\tget: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.' );\\n\\t\\t\\treturn this.arcLengthDivisions;\\n\\n\\t\\t},\\n\\t\\tset: function ( value ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.' );\\n\\t\\t\\tthis.arcLengthDivisions = value;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tPerspectiveCamera.prototype.setLens = function ( focalLength, filmGauge ) {\\n\\n\\t\\tconsole.warn( \\\"THREE.PerspectiveCamera.setLens is deprecated. \\\" +\\n\\t\\t\\t\\t\\\"Use .setFocalLength and .filmGauge for a photographic setup.\\\" );\\n\\n\\t\\tif ( filmGauge !== undefined ) this.filmGauge = filmGauge;\\n\\t\\tthis.setFocalLength( focalLength );\\n\\n\\t};\\n\\n\\t//\\n\\n\\tObject.defineProperties( Light.prototype, {\\n\\t\\tonlyShadow: {\\n\\t\\t\\tset: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .onlyShadow has been removed.' );\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowCameraFov: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowCameraFov is now .shadow.camera.fov.' );\\n\\t\\t\\t\\tthis.shadow.camera.fov = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowCameraLeft: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowCameraLeft is now .shadow.camera.left.' );\\n\\t\\t\\t\\tthis.shadow.camera.left = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowCameraRight: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowCameraRight is now .shadow.camera.right.' );\\n\\t\\t\\t\\tthis.shadow.camera.right = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowCameraTop: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowCameraTop is now .shadow.camera.top.' );\\n\\t\\t\\t\\tthis.shadow.camera.top = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowCameraBottom: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom.' );\\n\\t\\t\\t\\tthis.shadow.camera.bottom = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowCameraNear: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowCameraNear is now .shadow.camera.near.' );\\n\\t\\t\\t\\tthis.shadow.camera.near = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowCameraFar: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowCameraFar is now .shadow.camera.far.' );\\n\\t\\t\\t\\tthis.shadow.camera.far = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowCameraVisible: {\\n\\t\\t\\tset: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.' );\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowBias: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowBias is now .shadow.bias.' );\\n\\t\\t\\t\\tthis.shadow.bias = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowDarkness: {\\n\\t\\t\\tset: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowDarkness has been removed.' );\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowMapWidth: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowMapWidth is now .shadow.mapSize.width.' );\\n\\t\\t\\t\\tthis.shadow.mapSize.width = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowMapHeight: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowMapHeight is now .shadow.mapSize.height.' );\\n\\t\\t\\t\\tthis.shadow.mapSize.height = value;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\t} );\\n\\n\\t//\\n\\n\\tObject.defineProperties( BufferAttribute.prototype, {\\n\\n\\t\\tlength: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.BufferAttribute: .length has been deprecated. Use .count instead.' );\\n\\t\\t\\t\\treturn this.array.length;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( BufferGeometry.prototype, {\\n\\n\\t\\taddIndex: function ( index ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.BufferGeometry: .addIndex() has been renamed to .setIndex().' );\\n\\t\\t\\tthis.setIndex( index );\\n\\n\\t\\t},\\n\\t\\taddDrawCall: function ( start, count, indexOffset ) {\\n\\n\\t\\t\\tif ( indexOffset !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset.' );\\n\\n\\t\\t\\t}\\n\\t\\t\\tconsole.warn( 'THREE.BufferGeometry: .addDrawCall() is now .addGroup().' );\\n\\t\\t\\tthis.addGroup( start, count );\\n\\n\\t\\t},\\n\\t\\tclearDrawCalls: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups().' );\\n\\t\\t\\tthis.clearGroups();\\n\\n\\t\\t},\\n\\t\\tcomputeTangents: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.BufferGeometry: .computeTangents() has been removed.' );\\n\\n\\t\\t},\\n\\t\\tcomputeOffsets: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.BufferGeometry: .computeOffsets() has been removed.' );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperties( BufferGeometry.prototype, {\\n\\n\\t\\tdrawcalls: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.BufferGeometry: .drawcalls has been renamed to .groups.' );\\n\\t\\t\\t\\treturn this.groups;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\toffsets: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.BufferGeometry: .offsets has been renamed to .groups.' );\\n\\t\\t\\t\\treturn this.groups;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tObject.defineProperties( Uniform.prototype, {\\n\\n\\t\\tdynamic: {\\n\\t\\t\\tset: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Uniform: .dynamic has been removed. Use object.onBeforeRender() instead.' );\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tonUpdate: {\\n\\t\\t\\tvalue: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead.' );\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tObject.defineProperties( Material.prototype, {\\n\\n\\t\\twrapAround: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Material: .wrapAround has been removed.' );\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Material: .wrapAround has been removed.' );\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\twrapRGB: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Material: .wrapRGB has been removed.' );\\n\\t\\t\\t\\treturn new Color();\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\n\\t\\tshading: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.' + this.type + ': .shading has been removed. Use the boolean .flatShading instead.' );\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.' + this.type + ': .shading has been removed. Use the boolean .flatShading instead.' );\\n\\t\\t\\t\\tthis.flatShading = ( value === FlatShading );\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperties( MeshPhongMaterial.prototype, {\\n\\n\\t\\tmetal: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead.' );\\n\\t\\t\\t\\treturn false;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead' );\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperties( ShaderMaterial.prototype, {\\n\\n\\t\\tderivatives: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives.' );\\n\\t\\t\\t\\treturn this.extensions.derivatives;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives.' );\\n\\t\\t\\t\\tthis.extensions.derivatives = value;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tObject.assign( WebGLRenderer.prototype, {\\n\\n\\t\\tgetCurrentRenderTarget: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget().' );\\n\\t\\t\\treturn this.getRenderTarget();\\n\\n\\t\\t},\\n\\n\\t\\tgetMaxAnisotropy: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy().' );\\n\\t\\t\\treturn this.capabilities.getMaxAnisotropy();\\n\\n\\t\\t},\\n\\n\\t\\tgetPrecision: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision.' );\\n\\t\\t\\treturn this.capabilities.precision;\\n\\n\\t\\t},\\n\\n\\t\\tresetGLState: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .resetGLState() is now .state.reset().' );\\n\\t\\t\\treturn this.state.reset();\\n\\n\\t\\t},\\n\\n\\t\\tsupportsFloatTextures: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( \\\\'OES_texture_float\\\\' ).' );\\n\\t\\t\\treturn this.extensions.get( 'OES_texture_float' );\\n\\n\\t\\t},\\n\\t\\tsupportsHalfFloatTextures: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( \\\\'OES_texture_half_float\\\\' ).' );\\n\\t\\t\\treturn this.extensions.get( 'OES_texture_half_float' );\\n\\n\\t\\t},\\n\\t\\tsupportsStandardDerivatives: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( \\\\'OES_standard_derivatives\\\\' ).' );\\n\\t\\t\\treturn this.extensions.get( 'OES_standard_derivatives' );\\n\\n\\t\\t},\\n\\t\\tsupportsCompressedTextureS3TC: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( \\\\'WEBGL_compressed_texture_s3tc\\\\' ).' );\\n\\t\\t\\treturn this.extensions.get( 'WEBGL_compressed_texture_s3tc' );\\n\\n\\t\\t},\\n\\t\\tsupportsCompressedTexturePVRTC: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( \\\\'WEBGL_compressed_texture_pvrtc\\\\' ).' );\\n\\t\\t\\treturn this.extensions.get( 'WEBGL_compressed_texture_pvrtc' );\\n\\n\\t\\t},\\n\\t\\tsupportsBlendMinMax: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( \\\\'EXT_blend_minmax\\\\' ).' );\\n\\t\\t\\treturn this.extensions.get( 'EXT_blend_minmax' );\\n\\n\\t\\t},\\n\\t\\tsupportsVertexTextures: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures.' );\\n\\t\\t\\treturn this.capabilities.vertexTextures;\\n\\n\\t\\t},\\n\\t\\tsupportsInstancedArrays: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( \\\\'ANGLE_instanced_arrays\\\\' ).' );\\n\\t\\t\\treturn this.extensions.get( 'ANGLE_instanced_arrays' );\\n\\n\\t\\t},\\n\\t\\tenableScissorTest: function ( boolean ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest().' );\\n\\t\\t\\tthis.setScissorTest( boolean );\\n\\n\\t\\t},\\n\\t\\tinitMaterial: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .initMaterial() has been removed.' );\\n\\n\\t\\t},\\n\\t\\taddPrePlugin: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .addPrePlugin() has been removed.' );\\n\\n\\t\\t},\\n\\t\\taddPostPlugin: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .addPostPlugin() has been removed.' );\\n\\n\\t\\t},\\n\\t\\tupdateShadowMap: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .updateShadowMap() has been removed.' );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperties( WebGLRenderer.prototype, {\\n\\n\\t\\tshadowMapEnabled: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.shadowMap.enabled;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled.' );\\n\\t\\t\\t\\tthis.shadowMap.enabled = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowMapType: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.shadowMap.type;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type.' );\\n\\t\\t\\t\\tthis.shadowMap.type = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowMapCullFace: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.shadowMap.cullFace;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .shadowMapCullFace is now .shadowMap.cullFace.' );\\n\\t\\t\\t\\tthis.shadowMap.cullFace = value;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\t} );\\n\\n\\tObject.defineProperties( WebGLShadowMap.prototype, {\\n\\n\\t\\tcullFace: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.renderReverseSided ? CullFaceFront : CullFaceBack;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( cullFace ) {\\n\\n\\t\\t\\t\\tvar value = ( cullFace !== CullFaceBack );\\n\\t\\t\\t\\tconsole.warn( \\\"WebGLRenderer: .shadowMap.cullFace is deprecated. Set .shadowMap.renderReverseSided to \\\" + value + \\\".\\\" );\\n\\t\\t\\t\\tthis.renderReverseSided = value;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tObject.defineProperties( WebGLRenderTarget.prototype, {\\n\\n\\t\\twrapS: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.' );\\n\\t\\t\\t\\treturn this.texture.wrapS;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.' );\\n\\t\\t\\t\\tthis.texture.wrapS = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\twrapT: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.' );\\n\\t\\t\\t\\treturn this.texture.wrapT;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.' );\\n\\t\\t\\t\\tthis.texture.wrapT = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tmagFilter: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.' );\\n\\t\\t\\t\\treturn this.texture.magFilter;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.' );\\n\\t\\t\\t\\tthis.texture.magFilter = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tminFilter: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.' );\\n\\t\\t\\t\\treturn this.texture.minFilter;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.' );\\n\\t\\t\\t\\tthis.texture.minFilter = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tanisotropy: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.' );\\n\\t\\t\\t\\treturn this.texture.anisotropy;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.' );\\n\\t\\t\\t\\tthis.texture.anisotropy = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\toffset: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .offset is now .texture.offset.' );\\n\\t\\t\\t\\treturn this.texture.offset;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .offset is now .texture.offset.' );\\n\\t\\t\\t\\tthis.texture.offset = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\trepeat: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .repeat is now .texture.repeat.' );\\n\\t\\t\\t\\treturn this.texture.repeat;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .repeat is now .texture.repeat.' );\\n\\t\\t\\t\\tthis.texture.repeat = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tformat: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .format is now .texture.format.' );\\n\\t\\t\\t\\treturn this.texture.format;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .format is now .texture.format.' );\\n\\t\\t\\t\\tthis.texture.format = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\ttype: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .type is now .texture.type.' );\\n\\t\\t\\t\\treturn this.texture.type;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .type is now .texture.type.' );\\n\\t\\t\\t\\tthis.texture.type = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tgenerateMipmaps: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.' );\\n\\t\\t\\t\\treturn this.texture.generateMipmaps;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.' );\\n\\t\\t\\t\\tthis.texture.generateMipmaps = value;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tObject.assign( WebVRManager.prototype, {\\n\\n\\t\\tgetStandingMatrix: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebVRManager: .getStandingMatrix() has been removed.' );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperties( WebVRManager.prototype, {\\n\\n\\t\\tstanding: {\\n\\t\\t\\tset: function ( /* value */ ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebVRManager: .standing has been removed.' );\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tAudio.prototype.load = function ( file ) {\\n\\n\\t\\tconsole.warn( 'THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.' );\\n\\t\\tvar scope = this;\\n\\t\\tvar audioLoader = new AudioLoader();\\n\\t\\taudioLoader.load( file, function ( buffer ) {\\n\\n\\t\\t\\tscope.setBuffer( buffer );\\n\\n\\t\\t} );\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tAudioAnalyser.prototype.getData = function () {\\n\\n\\t\\tconsole.warn( 'THREE.AudioAnalyser: .getData() is now .getFrequencyData().' );\\n\\t\\treturn this.getFrequencyData();\\n\\n\\t};\\n\\n\\t//\\n\\n\\tCubeCamera.prototype.updateCubeMap = function ( renderer, scene ) {\\n\\n\\t\\tconsole.warn( 'THREE.CubeCamera: .updateCubeMap() is now .update().' );\\n\\t\\treturn this.update( renderer, scene );\\n\\n\\t};\\n\\n\\t//\\n\\n\\tvar GeometryUtils = {\\n\\n\\t\\tmerge: function ( geometry1, geometry2, materialIndexOffset ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.GeometryUtils: .merge() has been moved to Geometry. Use geometry.merge( geometry2, matrix, materialIndexOffset ) instead.' );\\n\\t\\t\\tvar matrix;\\n\\n\\t\\t\\tif ( geometry2.isMesh ) {\\n\\n\\t\\t\\t\\tgeometry2.matrixAutoUpdate && geometry2.updateMatrix();\\n\\n\\t\\t\\t\\tmatrix = geometry2.matrix;\\n\\t\\t\\t\\tgeometry2 = geometry2.geometry;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tgeometry1.merge( geometry2, matrix, materialIndexOffset );\\n\\n\\t\\t},\\n\\n\\t\\tcenter: function ( geometry ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.GeometryUtils: .center() has been moved to Geometry. Use geometry.center() instead.' );\\n\\t\\t\\treturn geometry.center();\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\tvar ImageUtils = {\\n\\n\\t\\tcrossOrigin: undefined,\\n\\n\\t\\tloadTexture: function ( url, mapping, onLoad, onError ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.' );\\n\\n\\t\\t\\tvar loader = new TextureLoader();\\n\\t\\t\\tloader.setCrossOrigin( this.crossOrigin );\\n\\n\\t\\t\\tvar texture = loader.load( url, onLoad, undefined, onError );\\n\\n\\t\\t\\tif ( mapping ) texture.mapping = mapping;\\n\\n\\t\\t\\treturn texture;\\n\\n\\t\\t},\\n\\n\\t\\tloadTextureCube: function ( urls, mapping, onLoad, onError ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.' );\\n\\n\\t\\t\\tvar loader = new CubeTextureLoader();\\n\\t\\t\\tloader.setCrossOrigin( this.crossOrigin );\\n\\n\\t\\t\\tvar texture = loader.load( urls, onLoad, undefined, onError );\\n\\n\\t\\t\\tif ( mapping ) texture.mapping = mapping;\\n\\n\\t\\t\\treturn texture;\\n\\n\\t\\t},\\n\\n\\t\\tloadCompressedTexture: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.' );\\n\\n\\t\\t},\\n\\n\\t\\tloadCompressedTextureCube: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.' );\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t//\\n\\n\\tfunction Projector() {\\n\\n\\t\\tconsole.error( 'THREE.Projector has been moved to /examples/js/renderers/Projector.js.' );\\n\\n\\t\\tthis.projectVector = function ( vector, camera ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Projector: .projectVector() is now vector.project().' );\\n\\t\\t\\tvector.project( camera );\\n\\n\\t\\t};\\n\\n\\t\\tthis.unprojectVector = function ( vector, camera ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Projector: .unprojectVector() is now vector.unproject().' );\\n\\t\\t\\tvector.unproject( camera );\\n\\n\\t\\t};\\n\\n\\t\\tthis.pickingRay = function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.Projector: .pickingRay() is now raycaster.setFromCamera().' );\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t//\\n\\n\\tfunction CanvasRenderer() {\\n\\n\\t\\tconsole.error( 'THREE.CanvasRenderer has been moved to /examples/js/renderers/CanvasRenderer.js' );\\n\\n\\t\\tthis.domElement = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' );\\n\\t\\tthis.clear = function () {};\\n\\t\\tthis.render = function () {};\\n\\t\\tthis.setClearColor = function () {};\\n\\t\\tthis.setSize = function () {};\\n\\n\\t}\\n\\n\\texports.WebGLRenderTargetCube = WebGLRenderTargetCube;\\n\\texports.WebGLRenderTarget = WebGLRenderTarget;\\n\\texports.WebGLRenderer = WebGLRenderer;\\n\\texports.ShaderLib = ShaderLib;\\n\\texports.UniformsLib = UniformsLib;\\n\\texports.UniformsUtils = UniformsUtils;\\n\\texports.ShaderChunk = ShaderChunk;\\n\\texports.FogExp2 = FogExp2;\\n\\texports.Fog = Fog;\\n\\texports.Scene = Scene;\\n\\texports.LensFlare = LensFlare;\\n\\texports.Sprite = Sprite;\\n\\texports.LOD = LOD;\\n\\texports.SkinnedMesh = SkinnedMesh;\\n\\texports.Skeleton = Skeleton;\\n\\texports.Bone = Bone;\\n\\texports.Mesh = Mesh;\\n\\texports.LineSegments = LineSegments;\\n\\texports.LineLoop = LineLoop;\\n\\texports.Line = Line;\\n\\texports.Points = Points;\\n\\texports.Group = Group;\\n\\texports.VideoTexture = VideoTexture;\\n\\texports.DataTexture = DataTexture;\\n\\texports.CompressedTexture = CompressedTexture;\\n\\texports.CubeTexture = CubeTexture;\\n\\texports.CanvasTexture = CanvasTexture;\\n\\texports.DepthTexture = DepthTexture;\\n\\texports.Texture = Texture;\\n\\texports.CompressedTextureLoader = CompressedTextureLoader;\\n\\texports.DataTextureLoader = DataTextureLoader;\\n\\texports.CubeTextureLoader = CubeTextureLoader;\\n\\texports.TextureLoader = TextureLoader;\\n\\texports.ObjectLoader = ObjectLoader;\\n\\texports.MaterialLoader = MaterialLoader;\\n\\texports.BufferGeometryLoader = BufferGeometryLoader;\\n\\texports.DefaultLoadingManager = DefaultLoadingManager;\\n\\texports.LoadingManager = LoadingManager;\\n\\texports.JSONLoader = JSONLoader;\\n\\texports.ImageLoader = ImageLoader;\\n\\texports.ImageBitmapLoader = ImageBitmapLoader;\\n\\texports.FontLoader = FontLoader;\\n\\texports.FileLoader = FileLoader;\\n\\texports.Loader = Loader;\\n\\texports.LoaderUtils = LoaderUtils;\\n\\texports.Cache = Cache;\\n\\texports.AudioLoader = AudioLoader;\\n\\texports.SpotLightShadow = SpotLightShadow;\\n\\texports.SpotLight = SpotLight;\\n\\texports.PointLight = PointLight;\\n\\texports.RectAreaLight = RectAreaLight;\\n\\texports.HemisphereLight = HemisphereLight;\\n\\texports.DirectionalLightShadow = DirectionalLightShadow;\\n\\texports.DirectionalLight = DirectionalLight;\\n\\texports.AmbientLight = AmbientLight;\\n\\texports.LightShadow = LightShadow;\\n\\texports.Light = Light;\\n\\texports.StereoCamera = StereoCamera;\\n\\texports.PerspectiveCamera = PerspectiveCamera;\\n\\texports.OrthographicCamera = OrthographicCamera;\\n\\texports.CubeCamera = CubeCamera;\\n\\texports.ArrayCamera = ArrayCamera;\\n\\texports.Camera = Camera;\\n\\texports.AudioListener = AudioListener;\\n\\texports.PositionalAudio = PositionalAudio;\\n\\texports.AudioContext = AudioContext;\\n\\texports.AudioAnalyser = AudioAnalyser;\\n\\texports.Audio = Audio;\\n\\texports.VectorKeyframeTrack = VectorKeyframeTrack;\\n\\texports.StringKeyframeTrack = StringKeyframeTrack;\\n\\texports.QuaternionKeyframeTrack = QuaternionKeyframeTrack;\\n\\texports.NumberKeyframeTrack = NumberKeyframeTrack;\\n\\texports.ColorKeyframeTrack = ColorKeyframeTrack;\\n\\texports.BooleanKeyframeTrack = BooleanKeyframeTrack;\\n\\texports.PropertyMixer = PropertyMixer;\\n\\texports.PropertyBinding = PropertyBinding;\\n\\texports.KeyframeTrack = KeyframeTrack;\\n\\texports.AnimationUtils = AnimationUtils;\\n\\texports.AnimationObjectGroup = AnimationObjectGroup;\\n\\texports.AnimationMixer = AnimationMixer;\\n\\texports.AnimationClip = AnimationClip;\\n\\texports.Uniform = Uniform;\\n\\texports.InstancedBufferGeometry = InstancedBufferGeometry;\\n\\texports.BufferGeometry = BufferGeometry;\\n\\texports.Geometry = Geometry;\\n\\texports.InterleavedBufferAttribute = InterleavedBufferAttribute;\\n\\texports.InstancedInterleavedBuffer = InstancedInterleavedBuffer;\\n\\texports.InterleavedBuffer = InterleavedBuffer;\\n\\texports.InstancedBufferAttribute = InstancedBufferAttribute;\\n\\texports.Face3 = Face3;\\n\\texports.Object3D = Object3D;\\n\\texports.Raycaster = Raycaster;\\n\\texports.Layers = Layers;\\n\\texports.EventDispatcher = EventDispatcher;\\n\\texports.Clock = Clock;\\n\\texports.QuaternionLinearInterpolant = QuaternionLinearInterpolant;\\n\\texports.LinearInterpolant = LinearInterpolant;\\n\\texports.DiscreteInterpolant = DiscreteInterpolant;\\n\\texports.CubicInterpolant = CubicInterpolant;\\n\\texports.Interpolant = Interpolant;\\n\\texports.Triangle = Triangle;\\n\\texports.Math = _Math;\\n\\texports.Spherical = Spherical;\\n\\texports.Cylindrical = Cylindrical;\\n\\texports.Plane = Plane;\\n\\texports.Frustum = Frustum;\\n\\texports.Sphere = Sphere;\\n\\texports.Ray = Ray;\\n\\texports.Matrix4 = Matrix4;\\n\\texports.Matrix3 = Matrix3;\\n\\texports.Box3 = Box3;\\n\\texports.Box2 = Box2;\\n\\texports.Line3 = Line3;\\n\\texports.Euler = Euler;\\n\\texports.Vector4 = Vector4;\\n\\texports.Vector3 = Vector3;\\n\\texports.Vector2 = Vector2;\\n\\texports.Quaternion = Quaternion;\\n\\texports.Color = Color;\\n\\texports.ImmediateRenderObject = ImmediateRenderObject;\\n\\texports.VertexNormalsHelper = VertexNormalsHelper;\\n\\texports.SpotLightHelper = SpotLightHelper;\\n\\texports.SkeletonHelper = SkeletonHelper;\\n\\texports.PointLightHelper = PointLightHelper;\\n\\texports.RectAreaLightHelper = RectAreaLightHelper;\\n\\texports.HemisphereLightHelper = HemisphereLightHelper;\\n\\texports.GridHelper = GridHelper;\\n\\texports.PolarGridHelper = PolarGridHelper;\\n\\texports.FaceNormalsHelper = FaceNormalsHelper;\\n\\texports.DirectionalLightHelper = DirectionalLightHelper;\\n\\texports.CameraHelper = CameraHelper;\\n\\texports.BoxHelper = BoxHelper;\\n\\texports.Box3Helper = Box3Helper;\\n\\texports.PlaneHelper = PlaneHelper;\\n\\texports.ArrowHelper = ArrowHelper;\\n\\texports.AxesHelper = AxesHelper;\\n\\texports.Shape = Shape;\\n\\texports.Path = Path;\\n\\texports.ShapePath = ShapePath;\\n\\texports.Font = Font;\\n\\texports.CurvePath = CurvePath;\\n\\texports.Curve = Curve;\\n\\texports.ShapeUtils = ShapeUtils;\\n\\texports.SceneUtils = SceneUtils;\\n\\texports.WebGLUtils = WebGLUtils;\\n\\texports.WireframeGeometry = WireframeGeometry;\\n\\texports.ParametricGeometry = ParametricGeometry;\\n\\texports.ParametricBufferGeometry = ParametricBufferGeometry;\\n\\texports.TetrahedronGeometry = TetrahedronGeometry;\\n\\texports.TetrahedronBufferGeometry = TetrahedronBufferGeometry;\\n\\texports.OctahedronGeometry = OctahedronGeometry;\\n\\texports.OctahedronBufferGeometry = OctahedronBufferGeometry;\\n\\texports.IcosahedronGeometry = IcosahedronGeometry;\\n\\texports.IcosahedronBufferGeometry = IcosahedronBufferGeometry;\\n\\texports.DodecahedronGeometry = DodecahedronGeometry;\\n\\texports.DodecahedronBufferGeometry = DodecahedronBufferGeometry;\\n\\texports.PolyhedronGeometry = PolyhedronGeometry;\\n\\texports.PolyhedronBufferGeometry = PolyhedronBufferGeometry;\\n\\texports.TubeGeometry = TubeGeometry;\\n\\texports.TubeBufferGeometry = TubeBufferGeometry;\\n\\texports.TorusKnotGeometry = TorusKnotGeometry;\\n\\texports.TorusKnotBufferGeometry = TorusKnotBufferGeometry;\\n\\texports.TorusGeometry = TorusGeometry;\\n\\texports.TorusBufferGeometry = TorusBufferGeometry;\\n\\texports.TextGeometry = TextGeometry;\\n\\texports.TextBufferGeometry = TextBufferGeometry;\\n\\texports.SphereGeometry = SphereGeometry;\\n\\texports.SphereBufferGeometry = SphereBufferGeometry;\\n\\texports.RingGeometry = RingGeometry;\\n\\texports.RingBufferGeometry = RingBufferGeometry;\\n\\texports.PlaneGeometry = PlaneGeometry;\\n\\texports.PlaneBufferGeometry = PlaneBufferGeometry;\\n\\texports.LatheGeometry = LatheGeometry;\\n\\texports.LatheBufferGeometry = LatheBufferGeometry;\\n\\texports.ShapeGeometry = ShapeGeometry;\\n\\texports.ShapeBufferGeometry = ShapeBufferGeometry;\\n\\texports.ExtrudeGeometry = ExtrudeGeometry;\\n\\texports.ExtrudeBufferGeometry = ExtrudeBufferGeometry;\\n\\texports.EdgesGeometry = EdgesGeometry;\\n\\texports.ConeGeometry = ConeGeometry;\\n\\texports.ConeBufferGeometry = ConeBufferGeometry;\\n\\texports.CylinderGeometry = CylinderGeometry;\\n\\texports.CylinderBufferGeometry = CylinderBufferGeometry;\\n\\texports.CircleGeometry = CircleGeometry;\\n\\texports.CircleBufferGeometry = CircleBufferGeometry;\\n\\texports.BoxGeometry = BoxGeometry;\\n\\texports.BoxBufferGeometry = BoxBufferGeometry;\\n\\texports.ShadowMaterial = ShadowMaterial;\\n\\texports.SpriteMaterial = SpriteMaterial;\\n\\texports.RawShaderMaterial = RawShaderMaterial;\\n\\texports.ShaderMaterial = ShaderMaterial;\\n\\texports.PointsMaterial = PointsMaterial;\\n\\texports.MeshPhysicalMaterial = MeshPhysicalMaterial;\\n\\texports.MeshStandardMaterial = MeshStandardMaterial;\\n\\texports.MeshPhongMaterial = MeshPhongMaterial;\\n\\texports.MeshToonMaterial = MeshToonMaterial;\\n\\texports.MeshNormalMaterial = MeshNormalMaterial;\\n\\texports.MeshLambertMaterial = MeshLambertMaterial;\\n\\texports.MeshDepthMaterial = MeshDepthMaterial;\\n\\texports.MeshDistanceMaterial = MeshDistanceMaterial;\\n\\texports.MeshBasicMaterial = MeshBasicMaterial;\\n\\texports.LineDashedMaterial = LineDashedMaterial;\\n\\texports.LineBasicMaterial = LineBasicMaterial;\\n\\texports.Material = Material;\\n\\texports.Float64BufferAttribute = Float64BufferAttribute;\\n\\texports.Float32BufferAttribute = Float32BufferAttribute;\\n\\texports.Uint32BufferAttribute = Uint32BufferAttribute;\\n\\texports.Int32BufferAttribute = Int32BufferAttribute;\\n\\texports.Uint16BufferAttribute = Uint16BufferAttribute;\\n\\texports.Int16BufferAttribute = Int16BufferAttribute;\\n\\texports.Uint8ClampedBufferAttribute = Uint8ClampedBufferAttribute;\\n\\texports.Uint8BufferAttribute = Uint8BufferAttribute;\\n\\texports.Int8BufferAttribute = Int8BufferAttribute;\\n\\texports.BufferAttribute = BufferAttribute;\\n\\texports.ArcCurve = ArcCurve;\\n\\texports.CatmullRomCurve3 = CatmullRomCurve3;\\n\\texports.CubicBezierCurve = CubicBezierCurve;\\n\\texports.CubicBezierCurve3 = CubicBezierCurve3;\\n\\texports.EllipseCurve = EllipseCurve;\\n\\texports.LineCurve = LineCurve;\\n\\texports.LineCurve3 = LineCurve3;\\n\\texports.QuadraticBezierCurve = QuadraticBezierCurve;\\n\\texports.QuadraticBezierCurve3 = QuadraticBezierCurve3;\\n\\texports.SplineCurve = SplineCurve;\\n\\texports.REVISION = REVISION;\\n\\texports.MOUSE = MOUSE;\\n\\texports.CullFaceNone = CullFaceNone;\\n\\texports.CullFaceBack = CullFaceBack;\\n\\texports.CullFaceFront = CullFaceFront;\\n\\texports.CullFaceFrontBack = CullFaceFrontBack;\\n\\texports.FrontFaceDirectionCW = FrontFaceDirectionCW;\\n\\texports.FrontFaceDirectionCCW = FrontFaceDirectionCCW;\\n\\texports.BasicShadowMap = BasicShadowMap;\\n\\texports.PCFShadowMap = PCFShadowMap;\\n\\texports.PCFSoftShadowMap = PCFSoftShadowMap;\\n\\texports.FrontSide = FrontSide;\\n\\texports.BackSide = BackSide;\\n\\texports.DoubleSide = DoubleSide;\\n\\texports.FlatShading = FlatShading;\\n\\texports.SmoothShading = SmoothShading;\\n\\texports.NoColors = NoColors;\\n\\texports.FaceColors = FaceColors;\\n\\texports.VertexColors = VertexColors;\\n\\texports.NoBlending = NoBlending;\\n\\texports.NormalBlending = NormalBlending;\\n\\texports.AdditiveBlending = AdditiveBlending;\\n\\texports.SubtractiveBlending = SubtractiveBlending;\\n\\texports.MultiplyBlending = MultiplyBlending;\\n\\texports.CustomBlending = CustomBlending;\\n\\texports.AddEquation = AddEquation;\\n\\texports.SubtractEquation = SubtractEquation;\\n\\texports.ReverseSubtractEquation = ReverseSubtractEquation;\\n\\texports.MinEquation = MinEquation;\\n\\texports.MaxEquation = MaxEquation;\\n\\texports.ZeroFactor = ZeroFactor;\\n\\texports.OneFactor = OneFactor;\\n\\texports.SrcColorFactor = SrcColorFactor;\\n\\texports.OneMinusSrcColorFactor = OneMinusSrcColorFactor;\\n\\texports.SrcAlphaFactor = SrcAlphaFactor;\\n\\texports.OneMinusSrcAlphaFactor = OneMinusSrcAlphaFactor;\\n\\texports.DstAlphaFactor = DstAlphaFactor;\\n\\texports.OneMinusDstAlphaFactor = OneMinusDstAlphaFactor;\\n\\texports.DstColorFactor = DstColorFactor;\\n\\texports.OneMinusDstColorFactor = OneMinusDstColorFactor;\\n\\texports.SrcAlphaSaturateFactor = SrcAlphaSaturateFactor;\\n\\texports.NeverDepth = NeverDepth;\\n\\texports.AlwaysDepth = AlwaysDepth;\\n\\texports.LessDepth = LessDepth;\\n\\texports.LessEqualDepth = LessEqualDepth;\\n\\texports.EqualDepth = EqualDepth;\\n\\texports.GreaterEqualDepth = GreaterEqualDepth;\\n\\texports.GreaterDepth = GreaterDepth;\\n\\texports.NotEqualDepth = NotEqualDepth;\\n\\texports.MultiplyOperation = MultiplyOperation;\\n\\texports.MixOperation = MixOperation;\\n\\texports.AddOperation = AddOperation;\\n\\texports.NoToneMapping = NoToneMapping;\\n\\texports.LinearToneMapping = LinearToneMapping;\\n\\texports.ReinhardToneMapping = ReinhardToneMapping;\\n\\texports.Uncharted2ToneMapping = Uncharted2ToneMapping;\\n\\texports.CineonToneMapping = CineonToneMapping;\\n\\texports.UVMapping = UVMapping;\\n\\texports.CubeReflectionMapping = CubeReflectionMapping;\\n\\texports.CubeRefractionMapping = CubeRefractionMapping;\\n\\texports.EquirectangularReflectionMapping = EquirectangularReflectionMapping;\\n\\texports.EquirectangularRefractionMapping = EquirectangularRefractionMapping;\\n\\texports.SphericalReflectionMapping = SphericalReflectionMapping;\\n\\texports.CubeUVReflectionMapping = CubeUVReflectionMapping;\\n\\texports.CubeUVRefractionMapping = CubeUVRefractionMapping;\\n\\texports.RepeatWrapping = RepeatWrapping;\\n\\texports.ClampToEdgeWrapping = ClampToEdgeWrapping;\\n\\texports.MirroredRepeatWrapping = MirroredRepeatWrapping;\\n\\texports.NearestFilter = NearestFilter;\\n\\texports.NearestMipMapNearestFilter = NearestMipMapNearestFilter;\\n\\texports.NearestMipMapLinearFilter = NearestMipMapLinearFilter;\\n\\texports.LinearFilter = LinearFilter;\\n\\texports.LinearMipMapNearestFilter = LinearMipMapNearestFilter;\\n\\texports.LinearMipMapLinearFilter = LinearMipMapLinearFilter;\\n\\texports.UnsignedByteType = UnsignedByteType;\\n\\texports.ByteType = ByteType;\\n\\texports.ShortType = ShortType;\\n\\texports.UnsignedShortType = UnsignedShortType;\\n\\texports.IntType = IntType;\\n\\texports.UnsignedIntType = UnsignedIntType;\\n\\texports.FloatType = FloatType;\\n\\texports.HalfFloatType = HalfFloatType;\\n\\texports.UnsignedShort4444Type = UnsignedShort4444Type;\\n\\texports.UnsignedShort5551Type = UnsignedShort5551Type;\\n\\texports.UnsignedShort565Type = UnsignedShort565Type;\\n\\texports.UnsignedInt248Type = UnsignedInt248Type;\\n\\texports.AlphaFormat = AlphaFormat;\\n\\texports.RGBFormat = RGBFormat;\\n\\texports.RGBAFormat = RGBAFormat;\\n\\texports.LuminanceFormat = LuminanceFormat;\\n\\texports.LuminanceAlphaFormat = LuminanceAlphaFormat;\\n\\texports.RGBEFormat = RGBEFormat;\\n\\texports.DepthFormat = DepthFormat;\\n\\texports.DepthStencilFormat = DepthStencilFormat;\\n\\texports.RGB_S3TC_DXT1_Format = RGB_S3TC_DXT1_Format;\\n\\texports.RGBA_S3TC_DXT1_Format = RGBA_S3TC_DXT1_Format;\\n\\texports.RGBA_S3TC_DXT3_Format = RGBA_S3TC_DXT3_Format;\\n\\texports.RGBA_S3TC_DXT5_Format = RGBA_S3TC_DXT5_Format;\\n\\texports.RGB_PVRTC_4BPPV1_Format = RGB_PVRTC_4BPPV1_Format;\\n\\texports.RGB_PVRTC_2BPPV1_Format = RGB_PVRTC_2BPPV1_Format;\\n\\texports.RGBA_PVRTC_4BPPV1_Format = RGBA_PVRTC_4BPPV1_Format;\\n\\texports.RGBA_PVRTC_2BPPV1_Format = RGBA_PVRTC_2BPPV1_Format;\\n\\texports.RGB_ETC1_Format = RGB_ETC1_Format;\\n\\texports.LoopOnce = LoopOnce;\\n\\texports.LoopRepeat = LoopRepeat;\\n\\texports.LoopPingPong = LoopPingPong;\\n\\texports.InterpolateDiscrete = InterpolateDiscrete;\\n\\texports.InterpolateLinear = InterpolateLinear;\\n\\texports.InterpolateSmooth = InterpolateSmooth;\\n\\texports.ZeroCurvatureEnding = ZeroCurvatureEnding;\\n\\texports.ZeroSlopeEnding = ZeroSlopeEnding;\\n\\texports.WrapAroundEnding = WrapAroundEnding;\\n\\texports.TrianglesDrawMode = TrianglesDrawMode;\\n\\texports.TriangleStripDrawMode = TriangleStripDrawMode;\\n\\texports.TriangleFanDrawMode = TriangleFanDrawMode;\\n\\texports.LinearEncoding = LinearEncoding;\\n\\texports.sRGBEncoding = sRGBEncoding;\\n\\texports.GammaEncoding = GammaEncoding;\\n\\texports.RGBEEncoding = RGBEEncoding;\\n\\texports.LogLuvEncoding = LogLuvEncoding;\\n\\texports.RGBM7Encoding = RGBM7Encoding;\\n\\texports.RGBM16Encoding = RGBM16Encoding;\\n\\texports.RGBDEncoding = RGBDEncoding;\\n\\texports.BasicDepthPacking = BasicDepthPacking;\\n\\texports.RGBADepthPacking = RGBADepthPacking;\\n\\texports.CubeGeometry = BoxGeometry;\\n\\texports.Face4 = Face4;\\n\\texports.LineStrip = LineStrip;\\n\\texports.LinePieces = LinePieces;\\n\\texports.MeshFaceMaterial = MeshFaceMaterial;\\n\\texports.MultiMaterial = MultiMaterial;\\n\\texports.PointCloud = PointCloud;\\n\\texports.Particle = Particle;\\n\\texports.ParticleSystem = ParticleSystem;\\n\\texports.PointCloudMaterial = PointCloudMaterial;\\n\\texports.ParticleBasicMaterial = ParticleBasicMaterial;\\n\\texports.ParticleSystemMaterial = ParticleSystemMaterial;\\n\\texports.Vertex = Vertex;\\n\\texports.DynamicBufferAttribute = DynamicBufferAttribute;\\n\\texports.Int8Attribute = Int8Attribute;\\n\\texports.Uint8Attribute = Uint8Attribute;\\n\\texports.Uint8ClampedAttribute = Uint8ClampedAttribute;\\n\\texports.Int16Attribute = Int16Attribute;\\n\\texports.Uint16Attribute = Uint16Attribute;\\n\\texports.Int32Attribute = Int32Attribute;\\n\\texports.Uint32Attribute = Uint32Attribute;\\n\\texports.Float32Attribute = Float32Attribute;\\n\\texports.Float64Attribute = Float64Attribute;\\n\\texports.ClosedSplineCurve3 = ClosedSplineCurve3;\\n\\texports.SplineCurve3 = SplineCurve3;\\n\\texports.Spline = Spline;\\n\\texports.AxisHelper = AxisHelper;\\n\\texports.BoundingBoxHelper = BoundingBoxHelper;\\n\\texports.EdgesHelper = EdgesHelper;\\n\\texports.WireframeHelper = WireframeHelper;\\n\\texports.XHRLoader = XHRLoader;\\n\\texports.BinaryTextureLoader = BinaryTextureLoader;\\n\\texports.GeometryUtils = GeometryUtils;\\n\\texports.ImageUtils = ImageUtils;\\n\\texports.Projector = Projector;\\n\\texports.CanvasRenderer = CanvasRenderer;\\n\\n\\tObject.defineProperty(exports, '__esModule', { value: true });\\n\\n})));\\n\"//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"621.js","mappings":"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","sources":["webpack://dash/./vendor/three.js?e4ba"],"sourcesContent":["module.exports = \"(function (global, factory) {\\n\\ttypeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\\n\\ttypeof define === 'function' && define.amd ? define(['exports'], factory) :\\n\\t(factory((global.THREE = {})));\\n}(this, (function (exports) { 'use strict';\\n\\n\\t// Polyfills\\n\\n\\tif ( Number.EPSILON === undefined ) {\\n\\n\\t\\tNumber.EPSILON = Math.pow( 2, - 52 );\\n\\n\\t}\\n\\n\\tif ( Number.isInteger === undefined ) {\\n\\n\\t\\t// Missing in IE\\n\\t\\t// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger\\n\\n\\t\\tNumber.isInteger = function ( value ) {\\n\\n\\t\\t\\treturn typeof value === 'number' && isFinite( value ) && Math.floor( value ) === value;\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t//\\n\\n\\tif ( Math.sign === undefined ) {\\n\\n\\t\\t// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign\\n\\n\\t\\tMath.sign = function ( x ) {\\n\\n\\t\\t\\treturn ( x < 0 ) ? - 1 : ( x > 0 ) ? 1 : + x;\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\tif ( 'name' in Function.prototype === false ) {\\n\\n\\t\\t// Missing in IE\\n\\t\\t// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name\\n\\n\\t\\tObject.defineProperty( Function.prototype, 'name', {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.toString().match( /^\\\\s*function\\\\s*([^\\\\(\\\\s]*)/ )[ 1 ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t} );\\n\\n\\t}\\n\\n\\tif ( Object.assign === undefined ) {\\n\\n\\t\\t// Missing in IE\\n\\t\\t// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign\\n\\n\\t\\t( function () {\\n\\n\\t\\t\\tObject.assign = function ( target ) {\\n\\n\\t\\t\\t\\tif ( target === undefined || target === null ) {\\n\\n\\t\\t\\t\\t\\tthrow new TypeError( 'Cannot convert undefined or null to object' );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar output = Object( target );\\n\\n\\t\\t\\t\\tfor ( var index = 1; index < arguments.length; index ++ ) {\\n\\n\\t\\t\\t\\t\\tvar source = arguments[ index ];\\n\\n\\t\\t\\t\\t\\tif ( source !== undefined && source !== null ) {\\n\\n\\t\\t\\t\\t\\t\\tfor ( var nextKey in source ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( Object.prototype.hasOwnProperty.call( source, nextKey ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\toutput[ nextKey ] = source[ nextKey ];\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn output;\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )();\\n\\n\\t}\\n\\n\\t/**\\n\\t * https://github.com/mrdoob/eventdispatcher.js/\\n\\t */\\n\\n\\tfunction EventDispatcher() {}\\n\\n\\tObject.assign( EventDispatcher.prototype, {\\n\\n\\t\\taddEventListener: function ( type, listener ) {\\n\\n\\t\\t\\tif ( this._listeners === undefined ) this._listeners = {};\\n\\n\\t\\t\\tvar listeners = this._listeners;\\n\\n\\t\\t\\tif ( listeners[ type ] === undefined ) {\\n\\n\\t\\t\\t\\tlisteners[ type ] = [];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( listeners[ type ].indexOf( listener ) === - 1 ) {\\n\\n\\t\\t\\t\\tlisteners[ type ].push( listener );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\thasEventListener: function ( type, listener ) {\\n\\n\\t\\t\\tif ( this._listeners === undefined ) return false;\\n\\n\\t\\t\\tvar listeners = this._listeners;\\n\\n\\t\\t\\treturn listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== - 1;\\n\\n\\t\\t},\\n\\n\\t\\tremoveEventListener: function ( type, listener ) {\\n\\n\\t\\t\\tif ( this._listeners === undefined ) return;\\n\\n\\t\\t\\tvar listeners = this._listeners;\\n\\t\\t\\tvar listenerArray = listeners[ type ];\\n\\n\\t\\t\\tif ( listenerArray !== undefined ) {\\n\\n\\t\\t\\t\\tvar index = listenerArray.indexOf( listener );\\n\\n\\t\\t\\t\\tif ( index !== - 1 ) {\\n\\n\\t\\t\\t\\t\\tlistenerArray.splice( index, 1 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tdispatchEvent: function ( event ) {\\n\\n\\t\\t\\tif ( this._listeners === undefined ) return;\\n\\n\\t\\t\\tvar listeners = this._listeners;\\n\\t\\t\\tvar listenerArray = listeners[ event.type ];\\n\\n\\t\\t\\tif ( listenerArray !== undefined ) {\\n\\n\\t\\t\\t\\tevent.target = this;\\n\\n\\t\\t\\t\\tvar array = listenerArray.slice( 0 );\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = array.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tarray[ i ].call( this, event );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tvar REVISION = '89';\\n\\tvar MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2 };\\n\\tvar CullFaceNone = 0;\\n\\tvar CullFaceBack = 1;\\n\\tvar CullFaceFront = 2;\\n\\tvar CullFaceFrontBack = 3;\\n\\tvar FrontFaceDirectionCW = 0;\\n\\tvar FrontFaceDirectionCCW = 1;\\n\\tvar BasicShadowMap = 0;\\n\\tvar PCFShadowMap = 1;\\n\\tvar PCFSoftShadowMap = 2;\\n\\tvar FrontSide = 0;\\n\\tvar BackSide = 1;\\n\\tvar DoubleSide = 2;\\n\\tvar FlatShading = 1;\\n\\tvar SmoothShading = 2;\\n\\tvar NoColors = 0;\\n\\tvar FaceColors = 1;\\n\\tvar VertexColors = 2;\\n\\tvar NoBlending = 0;\\n\\tvar NormalBlending = 1;\\n\\tvar AdditiveBlending = 2;\\n\\tvar SubtractiveBlending = 3;\\n\\tvar MultiplyBlending = 4;\\n\\tvar CustomBlending = 5;\\n\\tvar AddEquation = 100;\\n\\tvar SubtractEquation = 101;\\n\\tvar ReverseSubtractEquation = 102;\\n\\tvar MinEquation = 103;\\n\\tvar MaxEquation = 104;\\n\\tvar ZeroFactor = 200;\\n\\tvar OneFactor = 201;\\n\\tvar SrcColorFactor = 202;\\n\\tvar OneMinusSrcColorFactor = 203;\\n\\tvar SrcAlphaFactor = 204;\\n\\tvar OneMinusSrcAlphaFactor = 205;\\n\\tvar DstAlphaFactor = 206;\\n\\tvar OneMinusDstAlphaFactor = 207;\\n\\tvar DstColorFactor = 208;\\n\\tvar OneMinusDstColorFactor = 209;\\n\\tvar SrcAlphaSaturateFactor = 210;\\n\\tvar NeverDepth = 0;\\n\\tvar AlwaysDepth = 1;\\n\\tvar LessDepth = 2;\\n\\tvar LessEqualDepth = 3;\\n\\tvar EqualDepth = 4;\\n\\tvar GreaterEqualDepth = 5;\\n\\tvar GreaterDepth = 6;\\n\\tvar NotEqualDepth = 7;\\n\\tvar MultiplyOperation = 0;\\n\\tvar MixOperation = 1;\\n\\tvar AddOperation = 2;\\n\\tvar NoToneMapping = 0;\\n\\tvar LinearToneMapping = 1;\\n\\tvar ReinhardToneMapping = 2;\\n\\tvar Uncharted2ToneMapping = 3;\\n\\tvar CineonToneMapping = 4;\\n\\tvar UVMapping = 300;\\n\\tvar CubeReflectionMapping = 301;\\n\\tvar CubeRefractionMapping = 302;\\n\\tvar EquirectangularReflectionMapping = 303;\\n\\tvar EquirectangularRefractionMapping = 304;\\n\\tvar SphericalReflectionMapping = 305;\\n\\tvar CubeUVReflectionMapping = 306;\\n\\tvar CubeUVRefractionMapping = 307;\\n\\tvar RepeatWrapping = 1000;\\n\\tvar ClampToEdgeWrapping = 1001;\\n\\tvar MirroredRepeatWrapping = 1002;\\n\\tvar NearestFilter = 1003;\\n\\tvar NearestMipMapNearestFilter = 1004;\\n\\tvar NearestMipMapLinearFilter = 1005;\\n\\tvar LinearFilter = 1006;\\n\\tvar LinearMipMapNearestFilter = 1007;\\n\\tvar LinearMipMapLinearFilter = 1008;\\n\\tvar UnsignedByteType = 1009;\\n\\tvar ByteType = 1010;\\n\\tvar ShortType = 1011;\\n\\tvar UnsignedShortType = 1012;\\n\\tvar IntType = 1013;\\n\\tvar UnsignedIntType = 1014;\\n\\tvar FloatType = 1015;\\n\\tvar HalfFloatType = 1016;\\n\\tvar UnsignedShort4444Type = 1017;\\n\\tvar UnsignedShort5551Type = 1018;\\n\\tvar UnsignedShort565Type = 1019;\\n\\tvar UnsignedInt248Type = 1020;\\n\\tvar AlphaFormat = 1021;\\n\\tvar RGBFormat = 1022;\\n\\tvar RGBAFormat = 1023;\\n\\tvar LuminanceFormat = 1024;\\n\\tvar LuminanceAlphaFormat = 1025;\\n\\tvar RGBEFormat = RGBAFormat;\\n\\tvar DepthFormat = 1026;\\n\\tvar DepthStencilFormat = 1027;\\n\\tvar RGB_S3TC_DXT1_Format = 2001;\\n\\tvar RGBA_S3TC_DXT1_Format = 2002;\\n\\tvar RGBA_S3TC_DXT3_Format = 2003;\\n\\tvar RGBA_S3TC_DXT5_Format = 2004;\\n\\tvar RGB_PVRTC_4BPPV1_Format = 2100;\\n\\tvar RGB_PVRTC_2BPPV1_Format = 2101;\\n\\tvar RGBA_PVRTC_4BPPV1_Format = 2102;\\n\\tvar RGBA_PVRTC_2BPPV1_Format = 2103;\\n\\tvar RGB_ETC1_Format = 2151;\\n\\tvar LoopOnce = 2200;\\n\\tvar LoopRepeat = 2201;\\n\\tvar LoopPingPong = 2202;\\n\\tvar InterpolateDiscrete = 2300;\\n\\tvar InterpolateLinear = 2301;\\n\\tvar InterpolateSmooth = 2302;\\n\\tvar ZeroCurvatureEnding = 2400;\\n\\tvar ZeroSlopeEnding = 2401;\\n\\tvar WrapAroundEnding = 2402;\\n\\tvar TrianglesDrawMode = 0;\\n\\tvar TriangleStripDrawMode = 1;\\n\\tvar TriangleFanDrawMode = 2;\\n\\tvar LinearEncoding = 3000;\\n\\tvar sRGBEncoding = 3001;\\n\\tvar GammaEncoding = 3007;\\n\\tvar RGBEEncoding = 3002;\\n\\tvar LogLuvEncoding = 3003;\\n\\tvar RGBM7Encoding = 3004;\\n\\tvar RGBM16Encoding = 3005;\\n\\tvar RGBDEncoding = 3006;\\n\\tvar BasicDepthPacking = 3200;\\n\\tvar RGBADepthPacking = 3201;\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tvar _Math = {\\n\\n\\t\\tDEG2RAD: Math.PI / 180,\\n\\t\\tRAD2DEG: 180 / Math.PI,\\n\\n\\t\\tgenerateUUID: ( function () {\\n\\n\\t\\t\\t// http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136\\n\\n\\t\\t\\tvar lut = [];\\n\\n\\t\\t\\tfor ( var i = 0; i < 256; i ++ ) {\\n\\n\\t\\t\\t\\tlut[ i ] = ( i < 16 ? '0' : '' ) + ( i ).toString( 16 ).toUpperCase();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn function () {\\n\\n\\t\\t\\t\\tvar d0 = Math.random() * 0xffffffff | 0;\\n\\t\\t\\t\\tvar d1 = Math.random() * 0xffffffff | 0;\\n\\t\\t\\t\\tvar d2 = Math.random() * 0xffffffff | 0;\\n\\t\\t\\t\\tvar d3 = Math.random() * 0xffffffff | 0;\\n\\t\\t\\t\\treturn lut[ d0 & 0xff ] + lut[ d0 >> 8 & 0xff ] + lut[ d0 >> 16 & 0xff ] + lut[ d0 >> 24 & 0xff ] + '-' +\\n\\t\\t\\t\\t\\tlut[ d1 & 0xff ] + lut[ d1 >> 8 & 0xff ] + '-' + lut[ d1 >> 16 & 0x0f | 0x40 ] + lut[ d1 >> 24 & 0xff ] + '-' +\\n\\t\\t\\t\\t\\tlut[ d2 & 0x3f | 0x80 ] + lut[ d2 >> 8 & 0xff ] + '-' + lut[ d2 >> 16 & 0xff ] + lut[ d2 >> 24 & 0xff ] +\\n\\t\\t\\t\\t\\tlut[ d3 & 0xff ] + lut[ d3 >> 8 & 0xff ] + lut[ d3 >> 16 & 0xff ] + lut[ d3 >> 24 & 0xff ];\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )(),\\n\\n\\t\\tclamp: function ( value, min, max ) {\\n\\n\\t\\t\\treturn Math.max( min, Math.min( max, value ) );\\n\\n\\t\\t},\\n\\n\\t\\t// compute euclidian modulo of m % n\\n\\t\\t// https://en.wikipedia.org/wiki/Modulo_operation\\n\\n\\t\\teuclideanModulo: function ( n, m ) {\\n\\n\\t\\t\\treturn ( ( n % m ) + m ) % m;\\n\\n\\t\\t},\\n\\n\\t\\t// Linear mapping from range <a1, a2> to range <b1, b2>\\n\\n\\t\\tmapLinear: function ( x, a1, a2, b1, b2 ) {\\n\\n\\t\\t\\treturn b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 );\\n\\n\\t\\t},\\n\\n\\t\\t// https://en.wikipedia.org/wiki/Linear_interpolation\\n\\n\\t\\tlerp: function ( x, y, t ) {\\n\\n\\t\\t\\treturn ( 1 - t ) * x + t * y;\\n\\n\\t\\t},\\n\\n\\t\\t// http://en.wikipedia.org/wiki/Smoothstep\\n\\n\\t\\tsmoothstep: function ( x, min, max ) {\\n\\n\\t\\t\\tif ( x <= min ) return 0;\\n\\t\\t\\tif ( x >= max ) return 1;\\n\\n\\t\\t\\tx = ( x - min ) / ( max - min );\\n\\n\\t\\t\\treturn x * x * ( 3 - 2 * x );\\n\\n\\t\\t},\\n\\n\\t\\tsmootherstep: function ( x, min, max ) {\\n\\n\\t\\t\\tif ( x <= min ) return 0;\\n\\t\\t\\tif ( x >= max ) return 1;\\n\\n\\t\\t\\tx = ( x - min ) / ( max - min );\\n\\n\\t\\t\\treturn x * x * x * ( x * ( x * 6 - 15 ) + 10 );\\n\\n\\t\\t},\\n\\n\\t\\t// Random integer from <low, high> interval\\n\\n\\t\\trandInt: function ( low, high ) {\\n\\n\\t\\t\\treturn low + Math.floor( Math.random() * ( high - low + 1 ) );\\n\\n\\t\\t},\\n\\n\\t\\t// Random float from <low, high> interval\\n\\n\\t\\trandFloat: function ( low, high ) {\\n\\n\\t\\t\\treturn low + Math.random() * ( high - low );\\n\\n\\t\\t},\\n\\n\\t\\t// Random float from <-range/2, range/2> interval\\n\\n\\t\\trandFloatSpread: function ( range ) {\\n\\n\\t\\t\\treturn range * ( 0.5 - Math.random() );\\n\\n\\t\\t},\\n\\n\\t\\tdegToRad: function ( degrees ) {\\n\\n\\t\\t\\treturn degrees * _Math.DEG2RAD;\\n\\n\\t\\t},\\n\\n\\t\\tradToDeg: function ( radians ) {\\n\\n\\t\\t\\treturn radians * _Math.RAD2DEG;\\n\\n\\t\\t},\\n\\n\\t\\tisPowerOfTwo: function ( value ) {\\n\\n\\t\\t\\treturn ( value & ( value - 1 ) ) === 0 && value !== 0;\\n\\n\\t\\t},\\n\\n\\t\\tceilPowerOfTwo: function ( value ) {\\n\\n\\t\\t\\treturn Math.pow( 2, Math.ceil( Math.log( value ) / Math.LN2 ) );\\n\\n\\t\\t},\\n\\n\\t\\tfloorPowerOfTwo: function ( value ) {\\n\\n\\t\\t\\treturn Math.pow( 2, Math.floor( Math.log( value ) / Math.LN2 ) );\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author philogb / http://blog.thejit.org/\\n\\t * @author egraether / http://egraether.com/\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t */\\n\\n\\tfunction Vector2( x, y ) {\\n\\n\\t\\tthis.x = x || 0;\\n\\t\\tthis.y = y || 0;\\n\\n\\t}\\n\\n\\tObject.defineProperties( Vector2.prototype, {\\n\\n\\t\\t\\\"width\\\": {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.x;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis.x = value;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t\\\"height\\\": {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.y;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis.y = value;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Vector2.prototype, {\\n\\n\\t\\tisVector2: true,\\n\\n\\t\\tset: function ( x, y ) {\\n\\n\\t\\t\\tthis.x = x;\\n\\t\\t\\tthis.y = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.x = scalar;\\n\\t\\t\\tthis.y = scalar;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetX: function ( x ) {\\n\\n\\t\\t\\tthis.x = x;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetY: function ( y ) {\\n\\n\\t\\t\\tthis.y = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetComponent: function ( index, value ) {\\n\\n\\t\\t\\tswitch ( index ) {\\n\\n\\t\\t\\t\\tcase 0: this.x = value; break;\\n\\t\\t\\t\\tcase 1: this.y = value; break;\\n\\t\\t\\t\\tdefault: throw new Error( 'index is out of range: ' + index );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetComponent: function ( index ) {\\n\\n\\t\\t\\tswitch ( index ) {\\n\\n\\t\\t\\t\\tcase 0: return this.x;\\n\\t\\t\\t\\tcase 1: return this.y;\\n\\t\\t\\t\\tdefault: throw new Error( 'index is out of range: ' + index );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.x, this.y );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( v ) {\\n\\n\\t\\t\\tthis.x = v.x;\\n\\t\\t\\tthis.y = v.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tadd: function ( v, w ) {\\n\\n\\t\\t\\tif ( w !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.addVectors( v, w );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x += v.x;\\n\\t\\t\\tthis.y += v.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddScalar: function ( s ) {\\n\\n\\t\\t\\tthis.x += s;\\n\\t\\t\\tthis.y += s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddVectors: function ( a, b ) {\\n\\n\\t\\t\\tthis.x = a.x + b.x;\\n\\t\\t\\tthis.y = a.y + b.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddScaledVector: function ( v, s ) {\\n\\n\\t\\t\\tthis.x += v.x * s;\\n\\t\\t\\tthis.y += v.y * s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsub: function ( v, w ) {\\n\\n\\t\\t\\tif ( w !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.subVectors( v, w );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x -= v.x;\\n\\t\\t\\tthis.y -= v.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsubScalar: function ( s ) {\\n\\n\\t\\t\\tthis.x -= s;\\n\\t\\t\\tthis.y -= s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsubVectors: function ( a, b ) {\\n\\n\\t\\t\\tthis.x = a.x - b.x;\\n\\t\\t\\tthis.y = a.y - b.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiply: function ( v ) {\\n\\n\\t\\t\\tthis.x *= v.x;\\n\\t\\t\\tthis.y *= v.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.x *= scalar;\\n\\t\\t\\tthis.y *= scalar;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdivide: function ( v ) {\\n\\n\\t\\t\\tthis.x /= v.x;\\n\\t\\t\\tthis.y /= v.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdivideScalar: function ( scalar ) {\\n\\n\\t\\t\\treturn this.multiplyScalar( 1 / scalar );\\n\\n\\t\\t},\\n\\n\\t\\tapplyMatrix3: function ( m ) {\\n\\n\\t\\t\\tvar x = this.x, y = this.y;\\n\\t\\t\\tvar e = m.elements;\\n\\n\\t\\t\\tthis.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ];\\n\\t\\t\\tthis.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmin: function ( v ) {\\n\\n\\t\\t\\tthis.x = Math.min( this.x, v.x );\\n\\t\\t\\tthis.y = Math.min( this.y, v.y );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmax: function ( v ) {\\n\\n\\t\\t\\tthis.x = Math.max( this.x, v.x );\\n\\t\\t\\tthis.y = Math.max( this.y, v.y );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclamp: function ( min, max ) {\\n\\n\\t\\t\\t// assumes min < max, componentwise\\n\\n\\t\\t\\tthis.x = Math.max( min.x, Math.min( max.x, this.x ) );\\n\\t\\t\\tthis.y = Math.max( min.y, Math.min( max.y, this.y ) );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclampScalar: function () {\\n\\n\\t\\t\\tvar min = new Vector2();\\n\\t\\t\\tvar max = new Vector2();\\n\\n\\t\\t\\treturn function clampScalar( minVal, maxVal ) {\\n\\n\\t\\t\\t\\tmin.set( minVal, minVal );\\n\\t\\t\\t\\tmax.set( maxVal, maxVal );\\n\\n\\t\\t\\t\\treturn this.clamp( min, max );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tclampLength: function ( min, max ) {\\n\\n\\t\\t\\tvar length = this.length();\\n\\n\\t\\t\\treturn this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );\\n\\n\\t\\t},\\n\\n\\t\\tfloor: function () {\\n\\n\\t\\t\\tthis.x = Math.floor( this.x );\\n\\t\\t\\tthis.y = Math.floor( this.y );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tceil: function () {\\n\\n\\t\\t\\tthis.x = Math.ceil( this.x );\\n\\t\\t\\tthis.y = Math.ceil( this.y );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tround: function () {\\n\\n\\t\\t\\tthis.x = Math.round( this.x );\\n\\t\\t\\tthis.y = Math.round( this.y );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\troundToZero: function () {\\n\\n\\t\\t\\tthis.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );\\n\\t\\t\\tthis.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tnegate: function () {\\n\\n\\t\\t\\tthis.x = - this.x;\\n\\t\\t\\tthis.y = - this.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdot: function ( v ) {\\n\\n\\t\\t\\treturn this.x * v.x + this.y * v.y;\\n\\n\\t\\t},\\n\\n\\t\\tlengthSq: function () {\\n\\n\\t\\t\\treturn this.x * this.x + this.y * this.y;\\n\\n\\t\\t},\\n\\n\\t\\tlength: function () {\\n\\n\\t\\t\\treturn Math.sqrt( this.x * this.x + this.y * this.y );\\n\\n\\t\\t},\\n\\n\\t\\tmanhattanLength: function () {\\n\\n\\t\\t\\treturn Math.abs( this.x ) + Math.abs( this.y );\\n\\n\\t\\t},\\n\\n\\t\\tnormalize: function () {\\n\\n\\t\\t\\treturn this.divideScalar( this.length() || 1 );\\n\\n\\t\\t},\\n\\n\\t\\tangle: function () {\\n\\n\\t\\t\\t// computes the angle in radians with respect to the positive x-axis\\n\\n\\t\\t\\tvar angle = Math.atan2( this.y, this.x );\\n\\n\\t\\t\\tif ( angle < 0 ) angle += 2 * Math.PI;\\n\\n\\t\\t\\treturn angle;\\n\\n\\t\\t},\\n\\n\\t\\tdistanceTo: function ( v ) {\\n\\n\\t\\t\\treturn Math.sqrt( this.distanceToSquared( v ) );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToSquared: function ( v ) {\\n\\n\\t\\t\\tvar dx = this.x - v.x, dy = this.y - v.y;\\n\\t\\t\\treturn dx * dx + dy * dy;\\n\\n\\t\\t},\\n\\n\\t\\tmanhattanDistanceTo: function ( v ) {\\n\\n\\t\\t\\treturn Math.abs( this.x - v.x ) + Math.abs( this.y - v.y );\\n\\n\\t\\t},\\n\\n\\t\\tsetLength: function ( length ) {\\n\\n\\t\\t\\treturn this.normalize().multiplyScalar( length );\\n\\n\\t\\t},\\n\\n\\t\\tlerp: function ( v, alpha ) {\\n\\n\\t\\t\\tthis.x += ( v.x - this.x ) * alpha;\\n\\t\\t\\tthis.y += ( v.y - this.y ) * alpha;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tlerpVectors: function ( v1, v2, alpha ) {\\n\\n\\t\\t\\treturn this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( v ) {\\n\\n\\t\\t\\treturn ( ( v.x === this.x ) && ( v.y === this.y ) );\\n\\n\\t\\t},\\n\\n\\t\\tfromArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tthis.x = array[ offset ];\\n\\t\\t\\tthis.y = array[ offset + 1 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( array === undefined ) array = [];\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tarray[ offset ] = this.x;\\n\\t\\t\\tarray[ offset + 1 ] = this.y;\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t},\\n\\n\\t\\tfromBufferAttribute: function ( attribute, index, offset ) {\\n\\n\\t\\t\\tif ( offset !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector2: offset has been removed from .fromBufferAttribute().' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x = attribute.getX( index );\\n\\t\\t\\tthis.y = attribute.getY( index );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\trotateAround: function ( center, angle ) {\\n\\n\\t\\t\\tvar c = Math.cos( angle ), s = Math.sin( angle );\\n\\n\\t\\t\\tvar x = this.x - center.x;\\n\\t\\t\\tvar y = this.y - center.y;\\n\\n\\t\\t\\tthis.x = x * c - y * s + center.x;\\n\\t\\t\\tthis.y = x * s + y * c + center.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author supereggbert / http://www.paulbrunt.co.uk/\\n\\t * @author philogb / http://blog.thejit.org/\\n\\t * @author jordi_ros / http://plattsoft.com\\n\\t * @author D1plo1d / http://github.com/D1plo1d\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author timknip / http://www.floorplanner.com/\\n\\t * @author bhouston / http://clara.io\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction Matrix4() {\\n\\n\\t\\tthis.elements = [\\n\\n\\t\\t\\t1, 0, 0, 0,\\n\\t\\t\\t0, 1, 0, 0,\\n\\t\\t\\t0, 0, 1, 0,\\n\\t\\t\\t0, 0, 0, 1\\n\\n\\t\\t];\\n\\n\\t\\tif ( arguments.length > 0 ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.' );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tObject.assign( Matrix4.prototype, {\\n\\n\\t\\tisMatrix4: true,\\n\\n\\t\\tset: function ( n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44 ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tte[ 0 ] = n11; te[ 4 ] = n12; te[ 8 ] = n13; te[ 12 ] = n14;\\n\\t\\t\\tte[ 1 ] = n21; te[ 5 ] = n22; te[ 9 ] = n23; te[ 13 ] = n24;\\n\\t\\t\\tte[ 2 ] = n31; te[ 6 ] = n32; te[ 10 ] = n33; te[ 14 ] = n34;\\n\\t\\t\\tte[ 3 ] = n41; te[ 7 ] = n42; te[ 11 ] = n43; te[ 15 ] = n44;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tidentity: function () {\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\t1, 0, 0, 0,\\n\\t\\t\\t\\t0, 1, 0, 0,\\n\\t\\t\\t\\t0, 0, 1, 0,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new Matrix4().fromArray( this.elements );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( m ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\t\\t\\tvar me = m.elements;\\n\\n\\t\\t\\tte[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ]; te[ 3 ] = me[ 3 ];\\n\\t\\t\\tte[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ]; te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ];\\n\\t\\t\\tte[ 8 ] = me[ 8 ]; te[ 9 ] = me[ 9 ]; te[ 10 ] = me[ 10 ]; te[ 11 ] = me[ 11 ];\\n\\t\\t\\tte[ 12 ] = me[ 12 ]; te[ 13 ] = me[ 13 ]; te[ 14 ] = me[ 14 ]; te[ 15 ] = me[ 15 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyPosition: function ( m ) {\\n\\n\\t\\t\\tvar te = this.elements, me = m.elements;\\n\\n\\t\\t\\tte[ 12 ] = me[ 12 ];\\n\\t\\t\\tte[ 13 ] = me[ 13 ];\\n\\t\\t\\tte[ 14 ] = me[ 14 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\textractBasis: function ( xAxis, yAxis, zAxis ) {\\n\\n\\t\\t\\txAxis.setFromMatrixColumn( this, 0 );\\n\\t\\t\\tyAxis.setFromMatrixColumn( this, 1 );\\n\\t\\t\\tzAxis.setFromMatrixColumn( this, 2 );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeBasis: function ( xAxis, yAxis, zAxis ) {\\n\\n\\t\\t\\tthis.set(\\n\\t\\t\\t\\txAxis.x, yAxis.x, zAxis.x, 0,\\n\\t\\t\\t\\txAxis.y, yAxis.y, zAxis.y, 0,\\n\\t\\t\\t\\txAxis.z, yAxis.z, zAxis.z, 0,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\textractRotation: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function extractRotation( m ) {\\n\\n\\t\\t\\t\\tvar te = this.elements;\\n\\t\\t\\t\\tvar me = m.elements;\\n\\n\\t\\t\\t\\tvar scaleX = 1 / v1.setFromMatrixColumn( m, 0 ).length();\\n\\t\\t\\t\\tvar scaleY = 1 / v1.setFromMatrixColumn( m, 1 ).length();\\n\\t\\t\\t\\tvar scaleZ = 1 / v1.setFromMatrixColumn( m, 2 ).length();\\n\\n\\t\\t\\t\\tte[ 0 ] = me[ 0 ] * scaleX;\\n\\t\\t\\t\\tte[ 1 ] = me[ 1 ] * scaleX;\\n\\t\\t\\t\\tte[ 2 ] = me[ 2 ] * scaleX;\\n\\n\\t\\t\\t\\tte[ 4 ] = me[ 4 ] * scaleY;\\n\\t\\t\\t\\tte[ 5 ] = me[ 5 ] * scaleY;\\n\\t\\t\\t\\tte[ 6 ] = me[ 6 ] * scaleY;\\n\\n\\t\\t\\t\\tte[ 8 ] = me[ 8 ] * scaleZ;\\n\\t\\t\\t\\tte[ 9 ] = me[ 9 ] * scaleZ;\\n\\t\\t\\t\\tte[ 10 ] = me[ 10 ] * scaleZ;\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tmakeRotationFromEuler: function ( euler ) {\\n\\n\\t\\t\\tif ( ! ( euler && euler.isEuler ) ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tvar x = euler.x, y = euler.y, z = euler.z;\\n\\t\\t\\tvar a = Math.cos( x ), b = Math.sin( x );\\n\\t\\t\\tvar c = Math.cos( y ), d = Math.sin( y );\\n\\t\\t\\tvar e = Math.cos( z ), f = Math.sin( z );\\n\\n\\t\\t\\tif ( euler.order === 'XYZ' ) {\\n\\n\\t\\t\\t\\tvar ae = a * e, af = a * f, be = b * e, bf = b * f;\\n\\n\\t\\t\\t\\tte[ 0 ] = c * e;\\n\\t\\t\\t\\tte[ 4 ] = - c * f;\\n\\t\\t\\t\\tte[ 8 ] = d;\\n\\n\\t\\t\\t\\tte[ 1 ] = af + be * d;\\n\\t\\t\\t\\tte[ 5 ] = ae - bf * d;\\n\\t\\t\\t\\tte[ 9 ] = - b * c;\\n\\n\\t\\t\\t\\tte[ 2 ] = bf - ae * d;\\n\\t\\t\\t\\tte[ 6 ] = be + af * d;\\n\\t\\t\\t\\tte[ 10 ] = a * c;\\n\\n\\t\\t\\t} else if ( euler.order === 'YXZ' ) {\\n\\n\\t\\t\\t\\tvar ce = c * e, cf = c * f, de = d * e, df = d * f;\\n\\n\\t\\t\\t\\tte[ 0 ] = ce + df * b;\\n\\t\\t\\t\\tte[ 4 ] = de * b - cf;\\n\\t\\t\\t\\tte[ 8 ] = a * d;\\n\\n\\t\\t\\t\\tte[ 1 ] = a * f;\\n\\t\\t\\t\\tte[ 5 ] = a * e;\\n\\t\\t\\t\\tte[ 9 ] = - b;\\n\\n\\t\\t\\t\\tte[ 2 ] = cf * b - de;\\n\\t\\t\\t\\tte[ 6 ] = df + ce * b;\\n\\t\\t\\t\\tte[ 10 ] = a * c;\\n\\n\\t\\t\\t} else if ( euler.order === 'ZXY' ) {\\n\\n\\t\\t\\t\\tvar ce = c * e, cf = c * f, de = d * e, df = d * f;\\n\\n\\t\\t\\t\\tte[ 0 ] = ce - df * b;\\n\\t\\t\\t\\tte[ 4 ] = - a * f;\\n\\t\\t\\t\\tte[ 8 ] = de + cf * b;\\n\\n\\t\\t\\t\\tte[ 1 ] = cf + de * b;\\n\\t\\t\\t\\tte[ 5 ] = a * e;\\n\\t\\t\\t\\tte[ 9 ] = df - ce * b;\\n\\n\\t\\t\\t\\tte[ 2 ] = - a * d;\\n\\t\\t\\t\\tte[ 6 ] = b;\\n\\t\\t\\t\\tte[ 10 ] = a * c;\\n\\n\\t\\t\\t} else if ( euler.order === 'ZYX' ) {\\n\\n\\t\\t\\t\\tvar ae = a * e, af = a * f, be = b * e, bf = b * f;\\n\\n\\t\\t\\t\\tte[ 0 ] = c * e;\\n\\t\\t\\t\\tte[ 4 ] = be * d - af;\\n\\t\\t\\t\\tte[ 8 ] = ae * d + bf;\\n\\n\\t\\t\\t\\tte[ 1 ] = c * f;\\n\\t\\t\\t\\tte[ 5 ] = bf * d + ae;\\n\\t\\t\\t\\tte[ 9 ] = af * d - be;\\n\\n\\t\\t\\t\\tte[ 2 ] = - d;\\n\\t\\t\\t\\tte[ 6 ] = b * c;\\n\\t\\t\\t\\tte[ 10 ] = a * c;\\n\\n\\t\\t\\t} else if ( euler.order === 'YZX' ) {\\n\\n\\t\\t\\t\\tvar ac = a * c, ad = a * d, bc = b * c, bd = b * d;\\n\\n\\t\\t\\t\\tte[ 0 ] = c * e;\\n\\t\\t\\t\\tte[ 4 ] = bd - ac * f;\\n\\t\\t\\t\\tte[ 8 ] = bc * f + ad;\\n\\n\\t\\t\\t\\tte[ 1 ] = f;\\n\\t\\t\\t\\tte[ 5 ] = a * e;\\n\\t\\t\\t\\tte[ 9 ] = - b * e;\\n\\n\\t\\t\\t\\tte[ 2 ] = - d * e;\\n\\t\\t\\t\\tte[ 6 ] = ad * f + bc;\\n\\t\\t\\t\\tte[ 10 ] = ac - bd * f;\\n\\n\\t\\t\\t} else if ( euler.order === 'XZY' ) {\\n\\n\\t\\t\\t\\tvar ac = a * c, ad = a * d, bc = b * c, bd = b * d;\\n\\n\\t\\t\\t\\tte[ 0 ] = c * e;\\n\\t\\t\\t\\tte[ 4 ] = - f;\\n\\t\\t\\t\\tte[ 8 ] = d * e;\\n\\n\\t\\t\\t\\tte[ 1 ] = ac * f + bd;\\n\\t\\t\\t\\tte[ 5 ] = a * e;\\n\\t\\t\\t\\tte[ 9 ] = ad * f - bc;\\n\\n\\t\\t\\t\\tte[ 2 ] = bc * f - ad;\\n\\t\\t\\t\\tte[ 6 ] = b * e;\\n\\t\\t\\t\\tte[ 10 ] = bd * f + ac;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// last column\\n\\t\\t\\tte[ 3 ] = 0;\\n\\t\\t\\tte[ 7 ] = 0;\\n\\t\\t\\tte[ 11 ] = 0;\\n\\n\\t\\t\\t// bottom row\\n\\t\\t\\tte[ 12 ] = 0;\\n\\t\\t\\tte[ 13 ] = 0;\\n\\t\\t\\tte[ 14 ] = 0;\\n\\t\\t\\tte[ 15 ] = 1;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeRotationFromQuaternion: function ( q ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tvar x = q._x, y = q._y, z = q._z, w = q._w;\\n\\t\\t\\tvar x2 = x + x, y2 = y + y, z2 = z + z;\\n\\t\\t\\tvar xx = x * x2, xy = x * y2, xz = x * z2;\\n\\t\\t\\tvar yy = y * y2, yz = y * z2, zz = z * z2;\\n\\t\\t\\tvar wx = w * x2, wy = w * y2, wz = w * z2;\\n\\n\\t\\t\\tte[ 0 ] = 1 - ( yy + zz );\\n\\t\\t\\tte[ 4 ] = xy - wz;\\n\\t\\t\\tte[ 8 ] = xz + wy;\\n\\n\\t\\t\\tte[ 1 ] = xy + wz;\\n\\t\\t\\tte[ 5 ] = 1 - ( xx + zz );\\n\\t\\t\\tte[ 9 ] = yz - wx;\\n\\n\\t\\t\\tte[ 2 ] = xz - wy;\\n\\t\\t\\tte[ 6 ] = yz + wx;\\n\\t\\t\\tte[ 10 ] = 1 - ( xx + yy );\\n\\n\\t\\t\\t// last column\\n\\t\\t\\tte[ 3 ] = 0;\\n\\t\\t\\tte[ 7 ] = 0;\\n\\t\\t\\tte[ 11 ] = 0;\\n\\n\\t\\t\\t// bottom row\\n\\t\\t\\tte[ 12 ] = 0;\\n\\t\\t\\tte[ 13 ] = 0;\\n\\t\\t\\tte[ 14 ] = 0;\\n\\t\\t\\tte[ 15 ] = 1;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tlookAt: function () {\\n\\n\\t\\t\\tvar x = new Vector3();\\n\\t\\t\\tvar y = new Vector3();\\n\\t\\t\\tvar z = new Vector3();\\n\\n\\t\\t\\treturn function lookAt( eye, target, up ) {\\n\\n\\t\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\t\\tz.subVectors( eye, target );\\n\\n\\t\\t\\t\\tif ( z.lengthSq() === 0 ) {\\n\\n\\t\\t\\t\\t\\t// eye and target are in the same position\\n\\n\\t\\t\\t\\t\\tz.z = 1;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tz.normalize();\\n\\t\\t\\t\\tx.crossVectors( up, z );\\n\\n\\t\\t\\t\\tif ( x.lengthSq() === 0 ) {\\n\\n\\t\\t\\t\\t\\t// up and z are parallel\\n\\n\\t\\t\\t\\t\\tif ( Math.abs( up.z ) === 1 ) {\\n\\n\\t\\t\\t\\t\\t\\tz.x += 0.0001;\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tz.z += 0.0001;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tz.normalize();\\n\\t\\t\\t\\t\\tx.crossVectors( up, z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tx.normalize();\\n\\t\\t\\t\\ty.crossVectors( z, x );\\n\\n\\t\\t\\t\\tte[ 0 ] = x.x; te[ 4 ] = y.x; te[ 8 ] = z.x;\\n\\t\\t\\t\\tte[ 1 ] = x.y; te[ 5 ] = y.y; te[ 9 ] = z.y;\\n\\t\\t\\t\\tte[ 2 ] = x.z; te[ 6 ] = y.z; te[ 10 ] = z.z;\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tmultiply: function ( m, n ) {\\n\\n\\t\\t\\tif ( n !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.multiplyMatrices( m, n );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this.multiplyMatrices( this, m );\\n\\n\\t\\t},\\n\\n\\t\\tpremultiply: function ( m ) {\\n\\n\\t\\t\\treturn this.multiplyMatrices( m, this );\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyMatrices: function ( a, b ) {\\n\\n\\t\\t\\tvar ae = a.elements;\\n\\t\\t\\tvar be = b.elements;\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tvar a11 = ae[ 0 ], a12 = ae[ 4 ], a13 = ae[ 8 ], a14 = ae[ 12 ];\\n\\t\\t\\tvar a21 = ae[ 1 ], a22 = ae[ 5 ], a23 = ae[ 9 ], a24 = ae[ 13 ];\\n\\t\\t\\tvar a31 = ae[ 2 ], a32 = ae[ 6 ], a33 = ae[ 10 ], a34 = ae[ 14 ];\\n\\t\\t\\tvar a41 = ae[ 3 ], a42 = ae[ 7 ], a43 = ae[ 11 ], a44 = ae[ 15 ];\\n\\n\\t\\t\\tvar b11 = be[ 0 ], b12 = be[ 4 ], b13 = be[ 8 ], b14 = be[ 12 ];\\n\\t\\t\\tvar b21 = be[ 1 ], b22 = be[ 5 ], b23 = be[ 9 ], b24 = be[ 13 ];\\n\\t\\t\\tvar b31 = be[ 2 ], b32 = be[ 6 ], b33 = be[ 10 ], b34 = be[ 14 ];\\n\\t\\t\\tvar b41 = be[ 3 ], b42 = be[ 7 ], b43 = be[ 11 ], b44 = be[ 15 ];\\n\\n\\t\\t\\tte[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;\\n\\t\\t\\tte[ 4 ] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;\\n\\t\\t\\tte[ 8 ] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;\\n\\t\\t\\tte[ 12 ] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;\\n\\n\\t\\t\\tte[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;\\n\\t\\t\\tte[ 5 ] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;\\n\\t\\t\\tte[ 9 ] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;\\n\\t\\t\\tte[ 13 ] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;\\n\\n\\t\\t\\tte[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;\\n\\t\\t\\tte[ 6 ] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;\\n\\t\\t\\tte[ 10 ] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;\\n\\t\\t\\tte[ 14 ] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;\\n\\n\\t\\t\\tte[ 3 ] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;\\n\\t\\t\\tte[ 7 ] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;\\n\\t\\t\\tte[ 11 ] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;\\n\\t\\t\\tte[ 15 ] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyScalar: function ( s ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tte[ 0 ] *= s; te[ 4 ] *= s; te[ 8 ] *= s; te[ 12 ] *= s;\\n\\t\\t\\tte[ 1 ] *= s; te[ 5 ] *= s; te[ 9 ] *= s; te[ 13 ] *= s;\\n\\t\\t\\tte[ 2 ] *= s; te[ 6 ] *= s; te[ 10 ] *= s; te[ 14 ] *= s;\\n\\t\\t\\tte[ 3 ] *= s; te[ 7 ] *= s; te[ 11 ] *= s; te[ 15 ] *= s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tapplyToBufferAttribute: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function applyToBufferAttribute( attribute ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = attribute.count; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tv1.x = attribute.getX( i );\\n\\t\\t\\t\\t\\tv1.y = attribute.getY( i );\\n\\t\\t\\t\\t\\tv1.z = attribute.getZ( i );\\n\\n\\t\\t\\t\\t\\tv1.applyMatrix4( this );\\n\\n\\t\\t\\t\\t\\tattribute.setXYZ( i, v1.x, v1.y, v1.z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn attribute;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tdeterminant: function () {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tvar n11 = te[ 0 ], n12 = te[ 4 ], n13 = te[ 8 ], n14 = te[ 12 ];\\n\\t\\t\\tvar n21 = te[ 1 ], n22 = te[ 5 ], n23 = te[ 9 ], n24 = te[ 13 ];\\n\\t\\t\\tvar n31 = te[ 2 ], n32 = te[ 6 ], n33 = te[ 10 ], n34 = te[ 14 ];\\n\\t\\t\\tvar n41 = te[ 3 ], n42 = te[ 7 ], n43 = te[ 11 ], n44 = te[ 15 ];\\n\\n\\t\\t\\t//TODO: make this more efficient\\n\\t\\t\\t//( based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm )\\n\\n\\t\\t\\treturn (\\n\\t\\t\\t\\tn41 * (\\n\\t\\t\\t\\t\\t+ n14 * n23 * n32\\n\\t\\t\\t\\t\\t - n13 * n24 * n32\\n\\t\\t\\t\\t\\t - n14 * n22 * n33\\n\\t\\t\\t\\t\\t + n12 * n24 * n33\\n\\t\\t\\t\\t\\t + n13 * n22 * n34\\n\\t\\t\\t\\t\\t - n12 * n23 * n34\\n\\t\\t\\t\\t) +\\n\\t\\t\\t\\tn42 * (\\n\\t\\t\\t\\t\\t+ n11 * n23 * n34\\n\\t\\t\\t\\t\\t - n11 * n24 * n33\\n\\t\\t\\t\\t\\t + n14 * n21 * n33\\n\\t\\t\\t\\t\\t - n13 * n21 * n34\\n\\t\\t\\t\\t\\t + n13 * n24 * n31\\n\\t\\t\\t\\t\\t - n14 * n23 * n31\\n\\t\\t\\t\\t) +\\n\\t\\t\\t\\tn43 * (\\n\\t\\t\\t\\t\\t+ n11 * n24 * n32\\n\\t\\t\\t\\t\\t - n11 * n22 * n34\\n\\t\\t\\t\\t\\t - n14 * n21 * n32\\n\\t\\t\\t\\t\\t + n12 * n21 * n34\\n\\t\\t\\t\\t\\t + n14 * n22 * n31\\n\\t\\t\\t\\t\\t - n12 * n24 * n31\\n\\t\\t\\t\\t) +\\n\\t\\t\\t\\tn44 * (\\n\\t\\t\\t\\t\\t- n13 * n22 * n31\\n\\t\\t\\t\\t\\t - n11 * n23 * n32\\n\\t\\t\\t\\t\\t + n11 * n22 * n33\\n\\t\\t\\t\\t\\t + n13 * n21 * n32\\n\\t\\t\\t\\t\\t - n12 * n21 * n33\\n\\t\\t\\t\\t\\t + n12 * n23 * n31\\n\\t\\t\\t\\t)\\n\\n\\t\\t\\t);\\n\\n\\t\\t},\\n\\n\\t\\ttranspose: function () {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\t\\t\\tvar tmp;\\n\\n\\t\\t\\ttmp = te[ 1 ]; te[ 1 ] = te[ 4 ]; te[ 4 ] = tmp;\\n\\t\\t\\ttmp = te[ 2 ]; te[ 2 ] = te[ 8 ]; te[ 8 ] = tmp;\\n\\t\\t\\ttmp = te[ 6 ]; te[ 6 ] = te[ 9 ]; te[ 9 ] = tmp;\\n\\n\\t\\t\\ttmp = te[ 3 ]; te[ 3 ] = te[ 12 ]; te[ 12 ] = tmp;\\n\\t\\t\\ttmp = te[ 7 ]; te[ 7 ] = te[ 13 ]; te[ 13 ] = tmp;\\n\\t\\t\\ttmp = te[ 11 ]; te[ 11 ] = te[ 14 ]; te[ 14 ] = tmp;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetPosition: function ( v ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tte[ 12 ] = v.x;\\n\\t\\t\\tte[ 13 ] = v.y;\\n\\t\\t\\tte[ 14 ] = v.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetInverse: function ( m, throwOnDegenerate ) {\\n\\n\\t\\t\\t// based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm\\n\\t\\t\\tvar te = this.elements,\\n\\t\\t\\t\\tme = m.elements,\\n\\n\\t\\t\\t\\tn11 = me[ 0 ], n21 = me[ 1 ], n31 = me[ 2 ], n41 = me[ 3 ],\\n\\t\\t\\t\\tn12 = me[ 4 ], n22 = me[ 5 ], n32 = me[ 6 ], n42 = me[ 7 ],\\n\\t\\t\\t\\tn13 = me[ 8 ], n23 = me[ 9 ], n33 = me[ 10 ], n43 = me[ 11 ],\\n\\t\\t\\t\\tn14 = me[ 12 ], n24 = me[ 13 ], n34 = me[ 14 ], n44 = me[ 15 ],\\n\\n\\t\\t\\t\\tt11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44,\\n\\t\\t\\t\\tt12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44,\\n\\t\\t\\t\\tt13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44,\\n\\t\\t\\t\\tt14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;\\n\\n\\t\\t\\tvar det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;\\n\\n\\t\\t\\tif ( det === 0 ) {\\n\\n\\t\\t\\t\\tvar msg = \\\"THREE.Matrix4: .getInverse() can't invert matrix, determinant is 0\\\";\\n\\n\\t\\t\\t\\tif ( throwOnDegenerate === true ) {\\n\\n\\t\\t\\t\\t\\tthrow new Error( msg );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tconsole.warn( msg );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn this.identity();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar detInv = 1 / det;\\n\\n\\t\\t\\tte[ 0 ] = t11 * detInv;\\n\\t\\t\\tte[ 1 ] = ( n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44 ) * detInv;\\n\\t\\t\\tte[ 2 ] = ( n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44 ) * detInv;\\n\\t\\t\\tte[ 3 ] = ( n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43 ) * detInv;\\n\\n\\t\\t\\tte[ 4 ] = t12 * detInv;\\n\\t\\t\\tte[ 5 ] = ( n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44 ) * detInv;\\n\\t\\t\\tte[ 6 ] = ( n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44 ) * detInv;\\n\\t\\t\\tte[ 7 ] = ( n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43 ) * detInv;\\n\\n\\t\\t\\tte[ 8 ] = t13 * detInv;\\n\\t\\t\\tte[ 9 ] = ( n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44 ) * detInv;\\n\\t\\t\\tte[ 10 ] = ( n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44 ) * detInv;\\n\\t\\t\\tte[ 11 ] = ( n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43 ) * detInv;\\n\\n\\t\\t\\tte[ 12 ] = t14 * detInv;\\n\\t\\t\\tte[ 13 ] = ( n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34 ) * detInv;\\n\\t\\t\\tte[ 14 ] = ( n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34 ) * detInv;\\n\\t\\t\\tte[ 15 ] = ( n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33 ) * detInv;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tscale: function ( v ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\t\\t\\tvar x = v.x, y = v.y, z = v.z;\\n\\n\\t\\t\\tte[ 0 ] *= x; te[ 4 ] *= y; te[ 8 ] *= z;\\n\\t\\t\\tte[ 1 ] *= x; te[ 5 ] *= y; te[ 9 ] *= z;\\n\\t\\t\\tte[ 2 ] *= x; te[ 6 ] *= y; te[ 10 ] *= z;\\n\\t\\t\\tte[ 3 ] *= x; te[ 7 ] *= y; te[ 11 ] *= z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetMaxScaleOnAxis: function () {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tvar scaleXSq = te[ 0 ] * te[ 0 ] + te[ 1 ] * te[ 1 ] + te[ 2 ] * te[ 2 ];\\n\\t\\t\\tvar scaleYSq = te[ 4 ] * te[ 4 ] + te[ 5 ] * te[ 5 ] + te[ 6 ] * te[ 6 ];\\n\\t\\t\\tvar scaleZSq = te[ 8 ] * te[ 8 ] + te[ 9 ] * te[ 9 ] + te[ 10 ] * te[ 10 ];\\n\\n\\t\\t\\treturn Math.sqrt( Math.max( scaleXSq, scaleYSq, scaleZSq ) );\\n\\n\\t\\t},\\n\\n\\t\\tmakeTranslation: function ( x, y, z ) {\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\t1, 0, 0, x,\\n\\t\\t\\t\\t0, 1, 0, y,\\n\\t\\t\\t\\t0, 0, 1, z,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeRotationX: function ( theta ) {\\n\\n\\t\\t\\tvar c = Math.cos( theta ), s = Math.sin( theta );\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\t1, 0, 0, 0,\\n\\t\\t\\t\\t0, c, - s, 0,\\n\\t\\t\\t\\t0, s, c, 0,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeRotationY: function ( theta ) {\\n\\n\\t\\t\\tvar c = Math.cos( theta ), s = Math.sin( theta );\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\t c, 0, s, 0,\\n\\t\\t\\t\\t 0, 1, 0, 0,\\n\\t\\t\\t\\t- s, 0, c, 0,\\n\\t\\t\\t\\t 0, 0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeRotationZ: function ( theta ) {\\n\\n\\t\\t\\tvar c = Math.cos( theta ), s = Math.sin( theta );\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\tc, - s, 0, 0,\\n\\t\\t\\t\\ts, c, 0, 0,\\n\\t\\t\\t\\t0, 0, 1, 0,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeRotationAxis: function ( axis, angle ) {\\n\\n\\t\\t\\t// Based on http://www.gamedev.net/reference/articles/article1199.asp\\n\\n\\t\\t\\tvar c = Math.cos( angle );\\n\\t\\t\\tvar s = Math.sin( angle );\\n\\t\\t\\tvar t = 1 - c;\\n\\t\\t\\tvar x = axis.x, y = axis.y, z = axis.z;\\n\\t\\t\\tvar tx = t * x, ty = t * y;\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\ttx * x + c, tx * y - s * z, tx * z + s * y, 0,\\n\\t\\t\\t\\ttx * y + s * z, ty * y + c, ty * z - s * x, 0,\\n\\t\\t\\t\\ttx * z - s * y, ty * z + s * x, t * z * z + c, 0,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\t return this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeScale: function ( x, y, z ) {\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\tx, 0, 0, 0,\\n\\t\\t\\t\\t0, y, 0, 0,\\n\\t\\t\\t\\t0, 0, z, 0,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeShear: function ( x, y, z ) {\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\t1, y, z, 0,\\n\\t\\t\\t\\tx, 1, z, 0,\\n\\t\\t\\t\\tx, y, 1, 0,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcompose: function ( position, quaternion, scale ) {\\n\\n\\t\\t\\tthis.makeRotationFromQuaternion( quaternion );\\n\\t\\t\\tthis.scale( scale );\\n\\t\\t\\tthis.setPosition( position );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdecompose: function () {\\n\\n\\t\\t\\tvar vector = new Vector3();\\n\\t\\t\\tvar matrix = new Matrix4();\\n\\n\\t\\t\\treturn function decompose( position, quaternion, scale ) {\\n\\n\\t\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\t\\tvar sx = vector.set( te[ 0 ], te[ 1 ], te[ 2 ] ).length();\\n\\t\\t\\t\\tvar sy = vector.set( te[ 4 ], te[ 5 ], te[ 6 ] ).length();\\n\\t\\t\\t\\tvar sz = vector.set( te[ 8 ], te[ 9 ], te[ 10 ] ).length();\\n\\n\\t\\t\\t\\t// if determine is negative, we need to invert one scale\\n\\t\\t\\t\\tvar det = this.determinant();\\n\\t\\t\\t\\tif ( det < 0 ) sx = - sx;\\n\\n\\t\\t\\t\\tposition.x = te[ 12 ];\\n\\t\\t\\t\\tposition.y = te[ 13 ];\\n\\t\\t\\t\\tposition.z = te[ 14 ];\\n\\n\\t\\t\\t\\t// scale the rotation part\\n\\t\\t\\t\\tmatrix.copy( this );\\n\\n\\t\\t\\t\\tvar invSX = 1 / sx;\\n\\t\\t\\t\\tvar invSY = 1 / sy;\\n\\t\\t\\t\\tvar invSZ = 1 / sz;\\n\\n\\t\\t\\t\\tmatrix.elements[ 0 ] *= invSX;\\n\\t\\t\\t\\tmatrix.elements[ 1 ] *= invSX;\\n\\t\\t\\t\\tmatrix.elements[ 2 ] *= invSX;\\n\\n\\t\\t\\t\\tmatrix.elements[ 4 ] *= invSY;\\n\\t\\t\\t\\tmatrix.elements[ 5 ] *= invSY;\\n\\t\\t\\t\\tmatrix.elements[ 6 ] *= invSY;\\n\\n\\t\\t\\t\\tmatrix.elements[ 8 ] *= invSZ;\\n\\t\\t\\t\\tmatrix.elements[ 9 ] *= invSZ;\\n\\t\\t\\t\\tmatrix.elements[ 10 ] *= invSZ;\\n\\n\\t\\t\\t\\tquaternion.setFromRotationMatrix( matrix );\\n\\n\\t\\t\\t\\tscale.x = sx;\\n\\t\\t\\t\\tscale.y = sy;\\n\\t\\t\\t\\tscale.z = sz;\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tmakePerspective: function ( left, right, top, bottom, near, far ) {\\n\\n\\t\\t\\tif ( far === undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Matrix4: .makePerspective() has been redefined and has a new signature. Please check the docs.' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar te = this.elements;\\n\\t\\t\\tvar x = 2 * near / ( right - left );\\n\\t\\t\\tvar y = 2 * near / ( top - bottom );\\n\\n\\t\\t\\tvar a = ( right + left ) / ( right - left );\\n\\t\\t\\tvar b = ( top + bottom ) / ( top - bottom );\\n\\t\\t\\tvar c = - ( far + near ) / ( far - near );\\n\\t\\t\\tvar d = - 2 * far * near / ( far - near );\\n\\n\\t\\t\\tte[ 0 ] = x;\\tte[ 4 ] = 0;\\tte[ 8 ] = a;\\tte[ 12 ] = 0;\\n\\t\\t\\tte[ 1 ] = 0;\\tte[ 5 ] = y;\\tte[ 9 ] = b;\\tte[ 13 ] = 0;\\n\\t\\t\\tte[ 2 ] = 0;\\tte[ 6 ] = 0;\\tte[ 10 ] = c;\\tte[ 14 ] = d;\\n\\t\\t\\tte[ 3 ] = 0;\\tte[ 7 ] = 0;\\tte[ 11 ] = - 1;\\tte[ 15 ] = 0;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeOrthographic: function ( left, right, top, bottom, near, far ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\t\\t\\tvar w = 1.0 / ( right - left );\\n\\t\\t\\tvar h = 1.0 / ( top - bottom );\\n\\t\\t\\tvar p = 1.0 / ( far - near );\\n\\n\\t\\t\\tvar x = ( right + left ) * w;\\n\\t\\t\\tvar y = ( top + bottom ) * h;\\n\\t\\t\\tvar z = ( far + near ) * p;\\n\\n\\t\\t\\tte[ 0 ] = 2 * w;\\tte[ 4 ] = 0;\\tte[ 8 ] = 0;\\tte[ 12 ] = - x;\\n\\t\\t\\tte[ 1 ] = 0;\\tte[ 5 ] = 2 * h;\\tte[ 9 ] = 0;\\tte[ 13 ] = - y;\\n\\t\\t\\tte[ 2 ] = 0;\\tte[ 6 ] = 0;\\tte[ 10 ] = - 2 * p;\\tte[ 14 ] = - z;\\n\\t\\t\\tte[ 3 ] = 0;\\tte[ 7 ] = 0;\\tte[ 11 ] = 0;\\tte[ 15 ] = 1;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( matrix ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\t\\t\\tvar me = matrix.elements;\\n\\n\\t\\t\\tfor ( var i = 0; i < 16; i ++ ) {\\n\\n\\t\\t\\t\\tif ( te[ i ] !== me[ i ] ) return false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn true;\\n\\n\\t\\t},\\n\\n\\t\\tfromArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tfor ( var i = 0; i < 16; i ++ ) {\\n\\n\\t\\t\\t\\tthis.elements[ i ] = array[ i + offset ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( array === undefined ) array = [];\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tarray[ offset ] = te[ 0 ];\\n\\t\\t\\tarray[ offset + 1 ] = te[ 1 ];\\n\\t\\t\\tarray[ offset + 2 ] = te[ 2 ];\\n\\t\\t\\tarray[ offset + 3 ] = te[ 3 ];\\n\\n\\t\\t\\tarray[ offset + 4 ] = te[ 4 ];\\n\\t\\t\\tarray[ offset + 5 ] = te[ 5 ];\\n\\t\\t\\tarray[ offset + 6 ] = te[ 6 ];\\n\\t\\t\\tarray[ offset + 7 ] = te[ 7 ];\\n\\n\\t\\t\\tarray[ offset + 8 ] = te[ 8 ];\\n\\t\\t\\tarray[ offset + 9 ] = te[ 9 ];\\n\\t\\t\\tarray[ offset + 10 ] = te[ 10 ];\\n\\t\\t\\tarray[ offset + 11 ] = te[ 11 ];\\n\\n\\t\\t\\tarray[ offset + 12 ] = te[ 12 ];\\n\\t\\t\\tarray[ offset + 13 ] = te[ 13 ];\\n\\t\\t\\tarray[ offset + 14 ] = te[ 14 ];\\n\\t\\t\\tarray[ offset + 15 ] = te[ 15 ];\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t * @author bhouston / http://clara.io\\n\\t */\\n\\n\\tfunction Quaternion( x, y, z, w ) {\\n\\n\\t\\tthis._x = x || 0;\\n\\t\\tthis._y = y || 0;\\n\\t\\tthis._z = z || 0;\\n\\t\\tthis._w = ( w !== undefined ) ? w : 1;\\n\\n\\t}\\n\\n\\tObject.assign( Quaternion, {\\n\\n\\t\\tslerp: function ( qa, qb, qm, t ) {\\n\\n\\t\\t\\treturn qm.copy( qa ).slerp( qb, t );\\n\\n\\t\\t},\\n\\n\\t\\tslerpFlat: function ( dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t ) {\\n\\n\\t\\t\\t// fuzz-free, array-based Quaternion SLERP operation\\n\\n\\t\\t\\tvar x0 = src0[ srcOffset0 + 0 ],\\n\\t\\t\\t\\ty0 = src0[ srcOffset0 + 1 ],\\n\\t\\t\\t\\tz0 = src0[ srcOffset0 + 2 ],\\n\\t\\t\\t\\tw0 = src0[ srcOffset0 + 3 ],\\n\\n\\t\\t\\t\\tx1 = src1[ srcOffset1 + 0 ],\\n\\t\\t\\t\\ty1 = src1[ srcOffset1 + 1 ],\\n\\t\\t\\t\\tz1 = src1[ srcOffset1 + 2 ],\\n\\t\\t\\t\\tw1 = src1[ srcOffset1 + 3 ];\\n\\n\\t\\t\\tif ( w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1 ) {\\n\\n\\t\\t\\t\\tvar s = 1 - t,\\n\\n\\t\\t\\t\\t\\tcos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,\\n\\n\\t\\t\\t\\t\\tdir = ( cos >= 0 ? 1 : - 1 ),\\n\\t\\t\\t\\t\\tsqrSin = 1 - cos * cos;\\n\\n\\t\\t\\t\\t// Skip the Slerp for tiny steps to avoid numeric problems:\\n\\t\\t\\t\\tif ( sqrSin > Number.EPSILON ) {\\n\\n\\t\\t\\t\\t\\tvar sin = Math.sqrt( sqrSin ),\\n\\t\\t\\t\\t\\t\\tlen = Math.atan2( sin, cos * dir );\\n\\n\\t\\t\\t\\t\\ts = Math.sin( s * len ) / sin;\\n\\t\\t\\t\\t\\tt = Math.sin( t * len ) / sin;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar tDir = t * dir;\\n\\n\\t\\t\\t\\tx0 = x0 * s + x1 * tDir;\\n\\t\\t\\t\\ty0 = y0 * s + y1 * tDir;\\n\\t\\t\\t\\tz0 = z0 * s + z1 * tDir;\\n\\t\\t\\t\\tw0 = w0 * s + w1 * tDir;\\n\\n\\t\\t\\t\\t// Normalize in case we just did a lerp:\\n\\t\\t\\t\\tif ( s === 1 - t ) {\\n\\n\\t\\t\\t\\t\\tvar f = 1 / Math.sqrt( x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0 );\\n\\n\\t\\t\\t\\t\\tx0 *= f;\\n\\t\\t\\t\\t\\ty0 *= f;\\n\\t\\t\\t\\t\\tz0 *= f;\\n\\t\\t\\t\\t\\tw0 *= f;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tdst[ dstOffset ] = x0;\\n\\t\\t\\tdst[ dstOffset + 1 ] = y0;\\n\\t\\t\\tdst[ dstOffset + 2 ] = z0;\\n\\t\\t\\tdst[ dstOffset + 3 ] = w0;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperties( Quaternion.prototype, {\\n\\n\\t\\tx: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this._x;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis._x = value;\\n\\t\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\ty: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this._y;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis._y = value;\\n\\t\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tz: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this._z;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis._z = value;\\n\\t\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tw: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this._w;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis._w = value;\\n\\t\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Quaternion.prototype, {\\n\\n\\t\\tset: function ( x, y, z, w ) {\\n\\n\\t\\t\\tthis._x = x;\\n\\t\\t\\tthis._y = y;\\n\\t\\t\\tthis._z = z;\\n\\t\\t\\tthis._w = w;\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this._x, this._y, this._z, this._w );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( quaternion ) {\\n\\n\\t\\t\\tthis._x = quaternion.x;\\n\\t\\t\\tthis._y = quaternion.y;\\n\\t\\t\\tthis._z = quaternion.z;\\n\\t\\t\\tthis._w = quaternion.w;\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromEuler: function ( euler, update ) {\\n\\n\\t\\t\\tif ( ! ( euler && euler.isEuler ) ) {\\n\\n\\t\\t\\t\\tthrow new Error( 'THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar x = euler._x, y = euler._y, z = euler._z, order = euler.order;\\n\\n\\t\\t\\t// http://www.mathworks.com/matlabcentral/fileexchange/\\n\\t\\t\\t// \\t20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/\\n\\t\\t\\t//\\tcontent/SpinCalc.m\\n\\n\\t\\t\\tvar cos = Math.cos;\\n\\t\\t\\tvar sin = Math.sin;\\n\\n\\t\\t\\tvar c1 = cos( x / 2 );\\n\\t\\t\\tvar c2 = cos( y / 2 );\\n\\t\\t\\tvar c3 = cos( z / 2 );\\n\\n\\t\\t\\tvar s1 = sin( x / 2 );\\n\\t\\t\\tvar s2 = sin( y / 2 );\\n\\t\\t\\tvar s3 = sin( z / 2 );\\n\\n\\t\\t\\tif ( order === 'XYZ' ) {\\n\\n\\t\\t\\t\\tthis._x = s1 * c2 * c3 + c1 * s2 * s3;\\n\\t\\t\\t\\tthis._y = c1 * s2 * c3 - s1 * c2 * s3;\\n\\t\\t\\t\\tthis._z = c1 * c2 * s3 + s1 * s2 * c3;\\n\\t\\t\\t\\tthis._w = c1 * c2 * c3 - s1 * s2 * s3;\\n\\n\\t\\t\\t} else if ( order === 'YXZ' ) {\\n\\n\\t\\t\\t\\tthis._x = s1 * c2 * c3 + c1 * s2 * s3;\\n\\t\\t\\t\\tthis._y = c1 * s2 * c3 - s1 * c2 * s3;\\n\\t\\t\\t\\tthis._z = c1 * c2 * s3 - s1 * s2 * c3;\\n\\t\\t\\t\\tthis._w = c1 * c2 * c3 + s1 * s2 * s3;\\n\\n\\t\\t\\t} else if ( order === 'ZXY' ) {\\n\\n\\t\\t\\t\\tthis._x = s1 * c2 * c3 - c1 * s2 * s3;\\n\\t\\t\\t\\tthis._y = c1 * s2 * c3 + s1 * c2 * s3;\\n\\t\\t\\t\\tthis._z = c1 * c2 * s3 + s1 * s2 * c3;\\n\\t\\t\\t\\tthis._w = c1 * c2 * c3 - s1 * s2 * s3;\\n\\n\\t\\t\\t} else if ( order === 'ZYX' ) {\\n\\n\\t\\t\\t\\tthis._x = s1 * c2 * c3 - c1 * s2 * s3;\\n\\t\\t\\t\\tthis._y = c1 * s2 * c3 + s1 * c2 * s3;\\n\\t\\t\\t\\tthis._z = c1 * c2 * s3 - s1 * s2 * c3;\\n\\t\\t\\t\\tthis._w = c1 * c2 * c3 + s1 * s2 * s3;\\n\\n\\t\\t\\t} else if ( order === 'YZX' ) {\\n\\n\\t\\t\\t\\tthis._x = s1 * c2 * c3 + c1 * s2 * s3;\\n\\t\\t\\t\\tthis._y = c1 * s2 * c3 + s1 * c2 * s3;\\n\\t\\t\\t\\tthis._z = c1 * c2 * s3 - s1 * s2 * c3;\\n\\t\\t\\t\\tthis._w = c1 * c2 * c3 - s1 * s2 * s3;\\n\\n\\t\\t\\t} else if ( order === 'XZY' ) {\\n\\n\\t\\t\\t\\tthis._x = s1 * c2 * c3 - c1 * s2 * s3;\\n\\t\\t\\t\\tthis._y = c1 * s2 * c3 - s1 * c2 * s3;\\n\\t\\t\\t\\tthis._z = c1 * c2 * s3 + s1 * s2 * c3;\\n\\t\\t\\t\\tthis._w = c1 * c2 * c3 + s1 * s2 * s3;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( update !== false ) this.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromAxisAngle: function ( axis, angle ) {\\n\\n\\t\\t\\t// http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm\\n\\n\\t\\t\\t// assumes axis is normalized\\n\\n\\t\\t\\tvar halfAngle = angle / 2, s = Math.sin( halfAngle );\\n\\n\\t\\t\\tthis._x = axis.x * s;\\n\\t\\t\\tthis._y = axis.y * s;\\n\\t\\t\\tthis._z = axis.z * s;\\n\\t\\t\\tthis._w = Math.cos( halfAngle );\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromRotationMatrix: function ( m ) {\\n\\n\\t\\t\\t// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm\\n\\n\\t\\t\\t// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)\\n\\n\\t\\t\\tvar te = m.elements,\\n\\n\\t\\t\\t\\tm11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],\\n\\t\\t\\t\\tm21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],\\n\\t\\t\\t\\tm31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ],\\n\\n\\t\\t\\t\\ttrace = m11 + m22 + m33,\\n\\t\\t\\t\\ts;\\n\\n\\t\\t\\tif ( trace > 0 ) {\\n\\n\\t\\t\\t\\ts = 0.5 / Math.sqrt( trace + 1.0 );\\n\\n\\t\\t\\t\\tthis._w = 0.25 / s;\\n\\t\\t\\t\\tthis._x = ( m32 - m23 ) * s;\\n\\t\\t\\t\\tthis._y = ( m13 - m31 ) * s;\\n\\t\\t\\t\\tthis._z = ( m21 - m12 ) * s;\\n\\n\\t\\t\\t} else if ( m11 > m22 && m11 > m33 ) {\\n\\n\\t\\t\\t\\ts = 2.0 * Math.sqrt( 1.0 + m11 - m22 - m33 );\\n\\n\\t\\t\\t\\tthis._w = ( m32 - m23 ) / s;\\n\\t\\t\\t\\tthis._x = 0.25 * s;\\n\\t\\t\\t\\tthis._y = ( m12 + m21 ) / s;\\n\\t\\t\\t\\tthis._z = ( m13 + m31 ) / s;\\n\\n\\t\\t\\t} else if ( m22 > m33 ) {\\n\\n\\t\\t\\t\\ts = 2.0 * Math.sqrt( 1.0 + m22 - m11 - m33 );\\n\\n\\t\\t\\t\\tthis._w = ( m13 - m31 ) / s;\\n\\t\\t\\t\\tthis._x = ( m12 + m21 ) / s;\\n\\t\\t\\t\\tthis._y = 0.25 * s;\\n\\t\\t\\t\\tthis._z = ( m23 + m32 ) / s;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\ts = 2.0 * Math.sqrt( 1.0 + m33 - m11 - m22 );\\n\\n\\t\\t\\t\\tthis._w = ( m21 - m12 ) / s;\\n\\t\\t\\t\\tthis._x = ( m13 + m31 ) / s;\\n\\t\\t\\t\\tthis._y = ( m23 + m32 ) / s;\\n\\t\\t\\t\\tthis._z = 0.25 * s;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromUnitVectors: function () {\\n\\n\\t\\t\\t// assumes direction vectors vFrom and vTo are normalized\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\t\\t\\tvar r;\\n\\n\\t\\t\\tvar EPS = 0.000001;\\n\\n\\t\\t\\treturn function setFromUnitVectors( vFrom, vTo ) {\\n\\n\\t\\t\\t\\tif ( v1 === undefined ) v1 = new Vector3();\\n\\n\\t\\t\\t\\tr = vFrom.dot( vTo ) + 1;\\n\\n\\t\\t\\t\\tif ( r < EPS ) {\\n\\n\\t\\t\\t\\t\\tr = 0;\\n\\n\\t\\t\\t\\t\\tif ( Math.abs( vFrom.x ) > Math.abs( vFrom.z ) ) {\\n\\n\\t\\t\\t\\t\\t\\tv1.set( - vFrom.y, vFrom.x, 0 );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tv1.set( 0, - vFrom.z, vFrom.y );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tv1.crossVectors( vFrom, vTo );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis._x = v1.x;\\n\\t\\t\\t\\tthis._y = v1.y;\\n\\t\\t\\t\\tthis._z = v1.z;\\n\\t\\t\\t\\tthis._w = r;\\n\\n\\t\\t\\t\\treturn this.normalize();\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tinverse: function () {\\n\\n\\t\\t\\treturn this.conjugate().normalize();\\n\\n\\t\\t},\\n\\n\\t\\tconjugate: function () {\\n\\n\\t\\t\\tthis._x *= - 1;\\n\\t\\t\\tthis._y *= - 1;\\n\\t\\t\\tthis._z *= - 1;\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdot: function ( v ) {\\n\\n\\t\\t\\treturn this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;\\n\\n\\t\\t},\\n\\n\\t\\tlengthSq: function () {\\n\\n\\t\\t\\treturn this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;\\n\\n\\t\\t},\\n\\n\\t\\tlength: function () {\\n\\n\\t\\t\\treturn Math.sqrt( this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w );\\n\\n\\t\\t},\\n\\n\\t\\tnormalize: function () {\\n\\n\\t\\t\\tvar l = this.length();\\n\\n\\t\\t\\tif ( l === 0 ) {\\n\\n\\t\\t\\t\\tthis._x = 0;\\n\\t\\t\\t\\tthis._y = 0;\\n\\t\\t\\t\\tthis._z = 0;\\n\\t\\t\\t\\tthis._w = 1;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tl = 1 / l;\\n\\n\\t\\t\\t\\tthis._x = this._x * l;\\n\\t\\t\\t\\tthis._y = this._y * l;\\n\\t\\t\\t\\tthis._z = this._z * l;\\n\\t\\t\\t\\tthis._w = this._w * l;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiply: function ( q, p ) {\\n\\n\\t\\t\\tif ( p !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.multiplyQuaternions( q, p );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this.multiplyQuaternions( this, q );\\n\\n\\t\\t},\\n\\n\\t\\tpremultiply: function ( q ) {\\n\\n\\t\\t\\treturn this.multiplyQuaternions( q, this );\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyQuaternions: function ( a, b ) {\\n\\n\\t\\t\\t// from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm\\n\\n\\t\\t\\tvar qax = a._x, qay = a._y, qaz = a._z, qaw = a._w;\\n\\t\\t\\tvar qbx = b._x, qby = b._y, qbz = b._z, qbw = b._w;\\n\\n\\t\\t\\tthis._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;\\n\\t\\t\\tthis._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;\\n\\t\\t\\tthis._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;\\n\\t\\t\\tthis._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tslerp: function ( qb, t ) {\\n\\n\\t\\t\\tif ( t === 0 ) return this;\\n\\t\\t\\tif ( t === 1 ) return this.copy( qb );\\n\\n\\t\\t\\tvar x = this._x, y = this._y, z = this._z, w = this._w;\\n\\n\\t\\t\\t// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/\\n\\n\\t\\t\\tvar cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;\\n\\n\\t\\t\\tif ( cosHalfTheta < 0 ) {\\n\\n\\t\\t\\t\\tthis._w = - qb._w;\\n\\t\\t\\t\\tthis._x = - qb._x;\\n\\t\\t\\t\\tthis._y = - qb._y;\\n\\t\\t\\t\\tthis._z = - qb._z;\\n\\n\\t\\t\\t\\tcosHalfTheta = - cosHalfTheta;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.copy( qb );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( cosHalfTheta >= 1.0 ) {\\n\\n\\t\\t\\t\\tthis._w = w;\\n\\t\\t\\t\\tthis._x = x;\\n\\t\\t\\t\\tthis._y = y;\\n\\t\\t\\t\\tthis._z = z;\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar sinHalfTheta = Math.sqrt( 1.0 - cosHalfTheta * cosHalfTheta );\\n\\n\\t\\t\\tif ( Math.abs( sinHalfTheta ) < 0.001 ) {\\n\\n\\t\\t\\t\\tthis._w = 0.5 * ( w + this._w );\\n\\t\\t\\t\\tthis._x = 0.5 * ( x + this._x );\\n\\t\\t\\t\\tthis._y = 0.5 * ( y + this._y );\\n\\t\\t\\t\\tthis._z = 0.5 * ( z + this._z );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar halfTheta = Math.atan2( sinHalfTheta, cosHalfTheta );\\n\\t\\t\\tvar ratioA = Math.sin( ( 1 - t ) * halfTheta ) / sinHalfTheta,\\n\\t\\t\\t\\tratioB = Math.sin( t * halfTheta ) / sinHalfTheta;\\n\\n\\t\\t\\tthis._w = ( w * ratioA + this._w * ratioB );\\n\\t\\t\\tthis._x = ( x * ratioA + this._x * ratioB );\\n\\t\\t\\tthis._y = ( y * ratioA + this._y * ratioB );\\n\\t\\t\\tthis._z = ( z * ratioA + this._z * ratioB );\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( quaternion ) {\\n\\n\\t\\t\\treturn ( quaternion._x === this._x ) && ( quaternion._y === this._y ) && ( quaternion._z === this._z ) && ( quaternion._w === this._w );\\n\\n\\t\\t},\\n\\n\\t\\tfromArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tthis._x = array[ offset ];\\n\\t\\t\\tthis._y = array[ offset + 1 ];\\n\\t\\t\\tthis._z = array[ offset + 2 ];\\n\\t\\t\\tthis._w = array[ offset + 3 ];\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( array === undefined ) array = [];\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tarray[ offset ] = this._x;\\n\\t\\t\\tarray[ offset + 1 ] = this._y;\\n\\t\\t\\tarray[ offset + 2 ] = this._z;\\n\\t\\t\\tarray[ offset + 3 ] = this._w;\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t},\\n\\n\\t\\tonChange: function ( callback ) {\\n\\n\\t\\t\\tthis.onChangeCallback = callback;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tonChangeCallback: function () {}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author kile / http://kile.stravaganza.org/\\n\\t * @author philogb / http://blog.thejit.org/\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author egraether / http://egraether.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction Vector3( x, y, z ) {\\n\\n\\t\\tthis.x = x || 0;\\n\\t\\tthis.y = y || 0;\\n\\t\\tthis.z = z || 0;\\n\\n\\t}\\n\\n\\tObject.assign( Vector3.prototype, {\\n\\n\\t\\tisVector3: true,\\n\\n\\t\\tset: function ( x, y, z ) {\\n\\n\\t\\t\\tthis.x = x;\\n\\t\\t\\tthis.y = y;\\n\\t\\t\\tthis.z = z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.x = scalar;\\n\\t\\t\\tthis.y = scalar;\\n\\t\\t\\tthis.z = scalar;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetX: function ( x ) {\\n\\n\\t\\t\\tthis.x = x;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetY: function ( y ) {\\n\\n\\t\\t\\tthis.y = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetZ: function ( z ) {\\n\\n\\t\\t\\tthis.z = z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetComponent: function ( index, value ) {\\n\\n\\t\\t\\tswitch ( index ) {\\n\\n\\t\\t\\t\\tcase 0: this.x = value; break;\\n\\t\\t\\t\\tcase 1: this.y = value; break;\\n\\t\\t\\t\\tcase 2: this.z = value; break;\\n\\t\\t\\t\\tdefault: throw new Error( 'index is out of range: ' + index );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetComponent: function ( index ) {\\n\\n\\t\\t\\tswitch ( index ) {\\n\\n\\t\\t\\t\\tcase 0: return this.x;\\n\\t\\t\\t\\tcase 1: return this.y;\\n\\t\\t\\t\\tcase 2: return this.z;\\n\\t\\t\\t\\tdefault: throw new Error( 'index is out of range: ' + index );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.x, this.y, this.z );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( v ) {\\n\\n\\t\\t\\tthis.x = v.x;\\n\\t\\t\\tthis.y = v.y;\\n\\t\\t\\tthis.z = v.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tadd: function ( v, w ) {\\n\\n\\t\\t\\tif ( w !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.addVectors( v, w );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x += v.x;\\n\\t\\t\\tthis.y += v.y;\\n\\t\\t\\tthis.z += v.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddScalar: function ( s ) {\\n\\n\\t\\t\\tthis.x += s;\\n\\t\\t\\tthis.y += s;\\n\\t\\t\\tthis.z += s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddVectors: function ( a, b ) {\\n\\n\\t\\t\\tthis.x = a.x + b.x;\\n\\t\\t\\tthis.y = a.y + b.y;\\n\\t\\t\\tthis.z = a.z + b.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddScaledVector: function ( v, s ) {\\n\\n\\t\\t\\tthis.x += v.x * s;\\n\\t\\t\\tthis.y += v.y * s;\\n\\t\\t\\tthis.z += v.z * s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsub: function ( v, w ) {\\n\\n\\t\\t\\tif ( w !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.subVectors( v, w );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x -= v.x;\\n\\t\\t\\tthis.y -= v.y;\\n\\t\\t\\tthis.z -= v.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsubScalar: function ( s ) {\\n\\n\\t\\t\\tthis.x -= s;\\n\\t\\t\\tthis.y -= s;\\n\\t\\t\\tthis.z -= s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsubVectors: function ( a, b ) {\\n\\n\\t\\t\\tthis.x = a.x - b.x;\\n\\t\\t\\tthis.y = a.y - b.y;\\n\\t\\t\\tthis.z = a.z - b.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiply: function ( v, w ) {\\n\\n\\t\\t\\tif ( w !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.multiplyVectors( v, w );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x *= v.x;\\n\\t\\t\\tthis.y *= v.y;\\n\\t\\t\\tthis.z *= v.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.x *= scalar;\\n\\t\\t\\tthis.y *= scalar;\\n\\t\\t\\tthis.z *= scalar;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyVectors: function ( a, b ) {\\n\\n\\t\\t\\tthis.x = a.x * b.x;\\n\\t\\t\\tthis.y = a.y * b.y;\\n\\t\\t\\tthis.z = a.z * b.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tapplyEuler: function () {\\n\\n\\t\\t\\tvar quaternion = new Quaternion();\\n\\n\\t\\t\\treturn function applyEuler( euler ) {\\n\\n\\t\\t\\t\\tif ( ! ( euler && euler.isEuler ) ) {\\n\\n\\t\\t\\t\\t\\tconsole.error( 'THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order.' );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn this.applyQuaternion( quaternion.setFromEuler( euler ) );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tapplyAxisAngle: function () {\\n\\n\\t\\t\\tvar quaternion = new Quaternion();\\n\\n\\t\\t\\treturn function applyAxisAngle( axis, angle ) {\\n\\n\\t\\t\\t\\treturn this.applyQuaternion( quaternion.setFromAxisAngle( axis, angle ) );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tapplyMatrix3: function ( m ) {\\n\\n\\t\\t\\tvar x = this.x, y = this.y, z = this.z;\\n\\t\\t\\tvar e = m.elements;\\n\\n\\t\\t\\tthis.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ] * z;\\n\\t\\t\\tthis.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ] * z;\\n\\t\\t\\tthis.z = e[ 2 ] * x + e[ 5 ] * y + e[ 8 ] * z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tapplyMatrix4: function ( m ) {\\n\\n\\t\\t\\tvar x = this.x, y = this.y, z = this.z;\\n\\t\\t\\tvar e = m.elements;\\n\\n\\t\\t\\tvar w = 1 / ( e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] );\\n\\n\\t\\t\\tthis.x = ( e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] ) * w;\\n\\t\\t\\tthis.y = ( e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] ) * w;\\n\\t\\t\\tthis.z = ( e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] ) * w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tapplyQuaternion: function ( q ) {\\n\\n\\t\\t\\tvar x = this.x, y = this.y, z = this.z;\\n\\t\\t\\tvar qx = q.x, qy = q.y, qz = q.z, qw = q.w;\\n\\n\\t\\t\\t// calculate quat * vector\\n\\n\\t\\t\\tvar ix = qw * x + qy * z - qz * y;\\n\\t\\t\\tvar iy = qw * y + qz * x - qx * z;\\n\\t\\t\\tvar iz = qw * z + qx * y - qy * x;\\n\\t\\t\\tvar iw = - qx * x - qy * y - qz * z;\\n\\n\\t\\t\\t// calculate result * inverse quat\\n\\n\\t\\t\\tthis.x = ix * qw + iw * - qx + iy * - qz - iz * - qy;\\n\\t\\t\\tthis.y = iy * qw + iw * - qy + iz * - qx - ix * - qz;\\n\\t\\t\\tthis.z = iz * qw + iw * - qz + ix * - qy - iy * - qx;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tproject: function () {\\n\\n\\t\\t\\tvar matrix = new Matrix4();\\n\\n\\t\\t\\treturn function project( camera ) {\\n\\n\\t\\t\\t\\tmatrix.multiplyMatrices( camera.projectionMatrix, matrix.getInverse( camera.matrixWorld ) );\\n\\t\\t\\t\\treturn this.applyMatrix4( matrix );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tunproject: function () {\\n\\n\\t\\t\\tvar matrix = new Matrix4();\\n\\n\\t\\t\\treturn function unproject( camera ) {\\n\\n\\t\\t\\t\\tmatrix.multiplyMatrices( camera.matrixWorld, matrix.getInverse( camera.projectionMatrix ) );\\n\\t\\t\\t\\treturn this.applyMatrix4( matrix );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttransformDirection: function ( m ) {\\n\\n\\t\\t\\t// input: THREE.Matrix4 affine matrix\\n\\t\\t\\t// vector interpreted as a direction\\n\\n\\t\\t\\tvar x = this.x, y = this.y, z = this.z;\\n\\t\\t\\tvar e = m.elements;\\n\\n\\t\\t\\tthis.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z;\\n\\t\\t\\tthis.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z;\\n\\t\\t\\tthis.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z;\\n\\n\\t\\t\\treturn this.normalize();\\n\\n\\t\\t},\\n\\n\\t\\tdivide: function ( v ) {\\n\\n\\t\\t\\tthis.x /= v.x;\\n\\t\\t\\tthis.y /= v.y;\\n\\t\\t\\tthis.z /= v.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdivideScalar: function ( scalar ) {\\n\\n\\t\\t\\treturn this.multiplyScalar( 1 / scalar );\\n\\n\\t\\t},\\n\\n\\t\\tmin: function ( v ) {\\n\\n\\t\\t\\tthis.x = Math.min( this.x, v.x );\\n\\t\\t\\tthis.y = Math.min( this.y, v.y );\\n\\t\\t\\tthis.z = Math.min( this.z, v.z );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmax: function ( v ) {\\n\\n\\t\\t\\tthis.x = Math.max( this.x, v.x );\\n\\t\\t\\tthis.y = Math.max( this.y, v.y );\\n\\t\\t\\tthis.z = Math.max( this.z, v.z );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclamp: function ( min, max ) {\\n\\n\\t\\t\\t// assumes min < max, componentwise\\n\\n\\t\\t\\tthis.x = Math.max( min.x, Math.min( max.x, this.x ) );\\n\\t\\t\\tthis.y = Math.max( min.y, Math.min( max.y, this.y ) );\\n\\t\\t\\tthis.z = Math.max( min.z, Math.min( max.z, this.z ) );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclampScalar: function () {\\n\\n\\t\\t\\tvar min = new Vector3();\\n\\t\\t\\tvar max = new Vector3();\\n\\n\\t\\t\\treturn function clampScalar( minVal, maxVal ) {\\n\\n\\t\\t\\t\\tmin.set( minVal, minVal, minVal );\\n\\t\\t\\t\\tmax.set( maxVal, maxVal, maxVal );\\n\\n\\t\\t\\t\\treturn this.clamp( min, max );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tclampLength: function ( min, max ) {\\n\\n\\t\\t\\tvar length = this.length();\\n\\n\\t\\t\\treturn this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );\\n\\n\\t\\t},\\n\\n\\t\\tfloor: function () {\\n\\n\\t\\t\\tthis.x = Math.floor( this.x );\\n\\t\\t\\tthis.y = Math.floor( this.y );\\n\\t\\t\\tthis.z = Math.floor( this.z );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tceil: function () {\\n\\n\\t\\t\\tthis.x = Math.ceil( this.x );\\n\\t\\t\\tthis.y = Math.ceil( this.y );\\n\\t\\t\\tthis.z = Math.ceil( this.z );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tround: function () {\\n\\n\\t\\t\\tthis.x = Math.round( this.x );\\n\\t\\t\\tthis.y = Math.round( this.y );\\n\\t\\t\\tthis.z = Math.round( this.z );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\troundToZero: function () {\\n\\n\\t\\t\\tthis.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );\\n\\t\\t\\tthis.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );\\n\\t\\t\\tthis.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tnegate: function () {\\n\\n\\t\\t\\tthis.x = - this.x;\\n\\t\\t\\tthis.y = - this.y;\\n\\t\\t\\tthis.z = - this.z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdot: function ( v ) {\\n\\n\\t\\t\\treturn this.x * v.x + this.y * v.y + this.z * v.z;\\n\\n\\t\\t},\\n\\n\\t\\t// TODO lengthSquared?\\n\\n\\t\\tlengthSq: function () {\\n\\n\\t\\t\\treturn this.x * this.x + this.y * this.y + this.z * this.z;\\n\\n\\t\\t},\\n\\n\\t\\tlength: function () {\\n\\n\\t\\t\\treturn Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z );\\n\\n\\t\\t},\\n\\n\\t\\tmanhattanLength: function () {\\n\\n\\t\\t\\treturn Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z );\\n\\n\\t\\t},\\n\\n\\t\\tnormalize: function () {\\n\\n\\t\\t\\treturn this.divideScalar( this.length() || 1 );\\n\\n\\t\\t},\\n\\n\\t\\tsetLength: function ( length ) {\\n\\n\\t\\t\\treturn this.normalize().multiplyScalar( length );\\n\\n\\t\\t},\\n\\n\\t\\tlerp: function ( v, alpha ) {\\n\\n\\t\\t\\tthis.x += ( v.x - this.x ) * alpha;\\n\\t\\t\\tthis.y += ( v.y - this.y ) * alpha;\\n\\t\\t\\tthis.z += ( v.z - this.z ) * alpha;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tlerpVectors: function ( v1, v2, alpha ) {\\n\\n\\t\\t\\treturn this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );\\n\\n\\t\\t},\\n\\n\\t\\tcross: function ( v, w ) {\\n\\n\\t\\t\\tif ( w !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.crossVectors( v, w );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this.crossVectors( this, v );\\n\\n\\t\\t},\\n\\n\\t\\tcrossVectors: function ( a, b ) {\\n\\n\\t\\t\\tvar ax = a.x, ay = a.y, az = a.z;\\n\\t\\t\\tvar bx = b.x, by = b.y, bz = b.z;\\n\\n\\t\\t\\tthis.x = ay * bz - az * by;\\n\\t\\t\\tthis.y = az * bx - ax * bz;\\n\\t\\t\\tthis.z = ax * by - ay * bx;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tprojectOnVector: function ( vector ) {\\n\\n\\t\\t\\tvar scalar = vector.dot( this ) / vector.lengthSq();\\n\\n\\t\\t\\treturn this.copy( vector ).multiplyScalar( scalar );\\n\\n\\t\\t},\\n\\n\\t\\tprojectOnPlane: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function projectOnPlane( planeNormal ) {\\n\\n\\t\\t\\t\\tv1.copy( this ).projectOnVector( planeNormal );\\n\\n\\t\\t\\t\\treturn this.sub( v1 );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\treflect: function () {\\n\\n\\t\\t\\t// reflect incident vector off plane orthogonal to normal\\n\\t\\t\\t// normal is assumed to have unit length\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function reflect( normal ) {\\n\\n\\t\\t\\t\\treturn this.sub( v1.copy( normal ).multiplyScalar( 2 * this.dot( normal ) ) );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tangleTo: function ( v ) {\\n\\n\\t\\t\\tvar theta = this.dot( v ) / ( Math.sqrt( this.lengthSq() * v.lengthSq() ) );\\n\\n\\t\\t\\t// clamp, to handle numerical problems\\n\\n\\t\\t\\treturn Math.acos( _Math.clamp( theta, - 1, 1 ) );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceTo: function ( v ) {\\n\\n\\t\\t\\treturn Math.sqrt( this.distanceToSquared( v ) );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToSquared: function ( v ) {\\n\\n\\t\\t\\tvar dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;\\n\\n\\t\\t\\treturn dx * dx + dy * dy + dz * dz;\\n\\n\\t\\t},\\n\\n\\t\\tmanhattanDistanceTo: function ( v ) {\\n\\n\\t\\t\\treturn Math.abs( this.x - v.x ) + Math.abs( this.y - v.y ) + Math.abs( this.z - v.z );\\n\\n\\t\\t},\\n\\n\\t\\tsetFromSpherical: function ( s ) {\\n\\n\\t\\t\\tvar sinPhiRadius = Math.sin( s.phi ) * s.radius;\\n\\n\\t\\t\\tthis.x = sinPhiRadius * Math.sin( s.theta );\\n\\t\\t\\tthis.y = Math.cos( s.phi ) * s.radius;\\n\\t\\t\\tthis.z = sinPhiRadius * Math.cos( s.theta );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromCylindrical: function ( c ) {\\n\\n\\t\\t\\tthis.x = c.radius * Math.sin( c.theta );\\n\\t\\t\\tthis.y = c.y;\\n\\t\\t\\tthis.z = c.radius * Math.cos( c.theta );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromMatrixPosition: function ( m ) {\\n\\n\\t\\t\\tvar e = m.elements;\\n\\n\\t\\t\\tthis.x = e[ 12 ];\\n\\t\\t\\tthis.y = e[ 13 ];\\n\\t\\t\\tthis.z = e[ 14 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromMatrixScale: function ( m ) {\\n\\n\\t\\t\\tvar sx = this.setFromMatrixColumn( m, 0 ).length();\\n\\t\\t\\tvar sy = this.setFromMatrixColumn( m, 1 ).length();\\n\\t\\t\\tvar sz = this.setFromMatrixColumn( m, 2 ).length();\\n\\n\\t\\t\\tthis.x = sx;\\n\\t\\t\\tthis.y = sy;\\n\\t\\t\\tthis.z = sz;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromMatrixColumn: function ( m, index ) {\\n\\n\\t\\t\\treturn this.fromArray( m.elements, index * 4 );\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( v ) {\\n\\n\\t\\t\\treturn ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) );\\n\\n\\t\\t},\\n\\n\\t\\tfromArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tthis.x = array[ offset ];\\n\\t\\t\\tthis.y = array[ offset + 1 ];\\n\\t\\t\\tthis.z = array[ offset + 2 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( array === undefined ) array = [];\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tarray[ offset ] = this.x;\\n\\t\\t\\tarray[ offset + 1 ] = this.y;\\n\\t\\t\\tarray[ offset + 2 ] = this.z;\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t},\\n\\n\\t\\tfromBufferAttribute: function ( attribute, index, offset ) {\\n\\n\\t\\t\\tif ( offset !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector3: offset has been removed from .fromBufferAttribute().' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x = attribute.getX( index );\\n\\t\\t\\tthis.y = attribute.getY( index );\\n\\t\\t\\tthis.z = attribute.getZ( index );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t * @author bhouston / http://clara.io\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction Matrix3() {\\n\\n\\t\\tthis.elements = [\\n\\n\\t\\t\\t1, 0, 0,\\n\\t\\t\\t0, 1, 0,\\n\\t\\t\\t0, 0, 1\\n\\n\\t\\t];\\n\\n\\t\\tif ( arguments.length > 0 ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.' );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tObject.assign( Matrix3.prototype, {\\n\\n\\t\\tisMatrix3: true,\\n\\n\\t\\tset: function ( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tte[ 0 ] = n11; te[ 1 ] = n21; te[ 2 ] = n31;\\n\\t\\t\\tte[ 3 ] = n12; te[ 4 ] = n22; te[ 5 ] = n32;\\n\\t\\t\\tte[ 6 ] = n13; te[ 7 ] = n23; te[ 8 ] = n33;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tidentity: function () {\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\t1, 0, 0,\\n\\t\\t\\t\\t0, 1, 0,\\n\\t\\t\\t\\t0, 0, 1\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().fromArray( this.elements );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( m ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\t\\t\\tvar me = m.elements;\\n\\n\\t\\t\\tte[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ];\\n\\t\\t\\tte[ 3 ] = me[ 3 ]; te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ];\\n\\t\\t\\tte[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ]; te[ 8 ] = me[ 8 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromMatrix4: function ( m ) {\\n\\n\\t\\t\\tvar me = m.elements;\\n\\n\\t\\t\\tthis.set(\\n\\n\\t\\t\\t\\tme[ 0 ], me[ 4 ], me[ 8 ],\\n\\t\\t\\t\\tme[ 1 ], me[ 5 ], me[ 9 ],\\n\\t\\t\\t\\tme[ 2 ], me[ 6 ], me[ 10 ]\\n\\n\\t\\t\\t);\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tapplyToBufferAttribute: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function applyToBufferAttribute( attribute ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = attribute.count; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tv1.x = attribute.getX( i );\\n\\t\\t\\t\\t\\tv1.y = attribute.getY( i );\\n\\t\\t\\t\\t\\tv1.z = attribute.getZ( i );\\n\\n\\t\\t\\t\\t\\tv1.applyMatrix3( this );\\n\\n\\t\\t\\t\\t\\tattribute.setXYZ( i, v1.x, v1.y, v1.z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn attribute;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tmultiply: function ( m ) {\\n\\n\\t\\t\\treturn this.multiplyMatrices( this, m );\\n\\n\\t\\t},\\n\\n\\t\\tpremultiply: function ( m ) {\\n\\n\\t\\t\\treturn this.multiplyMatrices( m, this );\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyMatrices: function ( a, b ) {\\n\\n\\t\\t\\tvar ae = a.elements;\\n\\t\\t\\tvar be = b.elements;\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tvar a11 = ae[ 0 ], a12 = ae[ 3 ], a13 = ae[ 6 ];\\n\\t\\t\\tvar a21 = ae[ 1 ], a22 = ae[ 4 ], a23 = ae[ 7 ];\\n\\t\\t\\tvar a31 = ae[ 2 ], a32 = ae[ 5 ], a33 = ae[ 8 ];\\n\\n\\t\\t\\tvar b11 = be[ 0 ], b12 = be[ 3 ], b13 = be[ 6 ];\\n\\t\\t\\tvar b21 = be[ 1 ], b22 = be[ 4 ], b23 = be[ 7 ];\\n\\t\\t\\tvar b31 = be[ 2 ], b32 = be[ 5 ], b33 = be[ 8 ];\\n\\n\\t\\t\\tte[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31;\\n\\t\\t\\tte[ 3 ] = a11 * b12 + a12 * b22 + a13 * b32;\\n\\t\\t\\tte[ 6 ] = a11 * b13 + a12 * b23 + a13 * b33;\\n\\n\\t\\t\\tte[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31;\\n\\t\\t\\tte[ 4 ] = a21 * b12 + a22 * b22 + a23 * b32;\\n\\t\\t\\tte[ 7 ] = a21 * b13 + a22 * b23 + a23 * b33;\\n\\n\\t\\t\\tte[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31;\\n\\t\\t\\tte[ 5 ] = a31 * b12 + a32 * b22 + a33 * b32;\\n\\t\\t\\tte[ 8 ] = a31 * b13 + a32 * b23 + a33 * b33;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyScalar: function ( s ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tte[ 0 ] *= s; te[ 3 ] *= s; te[ 6 ] *= s;\\n\\t\\t\\tte[ 1 ] *= s; te[ 4 ] *= s; te[ 7 ] *= s;\\n\\t\\t\\tte[ 2 ] *= s; te[ 5 ] *= s; te[ 8 ] *= s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdeterminant: function () {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tvar a = te[ 0 ], b = te[ 1 ], c = te[ 2 ],\\n\\t\\t\\t\\td = te[ 3 ], e = te[ 4 ], f = te[ 5 ],\\n\\t\\t\\t\\tg = te[ 6 ], h = te[ 7 ], i = te[ 8 ];\\n\\n\\t\\t\\treturn a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g;\\n\\n\\t\\t},\\n\\n\\t\\tgetInverse: function ( matrix, throwOnDegenerate ) {\\n\\n\\t\\t\\tif ( matrix && matrix.isMatrix4 ) {\\n\\n\\t\\t\\t\\tconsole.error( \\\"THREE.Matrix3: .getInverse() no longer takes a Matrix4 argument.\\\" );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar me = matrix.elements,\\n\\t\\t\\t\\tte = this.elements,\\n\\n\\t\\t\\t\\tn11 = me[ 0 ], n21 = me[ 1 ], n31 = me[ 2 ],\\n\\t\\t\\t\\tn12 = me[ 3 ], n22 = me[ 4 ], n32 = me[ 5 ],\\n\\t\\t\\t\\tn13 = me[ 6 ], n23 = me[ 7 ], n33 = me[ 8 ],\\n\\n\\t\\t\\t\\tt11 = n33 * n22 - n32 * n23,\\n\\t\\t\\t\\tt12 = n32 * n13 - n33 * n12,\\n\\t\\t\\t\\tt13 = n23 * n12 - n22 * n13,\\n\\n\\t\\t\\t\\tdet = n11 * t11 + n21 * t12 + n31 * t13;\\n\\n\\t\\t\\tif ( det === 0 ) {\\n\\n\\t\\t\\t\\tvar msg = \\\"THREE.Matrix3: .getInverse() can't invert matrix, determinant is 0\\\";\\n\\n\\t\\t\\t\\tif ( throwOnDegenerate === true ) {\\n\\n\\t\\t\\t\\t\\tthrow new Error( msg );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tconsole.warn( msg );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn this.identity();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar detInv = 1 / det;\\n\\n\\t\\t\\tte[ 0 ] = t11 * detInv;\\n\\t\\t\\tte[ 1 ] = ( n31 * n23 - n33 * n21 ) * detInv;\\n\\t\\t\\tte[ 2 ] = ( n32 * n21 - n31 * n22 ) * detInv;\\n\\n\\t\\t\\tte[ 3 ] = t12 * detInv;\\n\\t\\t\\tte[ 4 ] = ( n33 * n11 - n31 * n13 ) * detInv;\\n\\t\\t\\tte[ 5 ] = ( n31 * n12 - n32 * n11 ) * detInv;\\n\\n\\t\\t\\tte[ 6 ] = t13 * detInv;\\n\\t\\t\\tte[ 7 ] = ( n21 * n13 - n23 * n11 ) * detInv;\\n\\t\\t\\tte[ 8 ] = ( n22 * n11 - n21 * n12 ) * detInv;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttranspose: function () {\\n\\n\\t\\t\\tvar tmp, m = this.elements;\\n\\n\\t\\t\\ttmp = m[ 1 ]; m[ 1 ] = m[ 3 ]; m[ 3 ] = tmp;\\n\\t\\t\\ttmp = m[ 2 ]; m[ 2 ] = m[ 6 ]; m[ 6 ] = tmp;\\n\\t\\t\\ttmp = m[ 5 ]; m[ 5 ] = m[ 7 ]; m[ 7 ] = tmp;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetNormalMatrix: function ( matrix4 ) {\\n\\n\\t\\t\\treturn this.setFromMatrix4( matrix4 ).getInverse( this ).transpose();\\n\\n\\t\\t},\\n\\n\\t\\ttransposeIntoArray: function ( r ) {\\n\\n\\t\\t\\tvar m = this.elements;\\n\\n\\t\\t\\tr[ 0 ] = m[ 0 ];\\n\\t\\t\\tr[ 1 ] = m[ 3 ];\\n\\t\\t\\tr[ 2 ] = m[ 6 ];\\n\\t\\t\\tr[ 3 ] = m[ 1 ];\\n\\t\\t\\tr[ 4 ] = m[ 4 ];\\n\\t\\t\\tr[ 5 ] = m[ 7 ];\\n\\t\\t\\tr[ 6 ] = m[ 2 ];\\n\\t\\t\\tr[ 7 ] = m[ 5 ];\\n\\t\\t\\tr[ 8 ] = m[ 8 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetUvTransform: function ( tx, ty, sx, sy, rotation, cx, cy ) {\\n\\n\\t\\t\\tvar c = Math.cos( rotation );\\n\\t\\t\\tvar s = Math.sin( rotation );\\n\\n\\t\\t\\tthis.set(\\n\\t\\t\\t\\tsx * c, sx * s, - sx * ( c * cx + s * cy ) + cx + tx,\\n\\t\\t\\t\\t- sy * s, sy * c, - sy * ( - s * cx + c * cy ) + cy + ty,\\n\\t\\t\\t\\t0, 0, 1\\n\\t\\t\\t);\\n\\n\\t\\t},\\n\\n\\t\\tscale: function ( sx, sy ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tte[ 0 ] *= sx; te[ 3 ] *= sx; te[ 6 ] *= sx;\\n\\t\\t\\tte[ 1 ] *= sy; te[ 4 ] *= sy; te[ 7 ] *= sy;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\trotate: function ( theta ) {\\n\\n\\t\\t\\tvar c = Math.cos( theta );\\n\\t\\t\\tvar s = Math.sin( theta );\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tvar a11 = te[ 0 ], a12 = te[ 3 ], a13 = te[ 6 ];\\n\\t\\t\\tvar a21 = te[ 1 ], a22 = te[ 4 ], a23 = te[ 7 ];\\n\\n\\t\\t\\tte[ 0 ] = c * a11 + s * a21;\\n\\t\\t\\tte[ 3 ] = c * a12 + s * a22;\\n\\t\\t\\tte[ 6 ] = c * a13 + s * a23;\\n\\n\\t\\t\\tte[ 1 ] = - s * a11 + c * a21;\\n\\t\\t\\tte[ 4 ] = - s * a12 + c * a22;\\n\\t\\t\\tte[ 7 ] = - s * a13 + c * a23;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttranslate: function ( tx, ty ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tte[ 0 ] += tx * te[ 2 ]; te[ 3 ] += tx * te[ 5 ]; te[ 6 ] += tx * te[ 8 ];\\n\\t\\t\\tte[ 1 ] += ty * te[ 2 ]; te[ 4 ] += ty * te[ 5 ]; te[ 7 ] += ty * te[ 8 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( matrix ) {\\n\\n\\t\\t\\tvar te = this.elements;\\n\\t\\t\\tvar me = matrix.elements;\\n\\n\\t\\t\\tfor ( var i = 0; i < 9; i ++ ) {\\n\\n\\t\\t\\t\\tif ( te[ i ] !== me[ i ] ) return false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn true;\\n\\n\\t\\t},\\n\\n\\t\\tfromArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tfor ( var i = 0; i < 9; i ++ ) {\\n\\n\\t\\t\\t\\tthis.elements[ i ] = array[ i + offset ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( array === undefined ) array = [];\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tvar te = this.elements;\\n\\n\\t\\t\\tarray[ offset ] = te[ 0 ];\\n\\t\\t\\tarray[ offset + 1 ] = te[ 1 ];\\n\\t\\t\\tarray[ offset + 2 ] = te[ 2 ];\\n\\n\\t\\t\\tarray[ offset + 3 ] = te[ 3 ];\\n\\t\\t\\tarray[ offset + 4 ] = te[ 4 ];\\n\\t\\t\\tarray[ offset + 5 ] = te[ 5 ];\\n\\n\\t\\t\\tarray[ offset + 6 ] = te[ 6 ];\\n\\t\\t\\tarray[ offset + 7 ] = te[ 7 ];\\n\\t\\t\\tarray[ offset + 8 ] = te[ 8 ];\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author szimek / https://github.com/szimek/\\n\\t */\\n\\n\\tvar textureId = 0;\\n\\n\\tfunction Texture( image, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding ) {\\n\\n\\t\\tObject.defineProperty( this, 'id', { value: textureId ++ } );\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.name = '';\\n\\n\\t\\tthis.image = image !== undefined ? image : Texture.DEFAULT_IMAGE;\\n\\t\\tthis.mipmaps = [];\\n\\n\\t\\tthis.mapping = mapping !== undefined ? mapping : Texture.DEFAULT_MAPPING;\\n\\n\\t\\tthis.wrapS = wrapS !== undefined ? wrapS : ClampToEdgeWrapping;\\n\\t\\tthis.wrapT = wrapT !== undefined ? wrapT : ClampToEdgeWrapping;\\n\\n\\t\\tthis.magFilter = magFilter !== undefined ? magFilter : LinearFilter;\\n\\t\\tthis.minFilter = minFilter !== undefined ? minFilter : LinearMipMapLinearFilter;\\n\\n\\t\\tthis.anisotropy = anisotropy !== undefined ? anisotropy : 1;\\n\\n\\t\\tthis.format = format !== undefined ? format : RGBAFormat;\\n\\t\\tthis.type = type !== undefined ? type : UnsignedByteType;\\n\\n\\t\\tthis.offset = new Vector2( 0, 0 );\\n\\t\\tthis.repeat = new Vector2( 1, 1 );\\n\\t\\tthis.center = new Vector2( 0, 0 );\\n\\t\\tthis.rotation = 0;\\n\\n\\t\\tthis.matrixAutoUpdate = true;\\n\\t\\tthis.matrix = new Matrix3();\\n\\n\\t\\tthis.generateMipmaps = true;\\n\\t\\tthis.premultiplyAlpha = false;\\n\\t\\tthis.flipY = true;\\n\\t\\tthis.unpackAlignment = 4;\\t// valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)\\n\\n\\t\\t// Values of encoding !== THREE.LinearEncoding only supported on map, envMap and emissiveMap.\\n\\t\\t//\\n\\t\\t// Also changing the encoding after already used by a Material will not automatically make the Material\\n\\t\\t// update.  You need to explicitly call Material.needsUpdate to trigger it to recompile.\\n\\t\\tthis.encoding = encoding !== undefined ? encoding : LinearEncoding;\\n\\n\\t\\tthis.version = 0;\\n\\t\\tthis.onUpdate = null;\\n\\n\\t}\\n\\n\\tTexture.DEFAULT_IMAGE = undefined;\\n\\tTexture.DEFAULT_MAPPING = UVMapping;\\n\\n\\tTexture.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {\\n\\n\\t\\tconstructor: Texture,\\n\\n\\t\\tisTexture: true,\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tthis.name = source.name;\\n\\n\\t\\t\\tthis.image = source.image;\\n\\t\\t\\tthis.mipmaps = source.mipmaps.slice( 0 );\\n\\n\\t\\t\\tthis.mapping = source.mapping;\\n\\n\\t\\t\\tthis.wrapS = source.wrapS;\\n\\t\\t\\tthis.wrapT = source.wrapT;\\n\\n\\t\\t\\tthis.magFilter = source.magFilter;\\n\\t\\t\\tthis.minFilter = source.minFilter;\\n\\n\\t\\t\\tthis.anisotropy = source.anisotropy;\\n\\n\\t\\t\\tthis.format = source.format;\\n\\t\\t\\tthis.type = source.type;\\n\\n\\t\\t\\tthis.offset.copy( source.offset );\\n\\t\\t\\tthis.repeat.copy( source.repeat );\\n\\t\\t\\tthis.center.copy( source.center );\\n\\t\\t\\tthis.rotation = source.rotation;\\n\\n\\t\\t\\tthis.matrixAutoUpdate = source.matrixAutoUpdate;\\n\\t\\t\\tthis.matrix.copy( source.matrix );\\n\\n\\t\\t\\tthis.generateMipmaps = source.generateMipmaps;\\n\\t\\t\\tthis.premultiplyAlpha = source.premultiplyAlpha;\\n\\t\\t\\tthis.flipY = source.flipY;\\n\\t\\t\\tthis.unpackAlignment = source.unpackAlignment;\\n\\t\\t\\tthis.encoding = source.encoding;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\tvar isRootObject = ( meta === undefined || typeof meta === 'string' );\\n\\n\\t\\t\\tif ( ! isRootObject && meta.textures[ this.uuid ] !== undefined ) {\\n\\n\\t\\t\\t\\treturn meta.textures[ this.uuid ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction getDataURL( image ) {\\n\\n\\t\\t\\t\\tvar canvas;\\n\\n\\t\\t\\t\\tif ( image instanceof HTMLCanvasElement ) {\\n\\n\\t\\t\\t\\t\\tcanvas = image;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tcanvas = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' );\\n\\t\\t\\t\\t\\tcanvas.width = image.width;\\n\\t\\t\\t\\t\\tcanvas.height = image.height;\\n\\n\\t\\t\\t\\t\\tvar context = canvas.getContext( '2d' );\\n\\n\\t\\t\\t\\t\\tif ( image instanceof ImageData ) {\\n\\n\\t\\t\\t\\t\\t\\tcontext.putImageData( image, 0, 0 );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tcontext.drawImage( image, 0, 0, image.width, image.height );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( canvas.width > 2048 || canvas.height > 2048 ) {\\n\\n\\t\\t\\t\\t\\treturn canvas.toDataURL( 'image/jpeg', 0.6 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\treturn canvas.toDataURL( 'image/png' );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar output = {\\n\\t\\t\\t\\tmetadata: {\\n\\t\\t\\t\\t\\tversion: 4.5,\\n\\t\\t\\t\\t\\ttype: 'Texture',\\n\\t\\t\\t\\t\\tgenerator: 'Texture.toJSON'\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tuuid: this.uuid,\\n\\t\\t\\t\\tname: this.name,\\n\\n\\t\\t\\t\\tmapping: this.mapping,\\n\\n\\t\\t\\t\\trepeat: [ this.repeat.x, this.repeat.y ],\\n\\t\\t\\t\\toffset: [ this.offset.x, this.offset.y ],\\n\\t\\t\\t\\tcenter: [ this.center.x, this.center.y ],\\n\\t\\t\\t\\trotation: this.rotation,\\n\\n\\t\\t\\t\\twrap: [ this.wrapS, this.wrapT ],\\n\\n\\t\\t\\t\\tminFilter: this.minFilter,\\n\\t\\t\\t\\tmagFilter: this.magFilter,\\n\\t\\t\\t\\tanisotropy: this.anisotropy,\\n\\n\\t\\t\\t\\tflipY: this.flipY\\n\\t\\t\\t};\\n\\n\\t\\t\\tif ( this.image !== undefined ) {\\n\\n\\t\\t\\t\\t// TODO: Move to THREE.Image\\n\\n\\t\\t\\t\\tvar image = this.image;\\n\\n\\t\\t\\t\\tif ( image.uuid === undefined ) {\\n\\n\\t\\t\\t\\t\\timage.uuid = _Math.generateUUID(); // UGH\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( ! isRootObject && meta.images[ image.uuid ] === undefined ) {\\n\\n\\t\\t\\t\\t\\tmeta.images[ image.uuid ] = {\\n\\t\\t\\t\\t\\t\\tuuid: image.uuid,\\n\\t\\t\\t\\t\\t\\turl: getDataURL( image )\\n\\t\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\toutput.image = image.uuid;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( ! isRootObject ) {\\n\\n\\t\\t\\t\\tmeta.textures[ this.uuid ] = output;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn output;\\n\\n\\t\\t},\\n\\n\\t\\tdispose: function () {\\n\\n\\t\\t\\tthis.dispatchEvent( { type: 'dispose' } );\\n\\n\\t\\t},\\n\\n\\t\\ttransformUv: function ( uv ) {\\n\\n\\t\\t\\tif ( this.mapping !== UVMapping ) return;\\n\\n\\t\\t\\tuv.applyMatrix3( this.matrix );\\n\\n\\t\\t\\tif ( uv.x < 0 || uv.x > 1 ) {\\n\\n\\t\\t\\t\\tswitch ( this.wrapS ) {\\n\\n\\t\\t\\t\\t\\tcase RepeatWrapping:\\n\\n\\t\\t\\t\\t\\t\\tuv.x = uv.x - Math.floor( uv.x );\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase ClampToEdgeWrapping:\\n\\n\\t\\t\\t\\t\\t\\tuv.x = uv.x < 0 ? 0 : 1;\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase MirroredRepeatWrapping:\\n\\n\\t\\t\\t\\t\\t\\tif ( Math.abs( Math.floor( uv.x ) % 2 ) === 1 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tuv.x = Math.ceil( uv.x ) - uv.x;\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tuv.x = uv.x - Math.floor( uv.x );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( uv.y < 0 || uv.y > 1 ) {\\n\\n\\t\\t\\t\\tswitch ( this.wrapT ) {\\n\\n\\t\\t\\t\\t\\tcase RepeatWrapping:\\n\\n\\t\\t\\t\\t\\t\\tuv.y = uv.y - Math.floor( uv.y );\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase ClampToEdgeWrapping:\\n\\n\\t\\t\\t\\t\\t\\tuv.y = uv.y < 0 ? 0 : 1;\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase MirroredRepeatWrapping:\\n\\n\\t\\t\\t\\t\\t\\tif ( Math.abs( Math.floor( uv.y ) % 2 ) === 1 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tuv.y = Math.ceil( uv.y ) - uv.y;\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tuv.y = uv.y - Math.floor( uv.y );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.flipY ) {\\n\\n\\t\\t\\t\\tuv.y = 1 - uv.y;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperty( Texture.prototype, \\\"needsUpdate\\\", {\\n\\n\\t\\tset: function ( value ) {\\n\\n\\t\\t\\tif ( value === true ) this.version ++;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author supereggbert / http://www.paulbrunt.co.uk/\\n\\t * @author philogb / http://blog.thejit.org/\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author egraether / http://egraether.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction Vector4( x, y, z, w ) {\\n\\n\\t\\tthis.x = x || 0;\\n\\t\\tthis.y = y || 0;\\n\\t\\tthis.z = z || 0;\\n\\t\\tthis.w = ( w !== undefined ) ? w : 1;\\n\\n\\t}\\n\\n\\tObject.assign( Vector4.prototype, {\\n\\n\\t\\tisVector4: true,\\n\\n\\t\\tset: function ( x, y, z, w ) {\\n\\n\\t\\t\\tthis.x = x;\\n\\t\\t\\tthis.y = y;\\n\\t\\t\\tthis.z = z;\\n\\t\\t\\tthis.w = w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.x = scalar;\\n\\t\\t\\tthis.y = scalar;\\n\\t\\t\\tthis.z = scalar;\\n\\t\\t\\tthis.w = scalar;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetX: function ( x ) {\\n\\n\\t\\t\\tthis.x = x;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetY: function ( y ) {\\n\\n\\t\\t\\tthis.y = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetZ: function ( z ) {\\n\\n\\t\\t\\tthis.z = z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetW: function ( w ) {\\n\\n\\t\\t\\tthis.w = w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetComponent: function ( index, value ) {\\n\\n\\t\\t\\tswitch ( index ) {\\n\\n\\t\\t\\t\\tcase 0: this.x = value; break;\\n\\t\\t\\t\\tcase 1: this.y = value; break;\\n\\t\\t\\t\\tcase 2: this.z = value; break;\\n\\t\\t\\t\\tcase 3: this.w = value; break;\\n\\t\\t\\t\\tdefault: throw new Error( 'index is out of range: ' + index );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetComponent: function ( index ) {\\n\\n\\t\\t\\tswitch ( index ) {\\n\\n\\t\\t\\t\\tcase 0: return this.x;\\n\\t\\t\\t\\tcase 1: return this.y;\\n\\t\\t\\t\\tcase 2: return this.z;\\n\\t\\t\\t\\tcase 3: return this.w;\\n\\t\\t\\t\\tdefault: throw new Error( 'index is out of range: ' + index );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.x, this.y, this.z, this.w );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( v ) {\\n\\n\\t\\t\\tthis.x = v.x;\\n\\t\\t\\tthis.y = v.y;\\n\\t\\t\\tthis.z = v.z;\\n\\t\\t\\tthis.w = ( v.w !== undefined ) ? v.w : 1;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tadd: function ( v, w ) {\\n\\n\\t\\t\\tif ( w !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.addVectors( v, w );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x += v.x;\\n\\t\\t\\tthis.y += v.y;\\n\\t\\t\\tthis.z += v.z;\\n\\t\\t\\tthis.w += v.w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddScalar: function ( s ) {\\n\\n\\t\\t\\tthis.x += s;\\n\\t\\t\\tthis.y += s;\\n\\t\\t\\tthis.z += s;\\n\\t\\t\\tthis.w += s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddVectors: function ( a, b ) {\\n\\n\\t\\t\\tthis.x = a.x + b.x;\\n\\t\\t\\tthis.y = a.y + b.y;\\n\\t\\t\\tthis.z = a.z + b.z;\\n\\t\\t\\tthis.w = a.w + b.w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddScaledVector: function ( v, s ) {\\n\\n\\t\\t\\tthis.x += v.x * s;\\n\\t\\t\\tthis.y += v.y * s;\\n\\t\\t\\tthis.z += v.z * s;\\n\\t\\t\\tthis.w += v.w * s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsub: function ( v, w ) {\\n\\n\\t\\t\\tif ( w !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );\\n\\t\\t\\t\\treturn this.subVectors( v, w );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x -= v.x;\\n\\t\\t\\tthis.y -= v.y;\\n\\t\\t\\tthis.z -= v.z;\\n\\t\\t\\tthis.w -= v.w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsubScalar: function ( s ) {\\n\\n\\t\\t\\tthis.x -= s;\\n\\t\\t\\tthis.y -= s;\\n\\t\\t\\tthis.z -= s;\\n\\t\\t\\tthis.w -= s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsubVectors: function ( a, b ) {\\n\\n\\t\\t\\tthis.x = a.x - b.x;\\n\\t\\t\\tthis.y = a.y - b.y;\\n\\t\\t\\tthis.z = a.z - b.z;\\n\\t\\t\\tthis.w = a.w - b.w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.x *= scalar;\\n\\t\\t\\tthis.y *= scalar;\\n\\t\\t\\tthis.z *= scalar;\\n\\t\\t\\tthis.w *= scalar;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tapplyMatrix4: function ( m ) {\\n\\n\\t\\t\\tvar x = this.x, y = this.y, z = this.z, w = this.w;\\n\\t\\t\\tvar e = m.elements;\\n\\n\\t\\t\\tthis.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] * w;\\n\\t\\t\\tthis.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] * w;\\n\\t\\t\\tthis.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] * w;\\n\\t\\t\\tthis.w = e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] * w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdivideScalar: function ( scalar ) {\\n\\n\\t\\t\\treturn this.multiplyScalar( 1 / scalar );\\n\\n\\t\\t},\\n\\n\\t\\tsetAxisAngleFromQuaternion: function ( q ) {\\n\\n\\t\\t\\t// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm\\n\\n\\t\\t\\t// q is assumed to be normalized\\n\\n\\t\\t\\tthis.w = 2 * Math.acos( q.w );\\n\\n\\t\\t\\tvar s = Math.sqrt( 1 - q.w * q.w );\\n\\n\\t\\t\\tif ( s < 0.0001 ) {\\n\\n\\t\\t\\t\\tthis.x = 1;\\n\\t\\t\\t\\tthis.y = 0;\\n\\t\\t\\t\\tthis.z = 0;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.x = q.x / s;\\n\\t\\t\\t\\tthis.y = q.y / s;\\n\\t\\t\\t\\tthis.z = q.z / s;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetAxisAngleFromRotationMatrix: function ( m ) {\\n\\n\\t\\t\\t// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm\\n\\n\\t\\t\\t// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)\\n\\n\\t\\t\\tvar angle, x, y, z,\\t\\t// variables for result\\n\\t\\t\\t\\tepsilon = 0.01,\\t\\t// margin to allow for rounding errors\\n\\t\\t\\t\\tepsilon2 = 0.1,\\t\\t// margin to distinguish between 0 and 180 degrees\\n\\n\\t\\t\\t\\tte = m.elements,\\n\\n\\t\\t\\t\\tm11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],\\n\\t\\t\\t\\tm21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],\\n\\t\\t\\t\\tm31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];\\n\\n\\t\\t\\tif ( ( Math.abs( m12 - m21 ) < epsilon ) &&\\n\\t\\t\\t     ( Math.abs( m13 - m31 ) < epsilon ) &&\\n\\t\\t\\t     ( Math.abs( m23 - m32 ) < epsilon ) ) {\\n\\n\\t\\t\\t\\t// singularity found\\n\\t\\t\\t\\t// first check for identity matrix which must have +1 for all terms\\n\\t\\t\\t\\t// in leading diagonal and zero in other terms\\n\\n\\t\\t\\t\\tif ( ( Math.abs( m12 + m21 ) < epsilon2 ) &&\\n\\t\\t\\t\\t     ( Math.abs( m13 + m31 ) < epsilon2 ) &&\\n\\t\\t\\t\\t     ( Math.abs( m23 + m32 ) < epsilon2 ) &&\\n\\t\\t\\t\\t     ( Math.abs( m11 + m22 + m33 - 3 ) < epsilon2 ) ) {\\n\\n\\t\\t\\t\\t\\t// this singularity is identity matrix so angle = 0\\n\\n\\t\\t\\t\\t\\tthis.set( 1, 0, 0, 0 );\\n\\n\\t\\t\\t\\t\\treturn this; // zero angle, arbitrary axis\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// otherwise this singularity is angle = 180\\n\\n\\t\\t\\t\\tangle = Math.PI;\\n\\n\\t\\t\\t\\tvar xx = ( m11 + 1 ) / 2;\\n\\t\\t\\t\\tvar yy = ( m22 + 1 ) / 2;\\n\\t\\t\\t\\tvar zz = ( m33 + 1 ) / 2;\\n\\t\\t\\t\\tvar xy = ( m12 + m21 ) / 4;\\n\\t\\t\\t\\tvar xz = ( m13 + m31 ) / 4;\\n\\t\\t\\t\\tvar yz = ( m23 + m32 ) / 4;\\n\\n\\t\\t\\t\\tif ( ( xx > yy ) && ( xx > zz ) ) {\\n\\n\\t\\t\\t\\t\\t// m11 is the largest diagonal term\\n\\n\\t\\t\\t\\t\\tif ( xx < epsilon ) {\\n\\n\\t\\t\\t\\t\\t\\tx = 0;\\n\\t\\t\\t\\t\\t\\ty = 0.707106781;\\n\\t\\t\\t\\t\\t\\tz = 0.707106781;\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tx = Math.sqrt( xx );\\n\\t\\t\\t\\t\\t\\ty = xy / x;\\n\\t\\t\\t\\t\\t\\tz = xz / x;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( yy > zz ) {\\n\\n\\t\\t\\t\\t\\t// m22 is the largest diagonal term\\n\\n\\t\\t\\t\\t\\tif ( yy < epsilon ) {\\n\\n\\t\\t\\t\\t\\t\\tx = 0.707106781;\\n\\t\\t\\t\\t\\t\\ty = 0;\\n\\t\\t\\t\\t\\t\\tz = 0.707106781;\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\ty = Math.sqrt( yy );\\n\\t\\t\\t\\t\\t\\tx = xy / y;\\n\\t\\t\\t\\t\\t\\tz = yz / y;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// m33 is the largest diagonal term so base result on this\\n\\n\\t\\t\\t\\t\\tif ( zz < epsilon ) {\\n\\n\\t\\t\\t\\t\\t\\tx = 0.707106781;\\n\\t\\t\\t\\t\\t\\ty = 0.707106781;\\n\\t\\t\\t\\t\\t\\tz = 0;\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tz = Math.sqrt( zz );\\n\\t\\t\\t\\t\\t\\tx = xz / z;\\n\\t\\t\\t\\t\\t\\ty = yz / z;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.set( x, y, z, angle );\\n\\n\\t\\t\\t\\treturn this; // return 180 deg rotation\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// as we have reached here there are no singularities so we can handle normally\\n\\n\\t\\t\\tvar s = Math.sqrt( ( m32 - m23 ) * ( m32 - m23 ) +\\n\\t\\t\\t                   ( m13 - m31 ) * ( m13 - m31 ) +\\n\\t\\t\\t                   ( m21 - m12 ) * ( m21 - m12 ) ); // used to normalize\\n\\n\\t\\t\\tif ( Math.abs( s ) < 0.001 ) s = 1;\\n\\n\\t\\t\\t// prevent divide by zero, should not happen if matrix is orthogonal and should be\\n\\t\\t\\t// caught by singularity test above, but I've left it in just in case\\n\\n\\t\\t\\tthis.x = ( m32 - m23 ) / s;\\n\\t\\t\\tthis.y = ( m13 - m31 ) / s;\\n\\t\\t\\tthis.z = ( m21 - m12 ) / s;\\n\\t\\t\\tthis.w = Math.acos( ( m11 + m22 + m33 - 1 ) / 2 );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmin: function ( v ) {\\n\\n\\t\\t\\tthis.x = Math.min( this.x, v.x );\\n\\t\\t\\tthis.y = Math.min( this.y, v.y );\\n\\t\\t\\tthis.z = Math.min( this.z, v.z );\\n\\t\\t\\tthis.w = Math.min( this.w, v.w );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmax: function ( v ) {\\n\\n\\t\\t\\tthis.x = Math.max( this.x, v.x );\\n\\t\\t\\tthis.y = Math.max( this.y, v.y );\\n\\t\\t\\tthis.z = Math.max( this.z, v.z );\\n\\t\\t\\tthis.w = Math.max( this.w, v.w );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclamp: function ( min, max ) {\\n\\n\\t\\t\\t// assumes min < max, componentwise\\n\\n\\t\\t\\tthis.x = Math.max( min.x, Math.min( max.x, this.x ) );\\n\\t\\t\\tthis.y = Math.max( min.y, Math.min( max.y, this.y ) );\\n\\t\\t\\tthis.z = Math.max( min.z, Math.min( max.z, this.z ) );\\n\\t\\t\\tthis.w = Math.max( min.w, Math.min( max.w, this.w ) );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclampScalar: function () {\\n\\n\\t\\t\\tvar min, max;\\n\\n\\t\\t\\treturn function clampScalar( minVal, maxVal ) {\\n\\n\\t\\t\\t\\tif ( min === undefined ) {\\n\\n\\t\\t\\t\\t\\tmin = new Vector4();\\n\\t\\t\\t\\t\\tmax = new Vector4();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tmin.set( minVal, minVal, minVal, minVal );\\n\\t\\t\\t\\tmax.set( maxVal, maxVal, maxVal, maxVal );\\n\\n\\t\\t\\t\\treturn this.clamp( min, max );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tclampLength: function ( min, max ) {\\n\\n\\t\\t\\tvar length = this.length();\\n\\n\\t\\t\\treturn this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );\\n\\n\\t\\t},\\n\\n\\t\\tfloor: function () {\\n\\n\\t\\t\\tthis.x = Math.floor( this.x );\\n\\t\\t\\tthis.y = Math.floor( this.y );\\n\\t\\t\\tthis.z = Math.floor( this.z );\\n\\t\\t\\tthis.w = Math.floor( this.w );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tceil: function () {\\n\\n\\t\\t\\tthis.x = Math.ceil( this.x );\\n\\t\\t\\tthis.y = Math.ceil( this.y );\\n\\t\\t\\tthis.z = Math.ceil( this.z );\\n\\t\\t\\tthis.w = Math.ceil( this.w );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tround: function () {\\n\\n\\t\\t\\tthis.x = Math.round( this.x );\\n\\t\\t\\tthis.y = Math.round( this.y );\\n\\t\\t\\tthis.z = Math.round( this.z );\\n\\t\\t\\tthis.w = Math.round( this.w );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\troundToZero: function () {\\n\\n\\t\\t\\tthis.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );\\n\\t\\t\\tthis.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );\\n\\t\\t\\tthis.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );\\n\\t\\t\\tthis.w = ( this.w < 0 ) ? Math.ceil( this.w ) : Math.floor( this.w );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tnegate: function () {\\n\\n\\t\\t\\tthis.x = - this.x;\\n\\t\\t\\tthis.y = - this.y;\\n\\t\\t\\tthis.z = - this.z;\\n\\t\\t\\tthis.w = - this.w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdot: function ( v ) {\\n\\n\\t\\t\\treturn this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;\\n\\n\\t\\t},\\n\\n\\t\\tlengthSq: function () {\\n\\n\\t\\t\\treturn this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;\\n\\n\\t\\t},\\n\\n\\t\\tlength: function () {\\n\\n\\t\\t\\treturn Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w );\\n\\n\\t\\t},\\n\\n\\t\\tmanhattanLength: function () {\\n\\n\\t\\t\\treturn Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z ) + Math.abs( this.w );\\n\\n\\t\\t},\\n\\n\\t\\tnormalize: function () {\\n\\n\\t\\t\\treturn this.divideScalar( this.length() || 1 );\\n\\n\\t\\t},\\n\\n\\t\\tsetLength: function ( length ) {\\n\\n\\t\\t\\treturn this.normalize().multiplyScalar( length );\\n\\n\\t\\t},\\n\\n\\t\\tlerp: function ( v, alpha ) {\\n\\n\\t\\t\\tthis.x += ( v.x - this.x ) * alpha;\\n\\t\\t\\tthis.y += ( v.y - this.y ) * alpha;\\n\\t\\t\\tthis.z += ( v.z - this.z ) * alpha;\\n\\t\\t\\tthis.w += ( v.w - this.w ) * alpha;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tlerpVectors: function ( v1, v2, alpha ) {\\n\\n\\t\\t\\treturn this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( v ) {\\n\\n\\t\\t\\treturn ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) && ( v.w === this.w ) );\\n\\n\\t\\t},\\n\\n\\t\\tfromArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tthis.x = array[ offset ];\\n\\t\\t\\tthis.y = array[ offset + 1 ];\\n\\t\\t\\tthis.z = array[ offset + 2 ];\\n\\t\\t\\tthis.w = array[ offset + 3 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( array === undefined ) array = [];\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tarray[ offset ] = this.x;\\n\\t\\t\\tarray[ offset + 1 ] = this.y;\\n\\t\\t\\tarray[ offset + 2 ] = this.z;\\n\\t\\t\\tarray[ offset + 3 ] = this.w;\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t},\\n\\n\\t\\tfromBufferAttribute: function ( attribute, index, offset ) {\\n\\n\\t\\t\\tif ( offset !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Vector4: offset has been removed from .fromBufferAttribute().' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.x = attribute.getX( index );\\n\\t\\t\\tthis.y = attribute.getY( index );\\n\\t\\t\\tthis.z = attribute.getZ( index );\\n\\t\\t\\tthis.w = attribute.getW( index );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author szimek / https://github.com/szimek/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author Marius Kintel / https://github.com/kintel\\n\\t */\\n\\n\\t/*\\n\\t In options, we can specify:\\n\\t * Texture parameters for an auto-generated target texture\\n\\t * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers\\n\\t*/\\n\\tfunction WebGLRenderTarget( width, height, options ) {\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.width = width;\\n\\t\\tthis.height = height;\\n\\n\\t\\tthis.scissor = new Vector4( 0, 0, width, height );\\n\\t\\tthis.scissorTest = false;\\n\\n\\t\\tthis.viewport = new Vector4( 0, 0, width, height );\\n\\n\\t\\toptions = options || {};\\n\\n\\t\\tif ( options.minFilter === undefined ) options.minFilter = LinearFilter;\\n\\n\\t\\tthis.texture = new Texture( undefined, undefined, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.encoding );\\n\\n\\t\\tthis.depthBuffer = options.depthBuffer !== undefined ? options.depthBuffer : true;\\n\\t\\tthis.stencilBuffer = options.stencilBuffer !== undefined ? options.stencilBuffer : true;\\n\\t\\tthis.depthTexture = options.depthTexture !== undefined ? options.depthTexture : null;\\n\\n\\t}\\n\\n\\tWebGLRenderTarget.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {\\n\\n\\t\\tconstructor: WebGLRenderTarget,\\n\\n\\t\\tisWebGLRenderTarget: true,\\n\\n\\t\\tsetSize: function ( width, height ) {\\n\\n\\t\\t\\tif ( this.width !== width || this.height !== height ) {\\n\\n\\t\\t\\t\\tthis.width = width;\\n\\t\\t\\t\\tthis.height = height;\\n\\n\\t\\t\\t\\tthis.dispose();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.viewport.set( 0, 0, width, height );\\n\\t\\t\\tthis.scissor.set( 0, 0, width, height );\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tthis.width = source.width;\\n\\t\\t\\tthis.height = source.height;\\n\\n\\t\\t\\tthis.viewport.copy( source.viewport );\\n\\n\\t\\t\\tthis.texture = source.texture.clone();\\n\\n\\t\\t\\tthis.depthBuffer = source.depthBuffer;\\n\\t\\t\\tthis.stencilBuffer = source.stencilBuffer;\\n\\t\\t\\tthis.depthTexture = source.depthTexture;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdispose: function () {\\n\\n\\t\\t\\tthis.dispatchEvent( { type: 'dispose' } );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com\\n\\t */\\n\\n\\tfunction WebGLRenderTargetCube( width, height, options ) {\\n\\n\\t\\tWebGLRenderTarget.call( this, width, height, options );\\n\\n\\t\\tthis.activeCubeFace = 0; // PX 0, NX 1, PY 2, NY 3, PZ 4, NZ 5\\n\\t\\tthis.activeMipMapLevel = 0;\\n\\n\\t}\\n\\n\\tWebGLRenderTargetCube.prototype = Object.create( WebGLRenderTarget.prototype );\\n\\tWebGLRenderTargetCube.prototype.constructor = WebGLRenderTargetCube;\\n\\n\\tWebGLRenderTargetCube.prototype.isWebGLRenderTargetCube = true;\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction DataTexture( data, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, encoding ) {\\n\\n\\t\\tTexture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding );\\n\\n\\t\\tthis.image = { data: data, width: width, height: height };\\n\\n\\t\\tthis.magFilter = magFilter !== undefined ? magFilter : NearestFilter;\\n\\t\\tthis.minFilter = minFilter !== undefined ? minFilter : NearestFilter;\\n\\n\\t\\tthis.generateMipmaps = false;\\n\\t\\tthis.flipY = false;\\n\\t\\tthis.unpackAlignment = 1;\\n\\n\\t}\\n\\n\\tDataTexture.prototype = Object.create( Texture.prototype );\\n\\tDataTexture.prototype.constructor = DataTexture;\\n\\n\\tDataTexture.prototype.isDataTexture = true;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction CubeTexture( images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding ) {\\n\\n\\t\\timages = images !== undefined ? images : [];\\n\\t\\tmapping = mapping !== undefined ? mapping : CubeReflectionMapping;\\n\\n\\t\\tTexture.call( this, images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding );\\n\\n\\t\\tthis.flipY = false;\\n\\n\\t}\\n\\n\\tCubeTexture.prototype = Object.create( Texture.prototype );\\n\\tCubeTexture.prototype.constructor = CubeTexture;\\n\\n\\tCubeTexture.prototype.isCubeTexture = true;\\n\\n\\tObject.defineProperty( CubeTexture.prototype, 'images', {\\n\\n\\t\\tget: function () {\\n\\n\\t\\t\\treturn this.image;\\n\\n\\t\\t},\\n\\n\\t\\tset: function ( value ) {\\n\\n\\t\\t\\tthis.image = value;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author tschw\\n\\t *\\n\\t * Uniforms of a program.\\n\\t * Those form a tree structure with a special top-level container for the root,\\n\\t * which you get by calling 'new WebGLUniforms( gl, program, renderer )'.\\n\\t *\\n\\t *\\n\\t * Properties of inner nodes including the top-level container:\\n\\t *\\n\\t * .seq - array of nested uniforms\\n\\t * .map - nested uniforms by name\\n\\t *\\n\\t *\\n\\t * Methods of all nodes except the top-level container:\\n\\t *\\n\\t * .setValue( gl, value, [renderer] )\\n\\t *\\n\\t * \\t\\tuploads a uniform value(s)\\n\\t *  \\tthe 'renderer' parameter is needed for sampler uniforms\\n\\t *\\n\\t *\\n\\t * Static methods of the top-level container (renderer factorizations):\\n\\t *\\n\\t * .upload( gl, seq, values, renderer )\\n\\t *\\n\\t * \\t\\tsets uniforms in 'seq' to 'values[id].value'\\n\\t *\\n\\t * .seqWithValue( seq, values ) : filteredSeq\\n\\t *\\n\\t * \\t\\tfilters 'seq' entries with corresponding entry in values\\n\\t *\\n\\t *\\n\\t * Methods of the top-level container (renderer factorizations):\\n\\t *\\n\\t * .setValue( gl, name, value )\\n\\t *\\n\\t * \\t\\tsets uniform with  name 'name' to 'value'\\n\\t *\\n\\t * .set( gl, obj, prop )\\n\\t *\\n\\t * \\t\\tsets uniform from object and property with same name than uniform\\n\\t *\\n\\t * .setOptional( gl, obj, prop )\\n\\t *\\n\\t * \\t\\tlike .set for an optional property of the object\\n\\t *\\n\\t */\\n\\n\\tvar emptyTexture = new Texture();\\n\\tvar emptyCubeTexture = new CubeTexture();\\n\\n\\t// --- Base for inner nodes (including the root) ---\\n\\n\\tfunction UniformContainer() {\\n\\n\\t\\tthis.seq = [];\\n\\t\\tthis.map = {};\\n\\n\\t}\\n\\n\\t// --- Utilities ---\\n\\n\\t// Array Caches (provide typed arrays for temporary by size)\\n\\n\\tvar arrayCacheF32 = [];\\n\\tvar arrayCacheI32 = [];\\n\\n\\t// Float32Array caches used for uploading Matrix uniforms\\n\\n\\tvar mat4array = new Float32Array( 16 );\\n\\tvar mat3array = new Float32Array( 9 );\\n\\n\\t// Flattening for arrays of vectors and matrices\\n\\n\\tfunction flatten( array, nBlocks, blockSize ) {\\n\\n\\t\\tvar firstElem = array[ 0 ];\\n\\n\\t\\tif ( firstElem <= 0 || firstElem > 0 ) return array;\\n\\t\\t// unoptimized: ! isNaN( firstElem )\\n\\t\\t// see http://jacksondunstan.com/articles/983\\n\\n\\t\\tvar n = nBlocks * blockSize,\\n\\t\\t\\tr = arrayCacheF32[ n ];\\n\\n\\t\\tif ( r === undefined ) {\\n\\n\\t\\t\\tr = new Float32Array( n );\\n\\t\\t\\tarrayCacheF32[ n ] = r;\\n\\n\\t\\t}\\n\\n\\t\\tif ( nBlocks !== 0 ) {\\n\\n\\t\\t\\tfirstElem.toArray( r, 0 );\\n\\n\\t\\t\\tfor ( var i = 1, offset = 0; i !== nBlocks; ++ i ) {\\n\\n\\t\\t\\t\\toffset += blockSize;\\n\\t\\t\\t\\tarray[ i ].toArray( r, offset );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\treturn r;\\n\\n\\t}\\n\\n\\t// Texture unit allocation\\n\\n\\tfunction allocTexUnits( renderer, n ) {\\n\\n\\t\\tvar r = arrayCacheI32[ n ];\\n\\n\\t\\tif ( r === undefined ) {\\n\\n\\t\\t\\tr = new Int32Array( n );\\n\\t\\t\\tarrayCacheI32[ n ] = r;\\n\\n\\t\\t}\\n\\n\\t\\tfor ( var i = 0; i !== n; ++ i )\\n\\t\\t\\tr[ i ] = renderer.allocTextureUnit();\\n\\n\\t\\treturn r;\\n\\n\\t}\\n\\n\\t// --- Setters ---\\n\\n\\t// Note: Defining these methods externally, because they come in a bunch\\n\\t// and this way their names minify.\\n\\n\\t// Single scalar\\n\\n\\tfunction setValue1f( gl, v ) {\\n\\n\\t\\tgl.uniform1f( this.addr, v );\\n\\n\\t}\\n\\n\\tfunction setValue1i( gl, v ) {\\n\\n\\t\\tgl.uniform1i( this.addr, v );\\n\\n\\t}\\n\\n\\t// Single float vector (from flat array or THREE.VectorN)\\n\\n\\tfunction setValue2fv( gl, v ) {\\n\\n\\t\\tif ( v.x === undefined ) {\\n\\n\\t\\t\\tgl.uniform2fv( this.addr, v );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tgl.uniform2f( this.addr, v.x, v.y );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tfunction setValue3fv( gl, v ) {\\n\\n\\t\\tif ( v.x !== undefined ) {\\n\\n\\t\\t\\tgl.uniform3f( this.addr, v.x, v.y, v.z );\\n\\n\\t\\t} else if ( v.r !== undefined ) {\\n\\n\\t\\t\\tgl.uniform3f( this.addr, v.r, v.g, v.b );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tgl.uniform3fv( this.addr, v );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tfunction setValue4fv( gl, v ) {\\n\\n\\t\\tif ( v.x === undefined ) {\\n\\n\\t\\t\\tgl.uniform4fv( this.addr, v );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\t gl.uniform4f( this.addr, v.x, v.y, v.z, v.w );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t// Single matrix (from flat array or MatrixN)\\n\\n\\tfunction setValue2fm( gl, v ) {\\n\\n\\t\\tgl.uniformMatrix2fv( this.addr, false, v.elements || v );\\n\\n\\t}\\n\\n\\tfunction setValue3fm( gl, v ) {\\n\\n\\t\\tif ( v.elements === undefined ) {\\n\\n\\t\\t\\tgl.uniformMatrix3fv( this.addr, false, v );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tmat3array.set( v.elements );\\n\\t\\t\\tgl.uniformMatrix3fv( this.addr, false, mat3array );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tfunction setValue4fm( gl, v ) {\\n\\n\\t\\tif ( v.elements === undefined ) {\\n\\n\\t\\t\\tgl.uniformMatrix4fv( this.addr, false, v );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tmat4array.set( v.elements );\\n\\t\\t\\tgl.uniformMatrix4fv( this.addr, false, mat4array );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t// Single texture (2D / Cube)\\n\\n\\tfunction setValueT1( gl, v, renderer ) {\\n\\n\\t\\tvar unit = renderer.allocTextureUnit();\\n\\t\\tgl.uniform1i( this.addr, unit );\\n\\t\\trenderer.setTexture2D( v || emptyTexture, unit );\\n\\n\\t}\\n\\n\\tfunction setValueT6( gl, v, renderer ) {\\n\\n\\t\\tvar unit = renderer.allocTextureUnit();\\n\\t\\tgl.uniform1i( this.addr, unit );\\n\\t\\trenderer.setTextureCube( v || emptyCubeTexture, unit );\\n\\n\\t}\\n\\n\\t// Integer / Boolean vectors or arrays thereof (always flat arrays)\\n\\n\\tfunction setValue2iv( gl, v ) {\\n\\n\\t\\tgl.uniform2iv( this.addr, v );\\n\\n\\t}\\n\\n\\tfunction setValue3iv( gl, v ) {\\n\\n\\t\\tgl.uniform3iv( this.addr, v );\\n\\n\\t}\\n\\n\\tfunction setValue4iv( gl, v ) {\\n\\n\\t\\tgl.uniform4iv( this.addr, v );\\n\\n\\t}\\n\\n\\t// Helper to pick the right setter for the singular case\\n\\n\\tfunction getSingularSetter( type ) {\\n\\n\\t\\tswitch ( type ) {\\n\\n\\t\\t\\tcase 0x1406: return setValue1f; // FLOAT\\n\\t\\t\\tcase 0x8b50: return setValue2fv; // _VEC2\\n\\t\\t\\tcase 0x8b51: return setValue3fv; // _VEC3\\n\\t\\t\\tcase 0x8b52: return setValue4fv; // _VEC4\\n\\n\\t\\t\\tcase 0x8b5a: return setValue2fm; // _MAT2\\n\\t\\t\\tcase 0x8b5b: return setValue3fm; // _MAT3\\n\\t\\t\\tcase 0x8b5c: return setValue4fm; // _MAT4\\n\\n\\t\\t\\tcase 0x8b5e: case 0x8d66: return setValueT1; // SAMPLER_2D, SAMPLER_EXTERNAL_OES\\n\\t\\t\\tcase 0x8b60: return setValueT6; // SAMPLER_CUBE\\n\\n\\t\\t\\tcase 0x1404: case 0x8b56: return setValue1i; // INT, BOOL\\n\\t\\t\\tcase 0x8b53: case 0x8b57: return setValue2iv; // _VEC2\\n\\t\\t\\tcase 0x8b54: case 0x8b58: return setValue3iv; // _VEC3\\n\\t\\t\\tcase 0x8b55: case 0x8b59: return setValue4iv; // _VEC4\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t// Array of scalars\\n\\n\\tfunction setValue1fv( gl, v ) {\\n\\n\\t\\tgl.uniform1fv( this.addr, v );\\n\\n\\t}\\n\\tfunction setValue1iv( gl, v ) {\\n\\n\\t\\tgl.uniform1iv( this.addr, v );\\n\\n\\t}\\n\\n\\t// Array of vectors (flat or from THREE classes)\\n\\n\\tfunction setValueV2a( gl, v ) {\\n\\n\\t\\tgl.uniform2fv( this.addr, flatten( v, this.size, 2 ) );\\n\\n\\t}\\n\\n\\tfunction setValueV3a( gl, v ) {\\n\\n\\t\\tgl.uniform3fv( this.addr, flatten( v, this.size, 3 ) );\\n\\n\\t}\\n\\n\\tfunction setValueV4a( gl, v ) {\\n\\n\\t\\tgl.uniform4fv( this.addr, flatten( v, this.size, 4 ) );\\n\\n\\t}\\n\\n\\t// Array of matrices (flat or from THREE clases)\\n\\n\\tfunction setValueM2a( gl, v ) {\\n\\n\\t\\tgl.uniformMatrix2fv( this.addr, false, flatten( v, this.size, 4 ) );\\n\\n\\t}\\n\\n\\tfunction setValueM3a( gl, v ) {\\n\\n\\t\\tgl.uniformMatrix3fv( this.addr, false, flatten( v, this.size, 9 ) );\\n\\n\\t}\\n\\n\\tfunction setValueM4a( gl, v ) {\\n\\n\\t\\tgl.uniformMatrix4fv( this.addr, false, flatten( v, this.size, 16 ) );\\n\\n\\t}\\n\\n\\t// Array of textures (2D / Cube)\\n\\n\\tfunction setValueT1a( gl, v, renderer ) {\\n\\n\\t\\tvar n = v.length,\\n\\t\\t\\tunits = allocTexUnits( renderer, n );\\n\\n\\t\\tgl.uniform1iv( this.addr, units );\\n\\n\\t\\tfor ( var i = 0; i !== n; ++ i ) {\\n\\n\\t\\t\\trenderer.setTexture2D( v[ i ] || emptyTexture, units[ i ] );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tfunction setValueT6a( gl, v, renderer ) {\\n\\n\\t\\tvar n = v.length,\\n\\t\\t\\tunits = allocTexUnits( renderer, n );\\n\\n\\t\\tgl.uniform1iv( this.addr, units );\\n\\n\\t\\tfor ( var i = 0; i !== n; ++ i ) {\\n\\n\\t\\t\\trenderer.setTextureCube( v[ i ] || emptyCubeTexture, units[ i ] );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t// Helper to pick the right setter for a pure (bottom-level) array\\n\\n\\tfunction getPureArraySetter( type ) {\\n\\n\\t\\tswitch ( type ) {\\n\\n\\t\\t\\tcase 0x1406: return setValue1fv; // FLOAT\\n\\t\\t\\tcase 0x8b50: return setValueV2a; // _VEC2\\n\\t\\t\\tcase 0x8b51: return setValueV3a; // _VEC3\\n\\t\\t\\tcase 0x8b52: return setValueV4a; // _VEC4\\n\\n\\t\\t\\tcase 0x8b5a: return setValueM2a; // _MAT2\\n\\t\\t\\tcase 0x8b5b: return setValueM3a; // _MAT3\\n\\t\\t\\tcase 0x8b5c: return setValueM4a; // _MAT4\\n\\n\\t\\t\\tcase 0x8b5e: return setValueT1a; // SAMPLER_2D\\n\\t\\t\\tcase 0x8b60: return setValueT6a; // SAMPLER_CUBE\\n\\n\\t\\t\\tcase 0x1404: case 0x8b56: return setValue1iv; // INT, BOOL\\n\\t\\t\\tcase 0x8b53: case 0x8b57: return setValue2iv; // _VEC2\\n\\t\\t\\tcase 0x8b54: case 0x8b58: return setValue3iv; // _VEC3\\n\\t\\t\\tcase 0x8b55: case 0x8b59: return setValue4iv; // _VEC4\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t// --- Uniform Classes ---\\n\\n\\tfunction SingleUniform( id, activeInfo, addr ) {\\n\\n\\t\\tthis.id = id;\\n\\t\\tthis.addr = addr;\\n\\t\\tthis.setValue = getSingularSetter( activeInfo.type );\\n\\n\\t\\t// this.path = activeInfo.name; // DEBUG\\n\\n\\t}\\n\\n\\tfunction PureArrayUniform( id, activeInfo, addr ) {\\n\\n\\t\\tthis.id = id;\\n\\t\\tthis.addr = addr;\\n\\t\\tthis.size = activeInfo.size;\\n\\t\\tthis.setValue = getPureArraySetter( activeInfo.type );\\n\\n\\t\\t// this.path = activeInfo.name; // DEBUG\\n\\n\\t}\\n\\n\\tfunction StructuredUniform( id ) {\\n\\n\\t\\tthis.id = id;\\n\\n\\t\\tUniformContainer.call( this ); // mix-in\\n\\n\\t}\\n\\n\\tStructuredUniform.prototype.setValue = function ( gl, value ) {\\n\\n\\t\\t// Note: Don't need an extra 'renderer' parameter, since samplers\\n\\t\\t// are not allowed in structured uniforms.\\n\\n\\t\\tvar seq = this.seq;\\n\\n\\t\\tfor ( var i = 0, n = seq.length; i !== n; ++ i ) {\\n\\n\\t\\t\\tvar u = seq[ i ];\\n\\t\\t\\tu.setValue( gl, value[ u.id ] );\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t// --- Top-level ---\\n\\n\\t// Parser - builds up the property tree from the path strings\\n\\n\\tvar RePathPart = /([\\\\w\\\\d_]+)(\\\\])?(\\\\[|\\\\.)?/g;\\n\\n\\t// extracts\\n\\t// \\t- the identifier (member name or array index)\\n\\t//  - followed by an optional right bracket (found when array index)\\n\\t//  - followed by an optional left bracket or dot (type of subscript)\\n\\t//\\n\\t// Note: These portions can be read in a non-overlapping fashion and\\n\\t// allow straightforward parsing of the hierarchy that WebGL encodes\\n\\t// in the uniform names.\\n\\n\\tfunction addUniform( container, uniformObject ) {\\n\\n\\t\\tcontainer.seq.push( uniformObject );\\n\\t\\tcontainer.map[ uniformObject.id ] = uniformObject;\\n\\n\\t}\\n\\n\\tfunction parseUniform( activeInfo, addr, container ) {\\n\\n\\t\\tvar path = activeInfo.name,\\n\\t\\t\\tpathLength = path.length;\\n\\n\\t\\t// reset RegExp object, because of the early exit of a previous run\\n\\t\\tRePathPart.lastIndex = 0;\\n\\n\\t\\tfor ( ; ; ) {\\n\\n\\t\\t\\tvar match = RePathPart.exec( path ),\\n\\t\\t\\t\\tmatchEnd = RePathPart.lastIndex,\\n\\n\\t\\t\\t\\tid = match[ 1 ],\\n\\t\\t\\t\\tidIsIndex = match[ 2 ] === ']',\\n\\t\\t\\t\\tsubscript = match[ 3 ];\\n\\n\\t\\t\\tif ( idIsIndex ) id = id | 0; // convert to integer\\n\\n\\t\\t\\tif ( subscript === undefined || subscript === '[' && matchEnd + 2 === pathLength ) {\\n\\n\\t\\t\\t\\t// bare name or \\\"pure\\\" bottom-level array \\\"[0]\\\" suffix\\n\\n\\t\\t\\t\\taddUniform( container, subscript === undefined ?\\n\\t\\t\\t\\t\\tnew SingleUniform( id, activeInfo, addr ) :\\n\\t\\t\\t\\t\\tnew PureArrayUniform( id, activeInfo, addr ) );\\n\\n\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// step into inner node / create it in case it doesn't exist\\n\\n\\t\\t\\t\\tvar map = container.map, next = map[ id ];\\n\\n\\t\\t\\t\\tif ( next === undefined ) {\\n\\n\\t\\t\\t\\t\\tnext = new StructuredUniform( id );\\n\\t\\t\\t\\t\\taddUniform( container, next );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tcontainer = next;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t// Root Container\\n\\n\\tfunction WebGLUniforms( gl, program, renderer ) {\\n\\n\\t\\tUniformContainer.call( this );\\n\\n\\t\\tthis.renderer = renderer;\\n\\n\\t\\tvar n = gl.getProgramParameter( program, gl.ACTIVE_UNIFORMS );\\n\\n\\t\\tfor ( var i = 0; i < n; ++ i ) {\\n\\n\\t\\t\\tvar info = gl.getActiveUniform( program, i ),\\n\\t\\t\\t\\tpath = info.name,\\n\\t\\t\\t\\taddr = gl.getUniformLocation( program, path );\\n\\n\\t\\t\\tparseUniform( info, addr, this );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tWebGLUniforms.prototype.setValue = function ( gl, name, value ) {\\n\\n\\t\\tvar u = this.map[ name ];\\n\\n\\t\\tif ( u !== undefined ) u.setValue( gl, value, this.renderer );\\n\\n\\t};\\n\\n\\tWebGLUniforms.prototype.setOptional = function ( gl, object, name ) {\\n\\n\\t\\tvar v = object[ name ];\\n\\n\\t\\tif ( v !== undefined ) this.setValue( gl, name, v );\\n\\n\\t};\\n\\n\\n\\t// Static interface\\n\\n\\tWebGLUniforms.upload = function ( gl, seq, values, renderer ) {\\n\\n\\t\\tfor ( var i = 0, n = seq.length; i !== n; ++ i ) {\\n\\n\\t\\t\\tvar u = seq[ i ],\\n\\t\\t\\t\\tv = values[ u.id ];\\n\\n\\t\\t\\tif ( v.needsUpdate !== false ) {\\n\\n\\t\\t\\t\\t// note: always updating when .needsUpdate is undefined\\n\\t\\t\\t\\tu.setValue( gl, v.value, renderer );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\tWebGLUniforms.seqWithValue = function ( seq, values ) {\\n\\n\\t\\tvar r = [];\\n\\n\\t\\tfor ( var i = 0, n = seq.length; i !== n; ++ i ) {\\n\\n\\t\\t\\tvar u = seq[ i ];\\n\\t\\t\\tif ( u.id in values ) r.push( u );\\n\\n\\t\\t}\\n\\n\\t\\treturn r;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tvar ColorKeywords = { 'aliceblue': 0xF0F8FF, 'antiquewhite': 0xFAEBD7, 'aqua': 0x00FFFF, 'aquamarine': 0x7FFFD4, 'azure': 0xF0FFFF,\\n\\t\\t'beige': 0xF5F5DC, 'bisque': 0xFFE4C4, 'black': 0x000000, 'blanchedalmond': 0xFFEBCD, 'blue': 0x0000FF, 'blueviolet': 0x8A2BE2,\\n\\t\\t'brown': 0xA52A2A, 'burlywood': 0xDEB887, 'cadetblue': 0x5F9EA0, 'chartreuse': 0x7FFF00, 'chocolate': 0xD2691E, 'coral': 0xFF7F50,\\n\\t\\t'cornflowerblue': 0x6495ED, 'cornsilk': 0xFFF8DC, 'crimson': 0xDC143C, 'cyan': 0x00FFFF, 'darkblue': 0x00008B, 'darkcyan': 0x008B8B,\\n\\t\\t'darkgoldenrod': 0xB8860B, 'darkgray': 0xA9A9A9, 'darkgreen': 0x006400, 'darkgrey': 0xA9A9A9, 'darkkhaki': 0xBDB76B, 'darkmagenta': 0x8B008B,\\n\\t\\t'darkolivegreen': 0x556B2F, 'darkorange': 0xFF8C00, 'darkorchid': 0x9932CC, 'darkred': 0x8B0000, 'darksalmon': 0xE9967A, 'darkseagreen': 0x8FBC8F,\\n\\t\\t'darkslateblue': 0x483D8B, 'darkslategray': 0x2F4F4F, 'darkslategrey': 0x2F4F4F, 'darkturquoise': 0x00CED1, 'darkviolet': 0x9400D3,\\n\\t\\t'deeppink': 0xFF1493, 'deepskyblue': 0x00BFFF, 'dimgray': 0x696969, 'dimgrey': 0x696969, 'dodgerblue': 0x1E90FF, 'firebrick': 0xB22222,\\n\\t\\t'floralwhite': 0xFFFAF0, 'forestgreen': 0x228B22, 'fuchsia': 0xFF00FF, 'gainsboro': 0xDCDCDC, 'ghostwhite': 0xF8F8FF, 'gold': 0xFFD700,\\n\\t\\t'goldenrod': 0xDAA520, 'gray': 0x808080, 'green': 0x008000, 'greenyellow': 0xADFF2F, 'grey': 0x808080, 'honeydew': 0xF0FFF0, 'hotpink': 0xFF69B4,\\n\\t\\t'indianred': 0xCD5C5C, 'indigo': 0x4B0082, 'ivory': 0xFFFFF0, 'khaki': 0xF0E68C, 'lavender': 0xE6E6FA, 'lavenderblush': 0xFFF0F5, 'lawngreen': 0x7CFC00,\\n\\t\\t'lemonchiffon': 0xFFFACD, 'lightblue': 0xADD8E6, 'lightcoral': 0xF08080, 'lightcyan': 0xE0FFFF, 'lightgoldenrodyellow': 0xFAFAD2, 'lightgray': 0xD3D3D3,\\n\\t\\t'lightgreen': 0x90EE90, 'lightgrey': 0xD3D3D3, 'lightpink': 0xFFB6C1, 'lightsalmon': 0xFFA07A, 'lightseagreen': 0x20B2AA, 'lightskyblue': 0x87CEFA,\\n\\t\\t'lightslategray': 0x778899, 'lightslategrey': 0x778899, 'lightsteelblue': 0xB0C4DE, 'lightyellow': 0xFFFFE0, 'lime': 0x00FF00, 'limegreen': 0x32CD32,\\n\\t\\t'linen': 0xFAF0E6, 'magenta': 0xFF00FF, 'maroon': 0x800000, 'mediumaquamarine': 0x66CDAA, 'mediumblue': 0x0000CD, 'mediumorchid': 0xBA55D3,\\n\\t\\t'mediumpurple': 0x9370DB, 'mediumseagreen': 0x3CB371, 'mediumslateblue': 0x7B68EE, 'mediumspringgreen': 0x00FA9A, 'mediumturquoise': 0x48D1CC,\\n\\t\\t'mediumvioletred': 0xC71585, 'midnightblue': 0x191970, 'mintcream': 0xF5FFFA, 'mistyrose': 0xFFE4E1, 'moccasin': 0xFFE4B5, 'navajowhite': 0xFFDEAD,\\n\\t\\t'navy': 0x000080, 'oldlace': 0xFDF5E6, 'olive': 0x808000, 'olivedrab': 0x6B8E23, 'orange': 0xFFA500, 'orangered': 0xFF4500, 'orchid': 0xDA70D6,\\n\\t\\t'palegoldenrod': 0xEEE8AA, 'palegreen': 0x98FB98, 'paleturquoise': 0xAFEEEE, 'palevioletred': 0xDB7093, 'papayawhip': 0xFFEFD5, 'peachpuff': 0xFFDAB9,\\n\\t\\t'peru': 0xCD853F, 'pink': 0xFFC0CB, 'plum': 0xDDA0DD, 'powderblue': 0xB0E0E6, 'purple': 0x800080, 'rebeccapurple': 0x663399, 'red': 0xFF0000, 'rosybrown': 0xBC8F8F,\\n\\t\\t'royalblue': 0x4169E1, 'saddlebrown': 0x8B4513, 'salmon': 0xFA8072, 'sandybrown': 0xF4A460, 'seagreen': 0x2E8B57, 'seashell': 0xFFF5EE,\\n\\t\\t'sienna': 0xA0522D, 'silver': 0xC0C0C0, 'skyblue': 0x87CEEB, 'slateblue': 0x6A5ACD, 'slategray': 0x708090, 'slategrey': 0x708090, 'snow': 0xFFFAFA,\\n\\t\\t'springgreen': 0x00FF7F, 'steelblue': 0x4682B4, 'tan': 0xD2B48C, 'teal': 0x008080, 'thistle': 0xD8BFD8, 'tomato': 0xFF6347, 'turquoise': 0x40E0D0,\\n\\t\\t'violet': 0xEE82EE, 'wheat': 0xF5DEB3, 'white': 0xFFFFFF, 'whitesmoke': 0xF5F5F5, 'yellow': 0xFFFF00, 'yellowgreen': 0x9ACD32 };\\n\\n\\tfunction Color( r, g, b ) {\\n\\n\\t\\tif ( g === undefined && b === undefined ) {\\n\\n\\t\\t\\t// r is THREE.Color, hex or string\\n\\t\\t\\treturn this.set( r );\\n\\n\\t\\t}\\n\\n\\t\\treturn this.setRGB( r, g, b );\\n\\n\\t}\\n\\n\\tObject.assign( Color.prototype, {\\n\\n\\t\\tisColor: true,\\n\\n\\t\\tr: 1, g: 1, b: 1,\\n\\n\\t\\tset: function ( value ) {\\n\\n\\t\\t\\tif ( value && value.isColor ) {\\n\\n\\t\\t\\t\\tthis.copy( value );\\n\\n\\t\\t\\t} else if ( typeof value === 'number' ) {\\n\\n\\t\\t\\t\\tthis.setHex( value );\\n\\n\\t\\t\\t} else if ( typeof value === 'string' ) {\\n\\n\\t\\t\\t\\tthis.setStyle( value );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.r = scalar;\\n\\t\\t\\tthis.g = scalar;\\n\\t\\t\\tthis.b = scalar;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetHex: function ( hex ) {\\n\\n\\t\\t\\thex = Math.floor( hex );\\n\\n\\t\\t\\tthis.r = ( hex >> 16 & 255 ) / 255;\\n\\t\\t\\tthis.g = ( hex >> 8 & 255 ) / 255;\\n\\t\\t\\tthis.b = ( hex & 255 ) / 255;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetRGB: function ( r, g, b ) {\\n\\n\\t\\t\\tthis.r = r;\\n\\t\\t\\tthis.g = g;\\n\\t\\t\\tthis.b = b;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetHSL: function () {\\n\\n\\t\\t\\tfunction hue2rgb( p, q, t ) {\\n\\n\\t\\t\\t\\tif ( t < 0 ) t += 1;\\n\\t\\t\\t\\tif ( t > 1 ) t -= 1;\\n\\t\\t\\t\\tif ( t < 1 / 6 ) return p + ( q - p ) * 6 * t;\\n\\t\\t\\t\\tif ( t < 1 / 2 ) return q;\\n\\t\\t\\t\\tif ( t < 2 / 3 ) return p + ( q - p ) * 6 * ( 2 / 3 - t );\\n\\t\\t\\t\\treturn p;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn function setHSL( h, s, l ) {\\n\\n\\t\\t\\t\\t// h,s,l ranges are in 0.0 - 1.0\\n\\t\\t\\t\\th = _Math.euclideanModulo( h, 1 );\\n\\t\\t\\t\\ts = _Math.clamp( s, 0, 1 );\\n\\t\\t\\t\\tl = _Math.clamp( l, 0, 1 );\\n\\n\\t\\t\\t\\tif ( s === 0 ) {\\n\\n\\t\\t\\t\\t\\tthis.r = this.g = this.b = l;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tvar p = l <= 0.5 ? l * ( 1 + s ) : l + s - ( l * s );\\n\\t\\t\\t\\t\\tvar q = ( 2 * l ) - p;\\n\\n\\t\\t\\t\\t\\tthis.r = hue2rgb( q, p, h + 1 / 3 );\\n\\t\\t\\t\\t\\tthis.g = hue2rgb( q, p, h );\\n\\t\\t\\t\\t\\tthis.b = hue2rgb( q, p, h - 1 / 3 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tsetStyle: function ( style ) {\\n\\n\\t\\t\\tfunction handleAlpha( string ) {\\n\\n\\t\\t\\t\\tif ( string === undefined ) return;\\n\\n\\t\\t\\t\\tif ( parseFloat( string ) < 1 ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.Color: Alpha component of ' + style + ' will be ignored.' );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\n\\t\\t\\tvar m;\\n\\n\\t\\t\\tif ( m = /^((?:rgb|hsl)a?)\\\\(\\\\s*([^\\\\)]*)\\\\)/.exec( style ) ) {\\n\\n\\t\\t\\t\\t// rgb / hsl\\n\\n\\t\\t\\t\\tvar color;\\n\\t\\t\\t\\tvar name = m[ 1 ];\\n\\t\\t\\t\\tvar components = m[ 2 ];\\n\\n\\t\\t\\t\\tswitch ( name ) {\\n\\n\\t\\t\\t\\t\\tcase 'rgb':\\n\\t\\t\\t\\t\\tcase 'rgba':\\n\\n\\t\\t\\t\\t\\t\\tif ( color = /^(\\\\d+)\\\\s*,\\\\s*(\\\\d+)\\\\s*,\\\\s*(\\\\d+)\\\\s*(,\\\\s*([0-9]*\\\\.?[0-9]+)\\\\s*)?$/.exec( components ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// rgb(255,0,0) rgba(255,0,0,0.5)\\n\\t\\t\\t\\t\\t\\t\\tthis.r = Math.min( 255, parseInt( color[ 1 ], 10 ) ) / 255;\\n\\t\\t\\t\\t\\t\\t\\tthis.g = Math.min( 255, parseInt( color[ 2 ], 10 ) ) / 255;\\n\\t\\t\\t\\t\\t\\t\\tthis.b = Math.min( 255, parseInt( color[ 3 ], 10 ) ) / 255;\\n\\n\\t\\t\\t\\t\\t\\t\\thandleAlpha( color[ 5 ] );\\n\\n\\t\\t\\t\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tif ( color = /^(\\\\d+)\\\\%\\\\s*,\\\\s*(\\\\d+)\\\\%\\\\s*,\\\\s*(\\\\d+)\\\\%\\\\s*(,\\\\s*([0-9]*\\\\.?[0-9]+)\\\\s*)?$/.exec( components ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// rgb(100%,0%,0%) rgba(100%,0%,0%,0.5)\\n\\t\\t\\t\\t\\t\\t\\tthis.r = Math.min( 100, parseInt( color[ 1 ], 10 ) ) / 100;\\n\\t\\t\\t\\t\\t\\t\\tthis.g = Math.min( 100, parseInt( color[ 2 ], 10 ) ) / 100;\\n\\t\\t\\t\\t\\t\\t\\tthis.b = Math.min( 100, parseInt( color[ 3 ], 10 ) ) / 100;\\n\\n\\t\\t\\t\\t\\t\\t\\thandleAlpha( color[ 5 ] );\\n\\n\\t\\t\\t\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'hsl':\\n\\t\\t\\t\\t\\tcase 'hsla':\\n\\n\\t\\t\\t\\t\\t\\tif ( color = /^([0-9]*\\\\.?[0-9]+)\\\\s*,\\\\s*(\\\\d+)\\\\%\\\\s*,\\\\s*(\\\\d+)\\\\%\\\\s*(,\\\\s*([0-9]*\\\\.?[0-9]+)\\\\s*)?$/.exec( components ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// hsl(120,50%,50%) hsla(120,50%,50%,0.5)\\n\\t\\t\\t\\t\\t\\t\\tvar h = parseFloat( color[ 1 ] ) / 360;\\n\\t\\t\\t\\t\\t\\t\\tvar s = parseInt( color[ 2 ], 10 ) / 100;\\n\\t\\t\\t\\t\\t\\t\\tvar l = parseInt( color[ 3 ], 10 ) / 100;\\n\\n\\t\\t\\t\\t\\t\\t\\thandleAlpha( color[ 5 ] );\\n\\n\\t\\t\\t\\t\\t\\t\\treturn this.setHSL( h, s, l );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( m = /^\\\\#([A-Fa-f0-9]+)$/.exec( style ) ) {\\n\\n\\t\\t\\t\\t// hex color\\n\\n\\t\\t\\t\\tvar hex = m[ 1 ];\\n\\t\\t\\t\\tvar size = hex.length;\\n\\n\\t\\t\\t\\tif ( size === 3 ) {\\n\\n\\t\\t\\t\\t\\t// #ff0\\n\\t\\t\\t\\t\\tthis.r = parseInt( hex.charAt( 0 ) + hex.charAt( 0 ), 16 ) / 255;\\n\\t\\t\\t\\t\\tthis.g = parseInt( hex.charAt( 1 ) + hex.charAt( 1 ), 16 ) / 255;\\n\\t\\t\\t\\t\\tthis.b = parseInt( hex.charAt( 2 ) + hex.charAt( 2 ), 16 ) / 255;\\n\\n\\t\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t\\t} else if ( size === 6 ) {\\n\\n\\t\\t\\t\\t\\t// #ff0000\\n\\t\\t\\t\\t\\tthis.r = parseInt( hex.charAt( 0 ) + hex.charAt( 1 ), 16 ) / 255;\\n\\t\\t\\t\\t\\tthis.g = parseInt( hex.charAt( 2 ) + hex.charAt( 3 ), 16 ) / 255;\\n\\t\\t\\t\\t\\tthis.b = parseInt( hex.charAt( 4 ) + hex.charAt( 5 ), 16 ) / 255;\\n\\n\\t\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( style && style.length > 0 ) {\\n\\n\\t\\t\\t\\t// color keywords\\n\\t\\t\\t\\tvar hex = ColorKeywords[ style ];\\n\\n\\t\\t\\t\\tif ( hex !== undefined ) {\\n\\n\\t\\t\\t\\t\\t// red\\n\\t\\t\\t\\t\\tthis.setHex( hex );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// unknown color\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.Color: Unknown color ' + style );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.r, this.g, this.b );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( color ) {\\n\\n\\t\\t\\tthis.r = color.r;\\n\\t\\t\\tthis.g = color.g;\\n\\t\\t\\tthis.b = color.b;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyGammaToLinear: function ( color, gammaFactor ) {\\n\\n\\t\\t\\tif ( gammaFactor === undefined ) gammaFactor = 2.0;\\n\\n\\t\\t\\tthis.r = Math.pow( color.r, gammaFactor );\\n\\t\\t\\tthis.g = Math.pow( color.g, gammaFactor );\\n\\t\\t\\tthis.b = Math.pow( color.b, gammaFactor );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyLinearToGamma: function ( color, gammaFactor ) {\\n\\n\\t\\t\\tif ( gammaFactor === undefined ) gammaFactor = 2.0;\\n\\n\\t\\t\\tvar safeInverse = ( gammaFactor > 0 ) ? ( 1.0 / gammaFactor ) : 1.0;\\n\\n\\t\\t\\tthis.r = Math.pow( color.r, safeInverse );\\n\\t\\t\\tthis.g = Math.pow( color.g, safeInverse );\\n\\t\\t\\tthis.b = Math.pow( color.b, safeInverse );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tconvertGammaToLinear: function () {\\n\\n\\t\\t\\tvar r = this.r, g = this.g, b = this.b;\\n\\n\\t\\t\\tthis.r = r * r;\\n\\t\\t\\tthis.g = g * g;\\n\\t\\t\\tthis.b = b * b;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tconvertLinearToGamma: function () {\\n\\n\\t\\t\\tthis.r = Math.sqrt( this.r );\\n\\t\\t\\tthis.g = Math.sqrt( this.g );\\n\\t\\t\\tthis.b = Math.sqrt( this.b );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetHex: function () {\\n\\n\\t\\t\\treturn ( this.r * 255 ) << 16 ^ ( this.g * 255 ) << 8 ^ ( this.b * 255 ) << 0;\\n\\n\\t\\t},\\n\\n\\t\\tgetHexString: function () {\\n\\n\\t\\t\\treturn ( '000000' + this.getHex().toString( 16 ) ).slice( - 6 );\\n\\n\\t\\t},\\n\\n\\t\\tgetHSL: function ( optionalTarget ) {\\n\\n\\t\\t\\t// h,s,l ranges are in 0.0 - 1.0\\n\\n\\t\\t\\tvar hsl = optionalTarget || { h: 0, s: 0, l: 0 };\\n\\n\\t\\t\\tvar r = this.r, g = this.g, b = this.b;\\n\\n\\t\\t\\tvar max = Math.max( r, g, b );\\n\\t\\t\\tvar min = Math.min( r, g, b );\\n\\n\\t\\t\\tvar hue, saturation;\\n\\t\\t\\tvar lightness = ( min + max ) / 2.0;\\n\\n\\t\\t\\tif ( min === max ) {\\n\\n\\t\\t\\t\\thue = 0;\\n\\t\\t\\t\\tsaturation = 0;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tvar delta = max - min;\\n\\n\\t\\t\\t\\tsaturation = lightness <= 0.5 ? delta / ( max + min ) : delta / ( 2 - max - min );\\n\\n\\t\\t\\t\\tswitch ( max ) {\\n\\n\\t\\t\\t\\t\\tcase r: hue = ( g - b ) / delta + ( g < b ? 6 : 0 ); break;\\n\\t\\t\\t\\t\\tcase g: hue = ( b - r ) / delta + 2; break;\\n\\t\\t\\t\\t\\tcase b: hue = ( r - g ) / delta + 4; break;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\thue /= 6;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\thsl.h = hue;\\n\\t\\t\\thsl.s = saturation;\\n\\t\\t\\thsl.l = lightness;\\n\\n\\t\\t\\treturn hsl;\\n\\n\\t\\t},\\n\\n\\t\\tgetStyle: function () {\\n\\n\\t\\t\\treturn 'rgb(' + ( ( this.r * 255 ) | 0 ) + ',' + ( ( this.g * 255 ) | 0 ) + ',' + ( ( this.b * 255 ) | 0 ) + ')';\\n\\n\\t\\t},\\n\\n\\t\\toffsetHSL: function ( h, s, l ) {\\n\\n\\t\\t\\tvar hsl = this.getHSL();\\n\\n\\t\\t\\thsl.h += h; hsl.s += s; hsl.l += l;\\n\\n\\t\\t\\tthis.setHSL( hsl.h, hsl.s, hsl.l );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tadd: function ( color ) {\\n\\n\\t\\t\\tthis.r += color.r;\\n\\t\\t\\tthis.g += color.g;\\n\\t\\t\\tthis.b += color.b;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddColors: function ( color1, color2 ) {\\n\\n\\t\\t\\tthis.r = color1.r + color2.r;\\n\\t\\t\\tthis.g = color1.g + color2.g;\\n\\t\\t\\tthis.b = color1.b + color2.b;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddScalar: function ( s ) {\\n\\n\\t\\t\\tthis.r += s;\\n\\t\\t\\tthis.g += s;\\n\\t\\t\\tthis.b += s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsub: function ( color ) {\\n\\n\\t\\t\\tthis.r = Math.max( 0, this.r - color.r );\\n\\t\\t\\tthis.g = Math.max( 0, this.g - color.g );\\n\\t\\t\\tthis.b = Math.max( 0, this.b - color.b );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiply: function ( color ) {\\n\\n\\t\\t\\tthis.r *= color.r;\\n\\t\\t\\tthis.g *= color.g;\\n\\t\\t\\tthis.b *= color.b;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmultiplyScalar: function ( s ) {\\n\\n\\t\\t\\tthis.r *= s;\\n\\t\\t\\tthis.g *= s;\\n\\t\\t\\tthis.b *= s;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tlerp: function ( color, alpha ) {\\n\\n\\t\\t\\tthis.r += ( color.r - this.r ) * alpha;\\n\\t\\t\\tthis.g += ( color.g - this.g ) * alpha;\\n\\t\\t\\tthis.b += ( color.b - this.b ) * alpha;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( c ) {\\n\\n\\t\\t\\treturn ( c.r === this.r ) && ( c.g === this.g ) && ( c.b === this.b );\\n\\n\\t\\t},\\n\\n\\t\\tfromArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tthis.r = array[ offset ];\\n\\t\\t\\tthis.g = array[ offset + 1 ];\\n\\t\\t\\tthis.b = array[ offset + 2 ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( array === undefined ) array = [];\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tarray[ offset ] = this.r;\\n\\t\\t\\tarray[ offset + 1 ] = this.g;\\n\\t\\t\\tarray[ offset + 2 ] = this.b;\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function () {\\n\\n\\t\\t\\treturn this.getHex();\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * Uniforms library for shared webgl shaders\\n\\t */\\n\\n\\tvar UniformsLib = {\\n\\n\\t\\tcommon: {\\n\\n\\t\\t\\tdiffuse: { value: new Color( 0xeeeeee ) },\\n\\t\\t\\topacity: { value: 1.0 },\\n\\n\\t\\t\\tmap: { value: null },\\n\\t\\t\\tuvTransform: { value: new Matrix3() },\\n\\n\\t\\t\\talphaMap: { value: null },\\n\\n\\t\\t},\\n\\n\\t\\tspecularmap: {\\n\\n\\t\\t\\tspecularMap: { value: null },\\n\\n\\t\\t},\\n\\n\\t\\tenvmap: {\\n\\n\\t\\t\\tenvMap: { value: null },\\n\\t\\t\\tflipEnvMap: { value: - 1 },\\n\\t\\t\\treflectivity: { value: 1.0 },\\n\\t\\t\\trefractionRatio: { value: 0.98 }\\n\\n\\t\\t},\\n\\n\\t\\taomap: {\\n\\n\\t\\t\\taoMap: { value: null },\\n\\t\\t\\taoMapIntensity: { value: 1 }\\n\\n\\t\\t},\\n\\n\\t\\tlightmap: {\\n\\n\\t\\t\\tlightMap: { value: null },\\n\\t\\t\\tlightMapIntensity: { value: 1 }\\n\\n\\t\\t},\\n\\n\\t\\temissivemap: {\\n\\n\\t\\t\\temissiveMap: { value: null }\\n\\n\\t\\t},\\n\\n\\t\\tbumpmap: {\\n\\n\\t\\t\\tbumpMap: { value: null },\\n\\t\\t\\tbumpScale: { value: 1 }\\n\\n\\t\\t},\\n\\n\\t\\tnormalmap: {\\n\\n\\t\\t\\tnormalMap: { value: null },\\n\\t\\t\\tnormalScale: { value: new Vector2( 1, 1 ) }\\n\\n\\t\\t},\\n\\n\\t\\tdisplacementmap: {\\n\\n\\t\\t\\tdisplacementMap: { value: null },\\n\\t\\t\\tdisplacementScale: { value: 1 },\\n\\t\\t\\tdisplacementBias: { value: 0 }\\n\\n\\t\\t},\\n\\n\\t\\troughnessmap: {\\n\\n\\t\\t\\troughnessMap: { value: null }\\n\\n\\t\\t},\\n\\n\\t\\tmetalnessmap: {\\n\\n\\t\\t\\tmetalnessMap: { value: null }\\n\\n\\t\\t},\\n\\n\\t\\tgradientmap: {\\n\\n\\t\\t\\tgradientMap: { value: null }\\n\\n\\t\\t},\\n\\n\\t\\tfog: {\\n\\n\\t\\t\\tfogDensity: { value: 0.00025 },\\n\\t\\t\\tfogNear: { value: 1 },\\n\\t\\t\\tfogFar: { value: 2000 },\\n\\t\\t\\tfogColor: { value: new Color( 0xffffff ) }\\n\\n\\t\\t},\\n\\n\\t\\tlights: {\\n\\n\\t\\t\\tambientLightColor: { value: [] },\\n\\n\\t\\t\\tdirectionalLights: { value: [], properties: {\\n\\t\\t\\t\\tdirection: {},\\n\\t\\t\\t\\tcolor: {},\\n\\n\\t\\t\\t\\tshadow: {},\\n\\t\\t\\t\\tshadowBias: {},\\n\\t\\t\\t\\tshadowRadius: {},\\n\\t\\t\\t\\tshadowMapSize: {}\\n\\t\\t\\t} },\\n\\n\\t\\t\\tdirectionalShadowMap: { value: [] },\\n\\t\\t\\tdirectionalShadowMatrix: { value: [] },\\n\\n\\t\\t\\tspotLights: { value: [], properties: {\\n\\t\\t\\t\\tcolor: {},\\n\\t\\t\\t\\tposition: {},\\n\\t\\t\\t\\tdirection: {},\\n\\t\\t\\t\\tdistance: {},\\n\\t\\t\\t\\tconeCos: {},\\n\\t\\t\\t\\tpenumbraCos: {},\\n\\t\\t\\t\\tdecay: {},\\n\\n\\t\\t\\t\\tshadow: {},\\n\\t\\t\\t\\tshadowBias: {},\\n\\t\\t\\t\\tshadowRadius: {},\\n\\t\\t\\t\\tshadowMapSize: {}\\n\\t\\t\\t} },\\n\\n\\t\\t\\tspotShadowMap: { value: [] },\\n\\t\\t\\tspotShadowMatrix: { value: [] },\\n\\n\\t\\t\\tpointLights: { value: [], properties: {\\n\\t\\t\\t\\tcolor: {},\\n\\t\\t\\t\\tposition: {},\\n\\t\\t\\t\\tdecay: {},\\n\\t\\t\\t\\tdistance: {},\\n\\n\\t\\t\\t\\tshadow: {},\\n\\t\\t\\t\\tshadowBias: {},\\n\\t\\t\\t\\tshadowRadius: {},\\n\\t\\t\\t\\tshadowMapSize: {},\\n\\t\\t\\t\\tshadowCameraNear: {},\\n\\t\\t\\t\\tshadowCameraFar: {}\\n\\t\\t\\t} },\\n\\n\\t\\t\\tpointShadowMap: { value: [] },\\n\\t\\t\\tpointShadowMatrix: { value: [] },\\n\\n\\t\\t\\themisphereLights: { value: [], properties: {\\n\\t\\t\\t\\tdirection: {},\\n\\t\\t\\t\\tskyColor: {},\\n\\t\\t\\t\\tgroundColor: {}\\n\\t\\t\\t} },\\n\\n\\t\\t\\t// TODO (abelnation): RectAreaLight BRDF data needs to be moved from example to main src\\n\\t\\t\\trectAreaLights: { value: [], properties: {\\n\\t\\t\\t\\tcolor: {},\\n\\t\\t\\t\\tposition: {},\\n\\t\\t\\t\\twidth: {},\\n\\t\\t\\t\\theight: {}\\n\\t\\t\\t} }\\n\\n\\t\\t},\\n\\n\\t\\tpoints: {\\n\\n\\t\\t\\tdiffuse: { value: new Color( 0xeeeeee ) },\\n\\t\\t\\topacity: { value: 1.0 },\\n\\t\\t\\tsize: { value: 1.0 },\\n\\t\\t\\tscale: { value: 1.0 },\\n\\t\\t\\tmap: { value: null },\\n\\t\\t\\tuvTransform: { value: new Matrix3() }\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * Uniform Utilities\\n\\t */\\n\\n\\tvar UniformsUtils = {\\n\\n\\t\\tmerge: function ( uniforms ) {\\n\\n\\t\\t\\tvar merged = {};\\n\\n\\t\\t\\tfor ( var u = 0; u < uniforms.length; u ++ ) {\\n\\n\\t\\t\\t\\tvar tmp = this.clone( uniforms[ u ] );\\n\\n\\t\\t\\t\\tfor ( var p in tmp ) {\\n\\n\\t\\t\\t\\t\\tmerged[ p ] = tmp[ p ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn merged;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function ( uniforms_src ) {\\n\\n\\t\\t\\tvar uniforms_dst = {};\\n\\n\\t\\t\\tfor ( var u in uniforms_src ) {\\n\\n\\t\\t\\t\\tuniforms_dst[ u ] = {};\\n\\n\\t\\t\\t\\tfor ( var p in uniforms_src[ u ] ) {\\n\\n\\t\\t\\t\\t\\tvar parameter_src = uniforms_src[ u ][ p ];\\n\\n\\t\\t\\t\\t\\tif ( parameter_src && ( parameter_src.isColor ||\\n\\t\\t\\t\\t\\t\\tparameter_src.isMatrix3 || parameter_src.isMatrix4 ||\\n\\t\\t\\t\\t\\t\\tparameter_src.isVector2 || parameter_src.isVector3 || parameter_src.isVector4 ||\\n\\t\\t\\t\\t\\t\\tparameter_src.isTexture ) ) {\\n\\n\\t\\t\\t\\t\\t\\tuniforms_dst[ u ][ p ] = parameter_src.clone();\\n\\n\\t\\t\\t\\t\\t} else if ( Array.isArray( parameter_src ) ) {\\n\\n\\t\\t\\t\\t\\t\\tuniforms_dst[ u ][ p ] = parameter_src.slice();\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tuniforms_dst[ u ][ p ] = parameter_src;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn uniforms_dst;\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\tvar alphamap_fragment = \\\"#ifdef USE_ALPHAMAP\\\\n\\\\tdiffuseColor.a *= texture2D( alphaMap, vUv ).g;\\\\n#endif\\\\n\\\";\\n\\n\\tvar alphamap_pars_fragment = \\\"#ifdef USE_ALPHAMAP\\\\n\\\\tuniform sampler2D alphaMap;\\\\n#endif\\\\n\\\";\\n\\n\\tvar alphatest_fragment = \\\"#ifdef ALPHATEST\\\\n\\\\tif ( diffuseColor.a < ALPHATEST ) discard;\\\\n#endif\\\\n\\\";\\n\\n\\tvar aomap_fragment = \\\"#ifdef USE_AOMAP\\\\n\\\\tfloat ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\\\\n\\\\treflectedLight.indirectDiffuse *= ambientOcclusion;\\\\n\\\\t#if defined( USE_ENVMAP ) && defined( PHYSICAL )\\\\n\\\\t\\\\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\\\\n\\\\t\\\\treflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.specularRoughness );\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar aomap_pars_fragment = \\\"#ifdef USE_AOMAP\\\\n\\\\tuniform sampler2D aoMap;\\\\n\\\\tuniform float aoMapIntensity;\\\\n#endif\\\";\\n\\n\\tvar begin_vertex = \\\"\\\\nvec3 transformed = vec3( position );\\\\n\\\";\\n\\n\\tvar beginnormal_vertex = \\\"\\\\nvec3 objectNormal = vec3( normal );\\\\n\\\";\\n\\n\\tvar bsdfs = \\\"float punctualLightIntensityToIrradianceFactor( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\\\\n\\\\tif( decayExponent > 0.0 ) {\\\\n#if defined ( PHYSICALLY_CORRECT_LIGHTS )\\\\n\\\\t\\\\tfloat distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\\\\n\\\\t\\\\tfloat maxDistanceCutoffFactor = pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\\\\n\\\\t\\\\treturn distanceFalloff * maxDistanceCutoffFactor;\\\\n#else\\\\n\\\\t\\\\treturn pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );\\\\n#endif\\\\n\\\\t}\\\\n\\\\treturn 1.0;\\\\n}\\\\nvec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {\\\\n\\\\treturn RECIPROCAL_PI * diffuseColor;\\\\n}\\\\nvec3 F_Schlick( const in vec3 specularColor, const in float dotLH ) {\\\\n\\\\tfloat fresnel = exp2( ( -5.55473 * dotLH - 6.98316 ) * dotLH );\\\\n\\\\treturn ( 1.0 - specularColor ) * fresnel + specularColor;\\\\n}\\\\nfloat G_GGX_Smith( const in float alpha, const in float dotNL, const in float dotNV ) {\\\\n\\\\tfloat a2 = pow2( alpha );\\\\n\\\\tfloat gl = dotNL + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\\\\n\\\\tfloat gv = dotNV + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\\\\n\\\\treturn 1.0 / ( gl * gv );\\\\n}\\\\nfloat G_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\\\\n\\\\tfloat a2 = pow2( alpha );\\\\n\\\\tfloat gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\\\\n\\\\tfloat gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\\\\n\\\\treturn 0.5 / max( gv + gl, EPSILON );\\\\n}\\\\nfloat D_GGX( const in float alpha, const in float dotNH ) {\\\\n\\\\tfloat a2 = pow2( alpha );\\\\n\\\\tfloat denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\\\\n\\\\treturn RECIPROCAL_PI * a2 / pow2( denom );\\\\n}\\\\nvec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float roughness ) {\\\\n\\\\tfloat alpha = pow2( roughness );\\\\n\\\\tvec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\\\\n\\\\tfloat dotNL = saturate( dot( geometry.normal, incidentLight.direction ) );\\\\n\\\\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\\\\n\\\\tfloat dotNH = saturate( dot( geometry.normal, halfDir ) );\\\\n\\\\tfloat dotLH = saturate( dot( incidentLight.direction, halfDir ) );\\\\n\\\\tvec3 F = F_Schlick( specularColor, dotLH );\\\\n\\\\tfloat G = G_GGX_SmithCorrelated( alpha, dotNL, dotNV );\\\\n\\\\tfloat D = D_GGX( alpha, dotNH );\\\\n\\\\treturn F * ( G * D );\\\\n}\\\\nvec2 LTC_Uv( const in vec3 N, const in vec3 V, const in float roughness ) {\\\\n\\\\tconst float LUT_SIZE  = 64.0;\\\\n\\\\tconst float LUT_SCALE = ( LUT_SIZE - 1.0 ) / LUT_SIZE;\\\\n\\\\tconst float LUT_BIAS  = 0.5 / LUT_SIZE;\\\\n\\\\tfloat theta = acos( dot( N, V ) );\\\\n\\\\tvec2 uv = vec2(\\\\n\\\\t\\\\tsqrt( saturate( roughness ) ),\\\\n\\\\t\\\\tsaturate( theta / ( 0.5 * PI ) ) );\\\\n\\\\tuv = uv * LUT_SCALE + LUT_BIAS;\\\\n\\\\treturn uv;\\\\n}\\\\nfloat LTC_ClippedSphereFormFactor( const in vec3 f ) {\\\\n\\\\tfloat l = length( f );\\\\n\\\\treturn max( ( l * l + f.z ) / ( l + 1.0 ), 0.0 );\\\\n}\\\\nvec3 LTC_EdgeVectorFormFactor( const in vec3 v1, const in vec3 v2 ) {\\\\n\\\\tfloat x = dot( v1, v2 );\\\\n\\\\tfloat y = abs( x );\\\\n\\\\tfloat a = 0.86267 + (0.49788 + 0.01436 * y ) * y;\\\\n\\\\tfloat b = 3.45068 + (4.18814 + y) * y;\\\\n\\\\tfloat v = a / b;\\\\n\\\\tfloat theta_sintheta = (x > 0.0) ? v : 0.5 * inversesqrt( 1.0 - x * x ) - v;\\\\n\\\\treturn cross( v1, v2 ) * theta_sintheta;\\\\n}\\\\nvec3 LTC_Evaluate( const in vec3 N, const in vec3 V, const in vec3 P, const in mat3 mInv, const in vec3 rectCoords[ 4 ] ) {\\\\n\\\\tvec3 v1 = rectCoords[ 1 ] - rectCoords[ 0 ];\\\\n\\\\tvec3 v2 = rectCoords[ 3 ] - rectCoords[ 0 ];\\\\n\\\\tvec3 lightNormal = cross( v1, v2 );\\\\n\\\\tif( dot( lightNormal, P - rectCoords[ 0 ] ) < 0.0 ) return vec3( 0.0 );\\\\n\\\\tvec3 T1, T2;\\\\n\\\\tT1 = normalize( V - N * dot( V, N ) );\\\\n\\\\tT2 = - cross( N, T1 );\\\\n\\\\tmat3 mat = mInv * transposeMat3( mat3( T1, T2, N ) );\\\\n\\\\tvec3 coords[ 4 ];\\\\n\\\\tcoords[ 0 ] = mat * ( rectCoords[ 0 ] - P );\\\\n\\\\tcoords[ 1 ] = mat * ( rectCoords[ 1 ] - P );\\\\n\\\\tcoords[ 2 ] = mat * ( rectCoords[ 2 ] - P );\\\\n\\\\tcoords[ 3 ] = mat * ( rectCoords[ 3 ] - P );\\\\n\\\\tcoords[ 0 ] = normalize( coords[ 0 ] );\\\\n\\\\tcoords[ 1 ] = normalize( coords[ 1 ] );\\\\n\\\\tcoords[ 2 ] = normalize( coords[ 2 ] );\\\\n\\\\tcoords[ 3 ] = normalize( coords[ 3 ] );\\\\n\\\\tvec3 vectorFormFactor = vec3( 0.0 );\\\\n\\\\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 0 ], coords[ 1 ] );\\\\n\\\\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 1 ], coords[ 2 ] );\\\\n\\\\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 2 ], coords[ 3 ] );\\\\n\\\\tvectorFormFactor += LTC_EdgeVectorFormFactor( coords[ 3 ], coords[ 0 ] );\\\\n\\\\tvec3 result = vec3( LTC_ClippedSphereFormFactor( vectorFormFactor ) );\\\\n\\\\treturn result;\\\\n}\\\\nvec3 BRDF_Specular_GGX_Environment( const in GeometricContext geometry, const in vec3 specularColor, const in float roughness ) {\\\\n\\\\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\\\\n\\\\tconst vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\\\\n\\\\tconst vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\\\\n\\\\tvec4 r = roughness * c0 + c1;\\\\n\\\\tfloat a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\\\\n\\\\tvec2 AB = vec2( -1.04, 1.04 ) * a004 + r.zw;\\\\n\\\\treturn specularColor * AB.x + AB.y;\\\\n}\\\\nfloat G_BlinnPhong_Implicit( ) {\\\\n\\\\treturn 0.25;\\\\n}\\\\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\\\\n\\\\treturn RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\\\\n}\\\\nvec3 BRDF_Specular_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess ) {\\\\n\\\\tvec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\\\\n\\\\tfloat dotNH = saturate( dot( geometry.normal, halfDir ) );\\\\n\\\\tfloat dotLH = saturate( dot( incidentLight.direction, halfDir ) );\\\\n\\\\tvec3 F = F_Schlick( specularColor, dotLH );\\\\n\\\\tfloat G = G_BlinnPhong_Implicit( );\\\\n\\\\tfloat D = D_BlinnPhong( shininess, dotNH );\\\\n\\\\treturn F * ( G * D );\\\\n}\\\\nfloat GGXRoughnessToBlinnExponent( const in float ggxRoughness ) {\\\\n\\\\treturn ( 2.0 / pow2( ggxRoughness + 0.0001 ) - 2.0 );\\\\n}\\\\nfloat BlinnExponentToGGXRoughness( const in float blinnExponent ) {\\\\n\\\\treturn sqrt( 2.0 / ( blinnExponent + 2.0 ) );\\\\n}\\\\n\\\";\\n\\n\\tvar bumpmap_pars_fragment = \\\"#ifdef USE_BUMPMAP\\\\n\\\\tuniform sampler2D bumpMap;\\\\n\\\\tuniform float bumpScale;\\\\n\\\\tvec2 dHdxy_fwd() {\\\\n\\\\t\\\\tvec2 dSTdx = dFdx( vUv );\\\\n\\\\t\\\\tvec2 dSTdy = dFdy( vUv );\\\\n\\\\t\\\\tfloat Hll = bumpScale * texture2D( bumpMap, vUv ).x;\\\\n\\\\t\\\\tfloat dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\\\\n\\\\t\\\\tfloat dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;\\\\n\\\\t\\\\treturn vec2( dBx, dBy );\\\\n\\\\t}\\\\n\\\\tvec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy ) {\\\\n\\\\t\\\\tvec3 vSigmaX = vec3( dFdx( surf_pos.x ), dFdx( surf_pos.y ), dFdx( surf_pos.z ) );\\\\n\\\\t\\\\tvec3 vSigmaY = vec3( dFdy( surf_pos.x ), dFdy( surf_pos.y ), dFdy( surf_pos.z ) );\\\\n\\\\t\\\\tvec3 vN = surf_norm;\\\\n\\\\t\\\\tvec3 R1 = cross( vSigmaY, vN );\\\\n\\\\t\\\\tvec3 R2 = cross( vN, vSigmaX );\\\\n\\\\t\\\\tfloat fDet = dot( vSigmaX, R1 );\\\\n\\\\t\\\\tvec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\\\\n\\\\t\\\\treturn normalize( abs( fDet ) * surf_norm - vGrad );\\\\n\\\\t}\\\\n#endif\\\\n\\\";\\n\\n\\tvar clipping_planes_fragment = \\\"#if NUM_CLIPPING_PLANES > 0\\\\n\\\\tfor ( int i = 0; i < UNION_CLIPPING_PLANES; ++ i ) {\\\\n\\\\t\\\\tvec4 plane = clippingPlanes[ i ];\\\\n\\\\t\\\\tif ( dot( vViewPosition, plane.xyz ) > plane.w ) discard;\\\\n\\\\t}\\\\n\\\\t\\\\t\\\\n\\\\t#if UNION_CLIPPING_PLANES < NUM_CLIPPING_PLANES\\\\n\\\\t\\\\tbool clipped = true;\\\\n\\\\t\\\\tfor ( int i = UNION_CLIPPING_PLANES; i < NUM_CLIPPING_PLANES; ++ i ) {\\\\n\\\\t\\\\t\\\\tvec4 plane = clippingPlanes[ i ];\\\\n\\\\t\\\\t\\\\tclipped = ( dot( vViewPosition, plane.xyz ) > plane.w ) && clipped;\\\\n\\\\t\\\\t}\\\\n\\\\t\\\\tif ( clipped ) discard;\\\\n\\\\t\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar clipping_planes_pars_fragment = \\\"#if NUM_CLIPPING_PLANES > 0\\\\n\\\\t#if ! defined( PHYSICAL ) && ! defined( PHONG )\\\\n\\\\t\\\\tvarying vec3 vViewPosition;\\\\n\\\\t#endif\\\\n\\\\tuniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\\\\n#endif\\\\n\\\";\\n\\n\\tvar clipping_planes_pars_vertex = \\\"#if NUM_CLIPPING_PLANES > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )\\\\n\\\\tvarying vec3 vViewPosition;\\\\n#endif\\\\n\\\";\\n\\n\\tvar clipping_planes_vertex = \\\"#if NUM_CLIPPING_PLANES > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )\\\\n\\\\tvViewPosition = - mvPosition.xyz;\\\\n#endif\\\\n\\\";\\n\\n\\tvar color_fragment = \\\"#ifdef USE_COLOR\\\\n\\\\tdiffuseColor.rgb *= vColor;\\\\n#endif\\\";\\n\\n\\tvar color_pars_fragment = \\\"#ifdef USE_COLOR\\\\n\\\\tvarying vec3 vColor;\\\\n#endif\\\\n\\\";\\n\\n\\tvar color_pars_vertex = \\\"#ifdef USE_COLOR\\\\n\\\\tvarying vec3 vColor;\\\\n#endif\\\";\\n\\n\\tvar color_vertex = \\\"#ifdef USE_COLOR\\\\n\\\\tvColor.xyz = color.xyz;\\\\n#endif\\\";\\n\\n\\tvar common = \\\"#define PI 3.14159265359\\\\n#define PI2 6.28318530718\\\\n#define PI_HALF 1.5707963267949\\\\n#define RECIPROCAL_PI 0.31830988618\\\\n#define RECIPROCAL_PI2 0.15915494\\\\n#define LOG2 1.442695\\\\n#define EPSILON 1e-6\\\\n#define saturate(a) clamp( a, 0.0, 1.0 )\\\\n#define whiteCompliment(a) ( 1.0 - saturate( a ) )\\\\nfloat pow2( const in float x ) { return x*x; }\\\\nfloat pow3( const in float x ) { return x*x*x; }\\\\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\\\\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\\\\nhighp float rand( const in vec2 uv ) {\\\\n\\\\tconst highp float a = 12.9898, b = 78.233, c = 43758.5453;\\\\n\\\\thighp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\\\\n\\\\treturn fract(sin(sn) * c);\\\\n}\\\\nstruct IncidentLight {\\\\n\\\\tvec3 color;\\\\n\\\\tvec3 direction;\\\\n\\\\tbool visible;\\\\n};\\\\nstruct ReflectedLight {\\\\n\\\\tvec3 directDiffuse;\\\\n\\\\tvec3 directSpecular;\\\\n\\\\tvec3 indirectDiffuse;\\\\n\\\\tvec3 indirectSpecular;\\\\n};\\\\nstruct GeometricContext {\\\\n\\\\tvec3 position;\\\\n\\\\tvec3 normal;\\\\n\\\\tvec3 viewDir;\\\\n};\\\\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\\\\n\\\\treturn normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\\\\n}\\\\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\\\\n\\\\treturn normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\\\\n}\\\\nvec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\\\\n\\\\tfloat distance = dot( planeNormal, point - pointOnPlane );\\\\n\\\\treturn - distance * planeNormal + point;\\\\n}\\\\nfloat sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\\\\n\\\\treturn sign( dot( point - pointOnPlane, planeNormal ) );\\\\n}\\\\nvec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {\\\\n\\\\treturn lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;\\\\n}\\\\nmat3 transposeMat3( const in mat3 m ) {\\\\n\\\\tmat3 tmp;\\\\n\\\\ttmp[ 0 ] = vec3( m[ 0 ].x, m[ 1 ].x, m[ 2 ].x );\\\\n\\\\ttmp[ 1 ] = vec3( m[ 0 ].y, m[ 1 ].y, m[ 2 ].y );\\\\n\\\\ttmp[ 2 ] = vec3( m[ 0 ].z, m[ 1 ].z, m[ 2 ].z );\\\\n\\\\treturn tmp;\\\\n}\\\\nfloat linearToRelativeLuminance( const in vec3 color ) {\\\\n\\\\tvec3 weights = vec3( 0.2126, 0.7152, 0.0722 );\\\\n\\\\treturn dot( weights, color.rgb );\\\\n}\\\\n\\\";\\n\\n\\tvar cube_uv_reflection_fragment = \\\"#ifdef ENVMAP_TYPE_CUBE_UV\\\\n#define cubeUV_textureSize (1024.0)\\\\nint getFaceFromDirection(vec3 direction) {\\\\n\\\\tvec3 absDirection = abs(direction);\\\\n\\\\tint face = -1;\\\\n\\\\tif( absDirection.x > absDirection.z ) {\\\\n\\\\t\\\\tif(absDirection.x > absDirection.y )\\\\n\\\\t\\\\t\\\\tface = direction.x > 0.0 ? 0 : 3;\\\\n\\\\t\\\\telse\\\\n\\\\t\\\\t\\\\tface = direction.y > 0.0 ? 1 : 4;\\\\n\\\\t}\\\\n\\\\telse {\\\\n\\\\t\\\\tif(absDirection.z > absDirection.y )\\\\n\\\\t\\\\t\\\\tface = direction.z > 0.0 ? 2 : 5;\\\\n\\\\t\\\\telse\\\\n\\\\t\\\\t\\\\tface = direction.y > 0.0 ? 1 : 4;\\\\n\\\\t}\\\\n\\\\treturn face;\\\\n}\\\\n#define cubeUV_maxLods1  (log2(cubeUV_textureSize*0.25) - 1.0)\\\\n#define cubeUV_rangeClamp (exp2((6.0 - 1.0) * 2.0))\\\\nvec2 MipLevelInfo( vec3 vec, float roughnessLevel, float roughness ) {\\\\n\\\\tfloat scale = exp2(cubeUV_maxLods1 - roughnessLevel);\\\\n\\\\tfloat dxRoughness = dFdx(roughness);\\\\n\\\\tfloat dyRoughness = dFdy(roughness);\\\\n\\\\tvec3 dx = dFdx( vec * scale * dxRoughness );\\\\n\\\\tvec3 dy = dFdy( vec * scale * dyRoughness );\\\\n\\\\tfloat d = max( dot( dx, dx ), dot( dy, dy ) );\\\\n\\\\td = clamp(d, 1.0, cubeUV_rangeClamp);\\\\n\\\\tfloat mipLevel = 0.5 * log2(d);\\\\n\\\\treturn vec2(floor(mipLevel), fract(mipLevel));\\\\n}\\\\n#define cubeUV_maxLods2 (log2(cubeUV_textureSize*0.25) - 2.0)\\\\n#define cubeUV_rcpTextureSize (1.0 / cubeUV_textureSize)\\\\nvec2 getCubeUV(vec3 direction, float roughnessLevel, float mipLevel) {\\\\n\\\\tmipLevel = roughnessLevel > cubeUV_maxLods2 - 3.0 ? 0.0 : mipLevel;\\\\n\\\\tfloat a = 16.0 * cubeUV_rcpTextureSize;\\\\n\\\\tvec2 exp2_packed = exp2( vec2( roughnessLevel, mipLevel ) );\\\\n\\\\tvec2 rcp_exp2_packed = vec2( 1.0 ) / exp2_packed;\\\\n\\\\tfloat powScale = exp2_packed.x * exp2_packed.y;\\\\n\\\\tfloat scale = rcp_exp2_packed.x * rcp_exp2_packed.y * 0.25;\\\\n\\\\tfloat mipOffset = 0.75*(1.0 - rcp_exp2_packed.y) * rcp_exp2_packed.x;\\\\n\\\\tbool bRes = mipLevel == 0.0;\\\\n\\\\tscale =  bRes && (scale < a) ? a : scale;\\\\n\\\\tvec3 r;\\\\n\\\\tvec2 offset;\\\\n\\\\tint face = getFaceFromDirection(direction);\\\\n\\\\tfloat rcpPowScale = 1.0 / powScale;\\\\n\\\\tif( face == 0) {\\\\n\\\\t\\\\tr = vec3(direction.x, -direction.z, direction.y);\\\\n\\\\t\\\\toffset = vec2(0.0+mipOffset,0.75 * rcpPowScale);\\\\n\\\\t\\\\toffset.y = bRes && (offset.y < 2.0*a) ? a : offset.y;\\\\n\\\\t}\\\\n\\\\telse if( face == 1) {\\\\n\\\\t\\\\tr = vec3(direction.y, direction.x, direction.z);\\\\n\\\\t\\\\toffset = vec2(scale+mipOffset, 0.75 * rcpPowScale);\\\\n\\\\t\\\\toffset.y = bRes && (offset.y < 2.0*a) ? a : offset.y;\\\\n\\\\t}\\\\n\\\\telse if( face == 2) {\\\\n\\\\t\\\\tr = vec3(direction.z, direction.x, direction.y);\\\\n\\\\t\\\\toffset = vec2(2.0*scale+mipOffset, 0.75 * rcpPowScale);\\\\n\\\\t\\\\toffset.y = bRes && (offset.y < 2.0*a) ? a : offset.y;\\\\n\\\\t}\\\\n\\\\telse if( face == 3) {\\\\n\\\\t\\\\tr = vec3(direction.x, direction.z, direction.y);\\\\n\\\\t\\\\toffset = vec2(0.0+mipOffset,0.5 * rcpPowScale);\\\\n\\\\t\\\\toffset.y = bRes && (offset.y < 2.0*a) ? 0.0 : offset.y;\\\\n\\\\t}\\\\n\\\\telse if( face == 4) {\\\\n\\\\t\\\\tr = vec3(direction.y, direction.x, -direction.z);\\\\n\\\\t\\\\toffset = vec2(scale+mipOffset, 0.5 * rcpPowScale);\\\\n\\\\t\\\\toffset.y = bRes && (offset.y < 2.0*a) ? 0.0 : offset.y;\\\\n\\\\t}\\\\n\\\\telse {\\\\n\\\\t\\\\tr = vec3(direction.z, -direction.x, direction.y);\\\\n\\\\t\\\\toffset = vec2(2.0*scale+mipOffset, 0.5 * rcpPowScale);\\\\n\\\\t\\\\toffset.y = bRes && (offset.y < 2.0*a) ? 0.0 : offset.y;\\\\n\\\\t}\\\\n\\\\tr = normalize(r);\\\\n\\\\tfloat texelOffset = 0.5 * cubeUV_rcpTextureSize;\\\\n\\\\tvec2 s = ( r.yz / abs( r.x ) + vec2( 1.0 ) ) * 0.5;\\\\n\\\\tvec2 base = offset + vec2( texelOffset );\\\\n\\\\treturn base + s * ( scale - 2.0 * texelOffset );\\\\n}\\\\n#define cubeUV_maxLods3 (log2(cubeUV_textureSize*0.25) - 3.0)\\\\nvec4 textureCubeUV(vec3 reflectedDirection, float roughness ) {\\\\n\\\\tfloat roughnessVal = roughness* cubeUV_maxLods3;\\\\n\\\\tfloat r1 = floor(roughnessVal);\\\\n\\\\tfloat r2 = r1 + 1.0;\\\\n\\\\tfloat t = fract(roughnessVal);\\\\n\\\\tvec2 mipInfo = MipLevelInfo(reflectedDirection, r1, roughness);\\\\n\\\\tfloat s = mipInfo.y;\\\\n\\\\tfloat level0 = mipInfo.x;\\\\n\\\\tfloat level1 = level0 + 1.0;\\\\n\\\\tlevel1 = level1 > 5.0 ? 5.0 : level1;\\\\n\\\\tlevel0 += min( floor( s + 0.5 ), 5.0 );\\\\n\\\\tvec2 uv_10 = getCubeUV(reflectedDirection, r1, level0);\\\\n\\\\tvec4 color10 = envMapTexelToLinear(texture2D(envMap, uv_10));\\\\n\\\\tvec2 uv_20 = getCubeUV(reflectedDirection, r2, level0);\\\\n\\\\tvec4 color20 = envMapTexelToLinear(texture2D(envMap, uv_20));\\\\n\\\\tvec4 result = mix(color10, color20, t);\\\\n\\\\treturn vec4(result.rgb, 1.0);\\\\n}\\\\n#endif\\\\n\\\";\\n\\n\\tvar defaultnormal_vertex = \\\"vec3 transformedNormal = normalMatrix * objectNormal;\\\\n#ifdef FLIP_SIDED\\\\n\\\\ttransformedNormal = - transformedNormal;\\\\n#endif\\\\n\\\";\\n\\n\\tvar displacementmap_pars_vertex = \\\"#ifdef USE_DISPLACEMENTMAP\\\\n\\\\tuniform sampler2D displacementMap;\\\\n\\\\tuniform float displacementScale;\\\\n\\\\tuniform float displacementBias;\\\\n#endif\\\\n\\\";\\n\\n\\tvar displacementmap_vertex = \\\"#ifdef USE_DISPLACEMENTMAP\\\\n\\\\ttransformed += normalize( objectNormal ) * ( texture2D( displacementMap, uv ).x * displacementScale + displacementBias );\\\\n#endif\\\\n\\\";\\n\\n\\tvar emissivemap_fragment = \\\"#ifdef USE_EMISSIVEMAP\\\\n\\\\tvec4 emissiveColor = texture2D( emissiveMap, vUv );\\\\n\\\\temissiveColor.rgb = emissiveMapTexelToLinear( emissiveColor ).rgb;\\\\n\\\\ttotalEmissiveRadiance *= emissiveColor.rgb;\\\\n#endif\\\\n\\\";\\n\\n\\tvar emissivemap_pars_fragment = \\\"#ifdef USE_EMISSIVEMAP\\\\n\\\\tuniform sampler2D emissiveMap;\\\\n#endif\\\\n\\\";\\n\\n\\tvar encodings_fragment = \\\"  gl_FragColor = linearToOutputTexel( gl_FragColor );\\\\n\\\";\\n\\n\\tvar encodings_pars_fragment = \\\"\\\\nvec4 LinearToLinear( in vec4 value ) {\\\\n\\\\treturn value;\\\\n}\\\\nvec4 GammaToLinear( in vec4 value, in float gammaFactor ) {\\\\n\\\\treturn vec4( pow( value.xyz, vec3( gammaFactor ) ), value.w );\\\\n}\\\\nvec4 LinearToGamma( in vec4 value, in float gammaFactor ) {\\\\n\\\\treturn vec4( pow( value.xyz, vec3( 1.0 / gammaFactor ) ), value.w );\\\\n}\\\\nvec4 sRGBToLinear( in vec4 value ) {\\\\n\\\\treturn vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.w );\\\\n}\\\\nvec4 LinearTosRGB( in vec4 value ) {\\\\n\\\\treturn vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.w );\\\\n}\\\\nvec4 RGBEToLinear( in vec4 value ) {\\\\n\\\\treturn vec4( value.rgb * exp2( value.a * 255.0 - 128.0 ), 1.0 );\\\\n}\\\\nvec4 LinearToRGBE( in vec4 value ) {\\\\n\\\\tfloat maxComponent = max( max( value.r, value.g ), value.b );\\\\n\\\\tfloat fExp = clamp( ceil( log2( maxComponent ) ), -128.0, 127.0 );\\\\n\\\\treturn vec4( value.rgb / exp2( fExp ), ( fExp + 128.0 ) / 255.0 );\\\\n}\\\\nvec4 RGBMToLinear( in vec4 value, in float maxRange ) {\\\\n\\\\treturn vec4( value.xyz * value.w * maxRange, 1.0 );\\\\n}\\\\nvec4 LinearToRGBM( in vec4 value, in float maxRange ) {\\\\n\\\\tfloat maxRGB = max( value.x, max( value.g, value.b ) );\\\\n\\\\tfloat M      = clamp( maxRGB / maxRange, 0.0, 1.0 );\\\\n\\\\tM            = ceil( M * 255.0 ) / 255.0;\\\\n\\\\treturn vec4( value.rgb / ( M * maxRange ), M );\\\\n}\\\\nvec4 RGBDToLinear( in vec4 value, in float maxRange ) {\\\\n\\\\treturn vec4( value.rgb * ( ( maxRange / 255.0 ) / value.a ), 1.0 );\\\\n}\\\\nvec4 LinearToRGBD( in vec4 value, in float maxRange ) {\\\\n\\\\tfloat maxRGB = max( value.x, max( value.g, value.b ) );\\\\n\\\\tfloat D      = max( maxRange / maxRGB, 1.0 );\\\\n\\\\tD            = min( floor( D ) / 255.0, 1.0 );\\\\n\\\\treturn vec4( value.rgb * ( D * ( 255.0 / maxRange ) ), D );\\\\n}\\\\nconst mat3 cLogLuvM = mat3( 0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969 );\\\\nvec4 LinearToLogLuv( in vec4 value )  {\\\\n\\\\tvec3 Xp_Y_XYZp = value.rgb * cLogLuvM;\\\\n\\\\tXp_Y_XYZp = max(Xp_Y_XYZp, vec3(1e-6, 1e-6, 1e-6));\\\\n\\\\tvec4 vResult;\\\\n\\\\tvResult.xy = Xp_Y_XYZp.xy / Xp_Y_XYZp.z;\\\\n\\\\tfloat Le = 2.0 * log2(Xp_Y_XYZp.y) + 127.0;\\\\n\\\\tvResult.w = fract(Le);\\\\n\\\\tvResult.z = (Le - (floor(vResult.w*255.0))/255.0)/255.0;\\\\n\\\\treturn vResult;\\\\n}\\\\nconst mat3 cLogLuvInverseM = mat3( 6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268 );\\\\nvec4 LogLuvToLinear( in vec4 value ) {\\\\n\\\\tfloat Le = value.z * 255.0 + value.w;\\\\n\\\\tvec3 Xp_Y_XYZp;\\\\n\\\\tXp_Y_XYZp.y = exp2((Le - 127.0) / 2.0);\\\\n\\\\tXp_Y_XYZp.z = Xp_Y_XYZp.y / value.y;\\\\n\\\\tXp_Y_XYZp.x = value.x * Xp_Y_XYZp.z;\\\\n\\\\tvec3 vRGB = Xp_Y_XYZp.rgb * cLogLuvInverseM;\\\\n\\\\treturn vec4( max(vRGB, 0.0), 1.0 );\\\\n}\\\\n\\\";\\n\\n\\tvar envmap_fragment = \\\"#ifdef USE_ENVMAP\\\\n\\\\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\\\\n\\\\t\\\\tvec3 cameraToVertex = normalize( vWorldPosition - cameraPosition );\\\\n\\\\t\\\\tvec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\\\\n\\\\t\\\\t#ifdef ENVMAP_MODE_REFLECTION\\\\n\\\\t\\\\t\\\\tvec3 reflectVec = reflect( cameraToVertex, worldNormal );\\\\n\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\tvec3 reflectVec = refract( cameraToVertex, worldNormal, refractionRatio );\\\\n\\\\t\\\\t#endif\\\\n\\\\t#else\\\\n\\\\t\\\\tvec3 reflectVec = vReflect;\\\\n\\\\t#endif\\\\n\\\\t#ifdef ENVMAP_TYPE_CUBE\\\\n\\\\t\\\\tvec4 envColor = textureCube( envMap, vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\\\\n\\\\t#elif defined( ENVMAP_TYPE_EQUIREC )\\\\n\\\\t\\\\tvec2 sampleUV;\\\\n\\\\t\\\\treflectVec = normalize( reflectVec );\\\\n\\\\t\\\\tsampleUV.y = asin( clamp( reflectVec.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\\\\n\\\\t\\\\tsampleUV.x = atan( reflectVec.z, reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\\\\n\\\\t\\\\tvec4 envColor = texture2D( envMap, sampleUV );\\\\n\\\\t#elif defined( ENVMAP_TYPE_SPHERE )\\\\n\\\\t\\\\treflectVec = normalize( reflectVec );\\\\n\\\\t\\\\tvec3 reflectView = normalize( ( viewMatrix * vec4( reflectVec, 0.0 ) ).xyz + vec3( 0.0, 0.0, 1.0 ) );\\\\n\\\\t\\\\tvec4 envColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5 );\\\\n\\\\t#else\\\\n\\\\t\\\\tvec4 envColor = vec4( 0.0 );\\\\n\\\\t#endif\\\\n\\\\tenvColor = envMapTexelToLinear( envColor );\\\\n\\\\t#ifdef ENVMAP_BLENDING_MULTIPLY\\\\n\\\\t\\\\toutgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\\\\n\\\\t#elif defined( ENVMAP_BLENDING_MIX )\\\\n\\\\t\\\\toutgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\\\\n\\\\t#elif defined( ENVMAP_BLENDING_ADD )\\\\n\\\\t\\\\toutgoingLight += envColor.xyz * specularStrength * reflectivity;\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar envmap_pars_fragment = \\\"#if defined( USE_ENVMAP ) || defined( PHYSICAL )\\\\n\\\\tuniform float reflectivity;\\\\n\\\\tuniform float envMapIntensity;\\\\n#endif\\\\n#ifdef USE_ENVMAP\\\\n\\\\t#if ! defined( PHYSICAL ) && ( defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) )\\\\n\\\\t\\\\tvarying vec3 vWorldPosition;\\\\n\\\\t#endif\\\\n\\\\t#ifdef ENVMAP_TYPE_CUBE\\\\n\\\\t\\\\tuniform samplerCube envMap;\\\\n\\\\t#else\\\\n\\\\t\\\\tuniform sampler2D envMap;\\\\n\\\\t#endif\\\\n\\\\tuniform float flipEnvMap;\\\\n\\\\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( PHYSICAL )\\\\n\\\\t\\\\tuniform float refractionRatio;\\\\n\\\\t#else\\\\n\\\\t\\\\tvarying vec3 vReflect;\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar envmap_pars_vertex = \\\"#ifdef USE_ENVMAP\\\\n\\\\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\\\\n\\\\t\\\\tvarying vec3 vWorldPosition;\\\\n\\\\t#else\\\\n\\\\t\\\\tvarying vec3 vReflect;\\\\n\\\\t\\\\tuniform float refractionRatio;\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar envmap_vertex = \\\"#ifdef USE_ENVMAP\\\\n\\\\t#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\\\\n\\\\t\\\\tvWorldPosition = worldPosition.xyz;\\\\n\\\\t#else\\\\n\\\\t\\\\tvec3 cameraToVertex = normalize( worldPosition.xyz - cameraPosition );\\\\n\\\\t\\\\tvec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\\\\n\\\\t\\\\t#ifdef ENVMAP_MODE_REFLECTION\\\\n\\\\t\\\\t\\\\tvReflect = reflect( cameraToVertex, worldNormal );\\\\n\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\tvReflect = refract( cameraToVertex, worldNormal, refractionRatio );\\\\n\\\\t\\\\t#endif\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar fog_vertex = \\\"\\\\n#ifdef USE_FOG\\\\nfogDepth = -mvPosition.z;\\\\n#endif\\\";\\n\\n\\tvar fog_pars_vertex = \\\"#ifdef USE_FOG\\\\n  varying float fogDepth;\\\\n#endif\\\\n\\\";\\n\\n\\tvar fog_fragment = \\\"#ifdef USE_FOG\\\\n\\\\t#ifdef FOG_EXP2\\\\n\\\\t\\\\tfloat fogFactor = whiteCompliment( exp2( - fogDensity * fogDensity * fogDepth * fogDepth * LOG2 ) );\\\\n\\\\t#else\\\\n\\\\t\\\\tfloat fogFactor = smoothstep( fogNear, fogFar, fogDepth );\\\\n\\\\t#endif\\\\n\\\\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\\\\n#endif\\\\n\\\";\\n\\n\\tvar fog_pars_fragment = \\\"#ifdef USE_FOG\\\\n\\\\tuniform vec3 fogColor;\\\\n\\\\tvarying float fogDepth;\\\\n\\\\t#ifdef FOG_EXP2\\\\n\\\\t\\\\tuniform float fogDensity;\\\\n\\\\t#else\\\\n\\\\t\\\\tuniform float fogNear;\\\\n\\\\t\\\\tuniform float fogFar;\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar gradientmap_pars_fragment = \\\"#ifdef TOON\\\\n\\\\tuniform sampler2D gradientMap;\\\\n\\\\tvec3 getGradientIrradiance( vec3 normal, vec3 lightDirection ) {\\\\n\\\\t\\\\tfloat dotNL = dot( normal, lightDirection );\\\\n\\\\t\\\\tvec2 coord = vec2( dotNL * 0.5 + 0.5, 0.0 );\\\\n\\\\t\\\\t#ifdef USE_GRADIENTMAP\\\\n\\\\t\\\\t\\\\treturn texture2D( gradientMap, coord ).rgb;\\\\n\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\treturn ( coord.x < 0.7 ) ? vec3( 0.7 ) : vec3( 1.0 );\\\\n\\\\t\\\\t#endif\\\\n\\\\t}\\\\n#endif\\\\n\\\";\\n\\n\\tvar lightmap_fragment = \\\"#ifdef USE_LIGHTMAP\\\\n\\\\treflectedLight.indirectDiffuse += PI * texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\\\\n#endif\\\\n\\\";\\n\\n\\tvar lightmap_pars_fragment = \\\"#ifdef USE_LIGHTMAP\\\\n\\\\tuniform sampler2D lightMap;\\\\n\\\\tuniform float lightMapIntensity;\\\\n#endif\\\";\\n\\n\\tvar lights_lambert_vertex = \\\"vec3 diffuse = vec3( 1.0 );\\\\nGeometricContext geometry;\\\\ngeometry.position = mvPosition.xyz;\\\\ngeometry.normal = normalize( transformedNormal );\\\\ngeometry.viewDir = normalize( -mvPosition.xyz );\\\\nGeometricContext backGeometry;\\\\nbackGeometry.position = geometry.position;\\\\nbackGeometry.normal = -geometry.normal;\\\\nbackGeometry.viewDir = geometry.viewDir;\\\\nvLightFront = vec3( 0.0 );\\\\n#ifdef DOUBLE_SIDED\\\\n\\\\tvLightBack = vec3( 0.0 );\\\\n#endif\\\\nIncidentLight directLight;\\\\nfloat dotNL;\\\\nvec3 directLightColor_Diffuse;\\\\n#if NUM_POINT_LIGHTS > 0\\\\n\\\\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tgetPointDirectLightIrradiance( pointLights[ i ], geometry, directLight );\\\\n\\\\t\\\\tdotNL = dot( geometry.normal, directLight.direction );\\\\n\\\\t\\\\tdirectLightColor_Diffuse = PI * directLight.color;\\\\n\\\\t\\\\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\\\\n\\\\t\\\\t#ifdef DOUBLE_SIDED\\\\n\\\\t\\\\t\\\\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\\\\n\\\\t\\\\t#endif\\\\n\\\\t}\\\\n#endif\\\\n#if NUM_SPOT_LIGHTS > 0\\\\n\\\\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tgetSpotDirectLightIrradiance( spotLights[ i ], geometry, directLight );\\\\n\\\\t\\\\tdotNL = dot( geometry.normal, directLight.direction );\\\\n\\\\t\\\\tdirectLightColor_Diffuse = PI * directLight.color;\\\\n\\\\t\\\\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\\\\n\\\\t\\\\t#ifdef DOUBLE_SIDED\\\\n\\\\t\\\\t\\\\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\\\\n\\\\t\\\\t#endif\\\\n\\\\t}\\\\n#endif\\\\n#if NUM_DIR_LIGHTS > 0\\\\n\\\\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tgetDirectionalDirectLightIrradiance( directionalLights[ i ], geometry, directLight );\\\\n\\\\t\\\\tdotNL = dot( geometry.normal, directLight.direction );\\\\n\\\\t\\\\tdirectLightColor_Diffuse = PI * directLight.color;\\\\n\\\\t\\\\tvLightFront += saturate( dotNL ) * directLightColor_Diffuse;\\\\n\\\\t\\\\t#ifdef DOUBLE_SIDED\\\\n\\\\t\\\\t\\\\tvLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\\\\n\\\\t\\\\t#endif\\\\n\\\\t}\\\\n#endif\\\\n#if NUM_HEMI_LIGHTS > 0\\\\n\\\\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tvLightFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\\\\n\\\\t\\\\t#ifdef DOUBLE_SIDED\\\\n\\\\t\\\\t\\\\tvLightBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry );\\\\n\\\\t\\\\t#endif\\\\n\\\\t}\\\\n#endif\\\\n\\\";\\n\\n\\tvar lights_pars = \\\"uniform vec3 ambientLightColor;\\\\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\\\\n\\\\tvec3 irradiance = ambientLightColor;\\\\n\\\\t#ifndef PHYSICALLY_CORRECT_LIGHTS\\\\n\\\\t\\\\tirradiance *= PI;\\\\n\\\\t#endif\\\\n\\\\treturn irradiance;\\\\n}\\\\n#if NUM_DIR_LIGHTS > 0\\\\n\\\\tstruct DirectionalLight {\\\\n\\\\t\\\\tvec3 direction;\\\\n\\\\t\\\\tvec3 color;\\\\n\\\\t\\\\tint shadow;\\\\n\\\\t\\\\tfloat shadowBias;\\\\n\\\\t\\\\tfloat shadowRadius;\\\\n\\\\t\\\\tvec2 shadowMapSize;\\\\n\\\\t};\\\\n\\\\tuniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\\\\n\\\\tvoid getDirectionalDirectLightIrradiance( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight directLight ) {\\\\n\\\\t\\\\tdirectLight.color = directionalLight.color;\\\\n\\\\t\\\\tdirectLight.direction = directionalLight.direction;\\\\n\\\\t\\\\tdirectLight.visible = true;\\\\n\\\\t}\\\\n#endif\\\\n#if NUM_POINT_LIGHTS > 0\\\\n\\\\tstruct PointLight {\\\\n\\\\t\\\\tvec3 position;\\\\n\\\\t\\\\tvec3 color;\\\\n\\\\t\\\\tfloat distance;\\\\n\\\\t\\\\tfloat decay;\\\\n\\\\t\\\\tint shadow;\\\\n\\\\t\\\\tfloat shadowBias;\\\\n\\\\t\\\\tfloat shadowRadius;\\\\n\\\\t\\\\tvec2 shadowMapSize;\\\\n\\\\t\\\\tfloat shadowCameraNear;\\\\n\\\\t\\\\tfloat shadowCameraFar;\\\\n\\\\t};\\\\n\\\\tuniform PointLight pointLights[ NUM_POINT_LIGHTS ];\\\\n\\\\tvoid getPointDirectLightIrradiance( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight directLight ) {\\\\n\\\\t\\\\tvec3 lVector = pointLight.position - geometry.position;\\\\n\\\\t\\\\tdirectLight.direction = normalize( lVector );\\\\n\\\\t\\\\tfloat lightDistance = length( lVector );\\\\n\\\\t\\\\tdirectLight.color = pointLight.color;\\\\n\\\\t\\\\tdirectLight.color *= punctualLightIntensityToIrradianceFactor( lightDistance, pointLight.distance, pointLight.decay );\\\\n\\\\t\\\\tdirectLight.visible = ( directLight.color != vec3( 0.0 ) );\\\\n\\\\t}\\\\n#endif\\\\n#if NUM_SPOT_LIGHTS > 0\\\\n\\\\tstruct SpotLight {\\\\n\\\\t\\\\tvec3 position;\\\\n\\\\t\\\\tvec3 direction;\\\\n\\\\t\\\\tvec3 color;\\\\n\\\\t\\\\tfloat distance;\\\\n\\\\t\\\\tfloat decay;\\\\n\\\\t\\\\tfloat coneCos;\\\\n\\\\t\\\\tfloat penumbraCos;\\\\n\\\\t\\\\tint shadow;\\\\n\\\\t\\\\tfloat shadowBias;\\\\n\\\\t\\\\tfloat shadowRadius;\\\\n\\\\t\\\\tvec2 shadowMapSize;\\\\n\\\\t};\\\\n\\\\tuniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\\\\n\\\\tvoid getSpotDirectLightIrradiance( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight directLight  ) {\\\\n\\\\t\\\\tvec3 lVector = spotLight.position - geometry.position;\\\\n\\\\t\\\\tdirectLight.direction = normalize( lVector );\\\\n\\\\t\\\\tfloat lightDistance = length( lVector );\\\\n\\\\t\\\\tfloat angleCos = dot( directLight.direction, spotLight.direction );\\\\n\\\\t\\\\tif ( angleCos > spotLight.coneCos ) {\\\\n\\\\t\\\\t\\\\tfloat spotEffect = smoothstep( spotLight.coneCos, spotLight.penumbraCos, angleCos );\\\\n\\\\t\\\\t\\\\tdirectLight.color = spotLight.color;\\\\n\\\\t\\\\t\\\\tdirectLight.color *= spotEffect * punctualLightIntensityToIrradianceFactor( lightDistance, spotLight.distance, spotLight.decay );\\\\n\\\\t\\\\t\\\\tdirectLight.visible = true;\\\\n\\\\t\\\\t} else {\\\\n\\\\t\\\\t\\\\tdirectLight.color = vec3( 0.0 );\\\\n\\\\t\\\\t\\\\tdirectLight.visible = false;\\\\n\\\\t\\\\t}\\\\n\\\\t}\\\\n#endif\\\\n#if NUM_RECT_AREA_LIGHTS > 0\\\\n\\\\tstruct RectAreaLight {\\\\n\\\\t\\\\tvec3 color;\\\\n\\\\t\\\\tvec3 position;\\\\n\\\\t\\\\tvec3 halfWidth;\\\\n\\\\t\\\\tvec3 halfHeight;\\\\n\\\\t};\\\\n\\\\tuniform sampler2D ltcMat;\\\\tuniform sampler2D ltcMag;\\\\n\\\\tuniform RectAreaLight rectAreaLights[ NUM_RECT_AREA_LIGHTS ];\\\\n#endif\\\\n#if NUM_HEMI_LIGHTS > 0\\\\n\\\\tstruct HemisphereLight {\\\\n\\\\t\\\\tvec3 direction;\\\\n\\\\t\\\\tvec3 skyColor;\\\\n\\\\t\\\\tvec3 groundColor;\\\\n\\\\t};\\\\n\\\\tuniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\\\\n\\\\tvec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in GeometricContext geometry ) {\\\\n\\\\t\\\\tfloat dotNL = dot( geometry.normal, hemiLight.direction );\\\\n\\\\t\\\\tfloat hemiDiffuseWeight = 0.5 * dotNL + 0.5;\\\\n\\\\t\\\\tvec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\\\\n\\\\t\\\\t#ifndef PHYSICALLY_CORRECT_LIGHTS\\\\n\\\\t\\\\t\\\\tirradiance *= PI;\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\treturn irradiance;\\\\n\\\\t}\\\\n#endif\\\\n#if defined( USE_ENVMAP ) && defined( PHYSICAL )\\\\n\\\\tvec3 getLightProbeIndirectIrradiance( const in GeometricContext geometry, const in int maxMIPLevel ) {\\\\n\\\\t\\\\tvec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );\\\\n\\\\t\\\\t#ifdef ENVMAP_TYPE_CUBE\\\\n\\\\t\\\\t\\\\tvec3 queryVec = vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\\\\n\\\\t\\\\t\\\\t#ifdef TEXTURE_LOD_EXT\\\\n\\\\t\\\\t\\\\t\\\\tvec4 envMapColor = textureCubeLodEXT( envMap, queryVec, float( maxMIPLevel ) );\\\\n\\\\t\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\t\\\\tvec4 envMapColor = textureCube( envMap, queryVec, float( maxMIPLevel ) );\\\\n\\\\t\\\\t\\\\t#endif\\\\n\\\\t\\\\t\\\\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\\\\n\\\\t\\\\t#elif defined( ENVMAP_TYPE_CUBE_UV )\\\\n\\\\t\\\\t\\\\tvec3 queryVec = vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\\\\n\\\\t\\\\t\\\\tvec4 envMapColor = textureCubeUV( queryVec, 1.0 );\\\\n\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\tvec4 envMapColor = vec4( 0.0 );\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\treturn PI * envMapColor.rgb * envMapIntensity;\\\\n\\\\t}\\\\n\\\\tfloat getSpecularMIPLevel( const in float blinnShininessExponent, const in int maxMIPLevel ) {\\\\n\\\\t\\\\tfloat maxMIPLevelScalar = float( maxMIPLevel );\\\\n\\\\t\\\\tfloat desiredMIPLevel = maxMIPLevelScalar + 0.79248 - 0.5 * log2( pow2( blinnShininessExponent ) + 1.0 );\\\\n\\\\t\\\\treturn clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );\\\\n\\\\t}\\\\n\\\\tvec3 getLightProbeIndirectRadiance( const in GeometricContext geometry, const in float blinnShininessExponent, const in int maxMIPLevel ) {\\\\n\\\\t\\\\t#ifdef ENVMAP_MODE_REFLECTION\\\\n\\\\t\\\\t\\\\tvec3 reflectVec = reflect( -geometry.viewDir, geometry.normal );\\\\n\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\tvec3 reflectVec = refract( -geometry.viewDir, geometry.normal, refractionRatio );\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\treflectVec = inverseTransformDirection( reflectVec, viewMatrix );\\\\n\\\\t\\\\tfloat specularMIPLevel = getSpecularMIPLevel( blinnShininessExponent, maxMIPLevel );\\\\n\\\\t\\\\t#ifdef ENVMAP_TYPE_CUBE\\\\n\\\\t\\\\t\\\\tvec3 queryReflectVec = vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\\\\n\\\\t\\\\t\\\\t#ifdef TEXTURE_LOD_EXT\\\\n\\\\t\\\\t\\\\t\\\\tvec4 envMapColor = textureCubeLodEXT( envMap, queryReflectVec, specularMIPLevel );\\\\n\\\\t\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\t\\\\tvec4 envMapColor = textureCube( envMap, queryReflectVec, specularMIPLevel );\\\\n\\\\t\\\\t\\\\t#endif\\\\n\\\\t\\\\t\\\\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\\\\n\\\\t\\\\t#elif defined( ENVMAP_TYPE_CUBE_UV )\\\\n\\\\t\\\\t\\\\tvec3 queryReflectVec = vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\\\\n\\\\t\\\\t\\\\tvec4 envMapColor = textureCubeUV(queryReflectVec, BlinnExponentToGGXRoughness(blinnShininessExponent));\\\\n\\\\t\\\\t#elif defined( ENVMAP_TYPE_EQUIREC )\\\\n\\\\t\\\\t\\\\tvec2 sampleUV;\\\\n\\\\t\\\\t\\\\tsampleUV.y = asin( clamp( reflectVec.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\\\\n\\\\t\\\\t\\\\tsampleUV.x = atan( reflectVec.z, reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\\\\n\\\\t\\\\t\\\\t#ifdef TEXTURE_LOD_EXT\\\\n\\\\t\\\\t\\\\t\\\\tvec4 envMapColor = texture2DLodEXT( envMap, sampleUV, specularMIPLevel );\\\\n\\\\t\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\t\\\\tvec4 envMapColor = texture2D( envMap, sampleUV, specularMIPLevel );\\\\n\\\\t\\\\t\\\\t#endif\\\\n\\\\t\\\\t\\\\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\\\\n\\\\t\\\\t#elif defined( ENVMAP_TYPE_SPHERE )\\\\n\\\\t\\\\t\\\\tvec3 reflectView = normalize( ( viewMatrix * vec4( reflectVec, 0.0 ) ).xyz + vec3( 0.0,0.0,1.0 ) );\\\\n\\\\t\\\\t\\\\t#ifdef TEXTURE_LOD_EXT\\\\n\\\\t\\\\t\\\\t\\\\tvec4 envMapColor = texture2DLodEXT( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\\\\n\\\\t\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\t\\\\tvec4 envMapColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\\\\n\\\\t\\\\t\\\\t#endif\\\\n\\\\t\\\\t\\\\tenvMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\treturn envMapColor.rgb * envMapIntensity;\\\\n\\\\t}\\\\n#endif\\\\n\\\";\\n\\n\\tvar lights_phong_fragment = \\\"BlinnPhongMaterial material;\\\\nmaterial.diffuseColor = diffuseColor.rgb;\\\\nmaterial.specularColor = specular;\\\\nmaterial.specularShininess = shininess;\\\\nmaterial.specularStrength = specularStrength;\\\\n\\\";\\n\\n\\tvar lights_phong_pars_fragment = \\\"varying vec3 vViewPosition;\\\\n#ifndef FLAT_SHADED\\\\n\\\\tvarying vec3 vNormal;\\\\n#endif\\\\nstruct BlinnPhongMaterial {\\\\n\\\\tvec3\\\\tdiffuseColor;\\\\n\\\\tvec3\\\\tspecularColor;\\\\n\\\\tfloat\\\\tspecularShininess;\\\\n\\\\tfloat\\\\tspecularStrength;\\\\n};\\\\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\\\\n\\\\t#ifdef TOON\\\\n\\\\t\\\\tvec3 irradiance = getGradientIrradiance( geometry.normal, directLight.direction ) * directLight.color;\\\\n\\\\t#else\\\\n\\\\t\\\\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\\\\n\\\\t\\\\tvec3 irradiance = dotNL * directLight.color;\\\\n\\\\t#endif\\\\n\\\\t#ifndef PHYSICALLY_CORRECT_LIGHTS\\\\n\\\\t\\\\tirradiance *= PI;\\\\n\\\\t#endif\\\\n\\\\treflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\\\\n\\\\treflectedLight.directSpecular += irradiance * BRDF_Specular_BlinnPhong( directLight, geometry, material.specularColor, material.specularShininess ) * material.specularStrength;\\\\n}\\\\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\\\\n\\\\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\\\\n}\\\\n#define RE_Direct\\\\t\\\\t\\\\t\\\\tRE_Direct_BlinnPhong\\\\n#define RE_IndirectDiffuse\\\\t\\\\tRE_IndirectDiffuse_BlinnPhong\\\\n#define Material_LightProbeLOD( material )\\\\t(0)\\\\n\\\";\\n\\n\\tvar lights_physical_fragment = \\\"PhysicalMaterial material;\\\\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\\\\nmaterial.specularRoughness = clamp( roughnessFactor, 0.04, 1.0 );\\\\n#ifdef STANDARD\\\\n\\\\tmaterial.specularColor = mix( vec3( DEFAULT_SPECULAR_COEFFICIENT ), diffuseColor.rgb, metalnessFactor );\\\\n#else\\\\n\\\\tmaterial.specularColor = mix( vec3( MAXIMUM_SPECULAR_COEFFICIENT * pow2( reflectivity ) ), diffuseColor.rgb, metalnessFactor );\\\\n\\\\tmaterial.clearCoat = saturate( clearCoat );\\\\tmaterial.clearCoatRoughness = clamp( clearCoatRoughness, 0.04, 1.0 );\\\\n#endif\\\\n\\\";\\n\\n\\tvar lights_physical_pars_fragment = \\\"struct PhysicalMaterial {\\\\n\\\\tvec3\\\\tdiffuseColor;\\\\n\\\\tfloat\\\\tspecularRoughness;\\\\n\\\\tvec3\\\\tspecularColor;\\\\n\\\\t#ifndef STANDARD\\\\n\\\\t\\\\tfloat clearCoat;\\\\n\\\\t\\\\tfloat clearCoatRoughness;\\\\n\\\\t#endif\\\\n};\\\\n#define MAXIMUM_SPECULAR_COEFFICIENT 0.16\\\\n#define DEFAULT_SPECULAR_COEFFICIENT 0.04\\\\nfloat clearCoatDHRApprox( const in float roughness, const in float dotNL ) {\\\\n\\\\treturn DEFAULT_SPECULAR_COEFFICIENT + ( 1.0 - DEFAULT_SPECULAR_COEFFICIENT ) * ( pow( 1.0 - dotNL, 5.0 ) * pow( 1.0 - roughness, 2.0 ) );\\\\n}\\\\n#if NUM_RECT_AREA_LIGHTS > 0\\\\n\\\\tvoid RE_Direct_RectArea_Physical( const in RectAreaLight rectAreaLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\\\\n\\\\t\\\\tvec3 normal = geometry.normal;\\\\n\\\\t\\\\tvec3 viewDir = geometry.viewDir;\\\\n\\\\t\\\\tvec3 position = geometry.position;\\\\n\\\\t\\\\tvec3 lightPos = rectAreaLight.position;\\\\n\\\\t\\\\tvec3 halfWidth = rectAreaLight.halfWidth;\\\\n\\\\t\\\\tvec3 halfHeight = rectAreaLight.halfHeight;\\\\n\\\\t\\\\tvec3 lightColor = rectAreaLight.color;\\\\n\\\\t\\\\tfloat roughness = material.specularRoughness;\\\\n\\\\t\\\\tvec3 rectCoords[ 4 ];\\\\n\\\\t\\\\trectCoords[ 0 ] = lightPos - halfWidth - halfHeight;\\\\t\\\\trectCoords[ 1 ] = lightPos + halfWidth - halfHeight;\\\\n\\\\t\\\\trectCoords[ 2 ] = lightPos + halfWidth + halfHeight;\\\\n\\\\t\\\\trectCoords[ 3 ] = lightPos - halfWidth + halfHeight;\\\\n\\\\t\\\\tvec2 uv = LTC_Uv( normal, viewDir, roughness );\\\\n\\\\t\\\\tfloat norm = texture2D( ltcMag, uv ).a;\\\\n\\\\t\\\\tvec4 t = texture2D( ltcMat, uv );\\\\n\\\\t\\\\tmat3 mInv = mat3(\\\\n\\\\t\\\\t\\\\tvec3(   1,   0, t.y ),\\\\n\\\\t\\\\t\\\\tvec3(   0, t.z,   0 ),\\\\n\\\\t\\\\t\\\\tvec3( t.w,   0, t.x )\\\\n\\\\t\\\\t);\\\\n\\\\t\\\\treflectedLight.directSpecular += lightColor * material.specularColor * norm * LTC_Evaluate( normal, viewDir, position, mInv, rectCoords );\\\\n\\\\t\\\\treflectedLight.directDiffuse += lightColor * material.diffuseColor * LTC_Evaluate( normal, viewDir, position, mat3( 1 ), rectCoords );\\\\n\\\\t}\\\\n#endif\\\\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\\\\n\\\\tfloat dotNL = saturate( dot( geometry.normal, directLight.direction ) );\\\\n\\\\tvec3 irradiance = dotNL * directLight.color;\\\\n\\\\t#ifndef PHYSICALLY_CORRECT_LIGHTS\\\\n\\\\t\\\\tirradiance *= PI;\\\\n\\\\t#endif\\\\n\\\\t#ifndef STANDARD\\\\n\\\\t\\\\tfloat clearCoatDHR = material.clearCoat * clearCoatDHRApprox( material.clearCoatRoughness, dotNL );\\\\n\\\\t#else\\\\n\\\\t\\\\tfloat clearCoatDHR = 0.0;\\\\n\\\\t#endif\\\\n\\\\treflectedLight.directSpecular += ( 1.0 - clearCoatDHR ) * irradiance * BRDF_Specular_GGX( directLight, geometry, material.specularColor, material.specularRoughness );\\\\n\\\\treflectedLight.directDiffuse += ( 1.0 - clearCoatDHR ) * irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\\\\n\\\\t#ifndef STANDARD\\\\n\\\\t\\\\treflectedLight.directSpecular += irradiance * material.clearCoat * BRDF_Specular_GGX( directLight, geometry, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearCoatRoughness );\\\\n\\\\t#endif\\\\n}\\\\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\\\\n\\\\treflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\\\\n}\\\\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in vec3 clearCoatRadiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\\\\n\\\\t#ifndef STANDARD\\\\n\\\\t\\\\tfloat dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\\\\n\\\\t\\\\tfloat dotNL = dotNV;\\\\n\\\\t\\\\tfloat clearCoatDHR = material.clearCoat * clearCoatDHRApprox( material.clearCoatRoughness, dotNL );\\\\n\\\\t#else\\\\n\\\\t\\\\tfloat clearCoatDHR = 0.0;\\\\n\\\\t#endif\\\\n\\\\treflectedLight.indirectSpecular += ( 1.0 - clearCoatDHR ) * radiance * BRDF_Specular_GGX_Environment( geometry, material.specularColor, material.specularRoughness );\\\\n\\\\t#ifndef STANDARD\\\\n\\\\t\\\\treflectedLight.indirectSpecular += clearCoatRadiance * material.clearCoat * BRDF_Specular_GGX_Environment( geometry, vec3( DEFAULT_SPECULAR_COEFFICIENT ), material.clearCoatRoughness );\\\\n\\\\t#endif\\\\n}\\\\n#define RE_Direct\\\\t\\\\t\\\\t\\\\tRE_Direct_Physical\\\\n#define RE_Direct_RectArea\\\\t\\\\tRE_Direct_RectArea_Physical\\\\n#define RE_IndirectDiffuse\\\\t\\\\tRE_IndirectDiffuse_Physical\\\\n#define RE_IndirectSpecular\\\\t\\\\tRE_IndirectSpecular_Physical\\\\n#define Material_BlinnShininessExponent( material )   GGXRoughnessToBlinnExponent( material.specularRoughness )\\\\n#define Material_ClearCoat_BlinnShininessExponent( material )   GGXRoughnessToBlinnExponent( material.clearCoatRoughness )\\\\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\\\\n\\\\treturn saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\\\\n}\\\\n\\\";\\n\\n\\tvar lights_template = \\\"\\\\nGeometricContext geometry;\\\\ngeometry.position = - vViewPosition;\\\\ngeometry.normal = normal;\\\\ngeometry.viewDir = normalize( vViewPosition );\\\\nIncidentLight directLight;\\\\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\\\\n\\\\tPointLight pointLight;\\\\n\\\\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tpointLight = pointLights[ i ];\\\\n\\\\t\\\\tgetPointDirectLightIrradiance( pointLight, geometry, directLight );\\\\n\\\\t\\\\t#ifdef USE_SHADOWMAP\\\\n\\\\t\\\\tdirectLight.color *= all( bvec2( pointLight.shadow, directLight.visible ) ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\tRE_Direct( directLight, geometry, material, reflectedLight );\\\\n\\\\t}\\\\n#endif\\\\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\\\\n\\\\tSpotLight spotLight;\\\\n\\\\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tspotLight = spotLights[ i ];\\\\n\\\\t\\\\tgetSpotDirectLightIrradiance( spotLight, geometry, directLight );\\\\n\\\\t\\\\t#ifdef USE_SHADOWMAP\\\\n\\\\t\\\\tdirectLight.color *= all( bvec2( spotLight.shadow, directLight.visible ) ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\tRE_Direct( directLight, geometry, material, reflectedLight );\\\\n\\\\t}\\\\n#endif\\\\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\\\\n\\\\tDirectionalLight directionalLight;\\\\n\\\\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tdirectionalLight = directionalLights[ i ];\\\\n\\\\t\\\\tgetDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\\\\n\\\\t\\\\t#ifdef USE_SHADOWMAP\\\\n\\\\t\\\\tdirectLight.color *= all( bvec2( directionalLight.shadow, directLight.visible ) ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\tRE_Direct( directLight, geometry, material, reflectedLight );\\\\n\\\\t}\\\\n#endif\\\\n#if ( NUM_RECT_AREA_LIGHTS > 0 ) && defined( RE_Direct_RectArea )\\\\n\\\\tRectAreaLight rectAreaLight;\\\\n\\\\tfor ( int i = 0; i < NUM_RECT_AREA_LIGHTS; i ++ ) {\\\\n\\\\t\\\\trectAreaLight = rectAreaLights[ i ];\\\\n\\\\t\\\\tRE_Direct_RectArea( rectAreaLight, geometry, material, reflectedLight );\\\\n\\\\t}\\\\n#endif\\\\n#if defined( RE_IndirectDiffuse )\\\\n\\\\tvec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\\\\n\\\\t#ifdef USE_LIGHTMAP\\\\n\\\\t\\\\tvec3 lightMapIrradiance = texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\\\\n\\\\t\\\\t#ifndef PHYSICALLY_CORRECT_LIGHTS\\\\n\\\\t\\\\t\\\\tlightMapIrradiance *= PI;\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\tirradiance += lightMapIrradiance;\\\\n\\\\t#endif\\\\n\\\\t#if ( NUM_HEMI_LIGHTS > 0 )\\\\n\\\\t\\\\tfor ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\\\\n\\\\t\\\\t\\\\tirradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\\\\n\\\\t\\\\t}\\\\n\\\\t#endif\\\\n\\\\t#if defined( USE_ENVMAP ) && defined( PHYSICAL ) && defined( ENVMAP_TYPE_CUBE_UV )\\\\n\\\\t\\\\tirradiance += getLightProbeIndirectIrradiance( geometry, 8 );\\\\n\\\\t#endif\\\\n\\\\tRE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );\\\\n#endif\\\\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\\\\n\\\\tvec3 radiance = getLightProbeIndirectRadiance( geometry, Material_BlinnShininessExponent( material ), 8 );\\\\n\\\\t#ifndef STANDARD\\\\n\\\\t\\\\tvec3 clearCoatRadiance = getLightProbeIndirectRadiance( geometry, Material_ClearCoat_BlinnShininessExponent( material ), 8 );\\\\n\\\\t#else\\\\n\\\\t\\\\tvec3 clearCoatRadiance = vec3( 0.0 );\\\\n\\\\t#endif\\\\n\\\\tRE_IndirectSpecular( radiance, clearCoatRadiance, geometry, material, reflectedLight );\\\\n#endif\\\\n\\\";\\n\\n\\tvar logdepthbuf_fragment = \\\"#if defined( USE_LOGDEPTHBUF ) && defined( USE_LOGDEPTHBUF_EXT )\\\\n\\\\tgl_FragDepthEXT = log2( vFragDepth ) * logDepthBufFC * 0.5;\\\\n#endif\\\";\\n\\n\\tvar logdepthbuf_pars_fragment = \\\"#ifdef USE_LOGDEPTHBUF\\\\n\\\\tuniform float logDepthBufFC;\\\\n\\\\t#ifdef USE_LOGDEPTHBUF_EXT\\\\n\\\\t\\\\tvarying float vFragDepth;\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar logdepthbuf_pars_vertex = \\\"#ifdef USE_LOGDEPTHBUF\\\\n\\\\t#ifdef USE_LOGDEPTHBUF_EXT\\\\n\\\\t\\\\tvarying float vFragDepth;\\\\n\\\\t#endif\\\\n\\\\tuniform float logDepthBufFC;\\\\n#endif\\\";\\n\\n\\tvar logdepthbuf_vertex = \\\"#ifdef USE_LOGDEPTHBUF\\\\n\\\\t#ifdef USE_LOGDEPTHBUF_EXT\\\\n\\\\t\\\\tvFragDepth = 1.0 + gl_Position.w;\\\\n\\\\t#else\\\\n\\\\t\\\\tgl_Position.z = log2( max( EPSILON, gl_Position.w + 1.0 ) ) * logDepthBufFC - 1.0;\\\\n\\\\t\\\\tgl_Position.z *= gl_Position.w;\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar map_fragment = \\\"#ifdef USE_MAP\\\\n\\\\tvec4 texelColor = texture2D( map, vUv );\\\\n\\\\ttexelColor = mapTexelToLinear( texelColor );\\\\n\\\\tdiffuseColor *= texelColor;\\\\n#endif\\\\n\\\";\\n\\n\\tvar map_pars_fragment = \\\"#ifdef USE_MAP\\\\n\\\\tuniform sampler2D map;\\\\n#endif\\\\n\\\";\\n\\n\\tvar map_particle_fragment = \\\"#ifdef USE_MAP\\\\n\\\\tvec2 uv = ( uvTransform * vec3( gl_PointCoord.x, 1.0 - gl_PointCoord.y, 1 ) ).xy;\\\\n\\\\tvec4 mapTexel = texture2D( map, uv );\\\\n\\\\tdiffuseColor *= mapTexelToLinear( mapTexel );\\\\n#endif\\\\n\\\";\\n\\n\\tvar map_particle_pars_fragment = \\\"#ifdef USE_MAP\\\\n\\\\tuniform mat3 uvTransform;\\\\n\\\\tuniform sampler2D map;\\\\n#endif\\\\n\\\";\\n\\n\\tvar metalnessmap_fragment = \\\"float metalnessFactor = metalness;\\\\n#ifdef USE_METALNESSMAP\\\\n\\\\tvec4 texelMetalness = texture2D( metalnessMap, vUv );\\\\n\\\\tmetalnessFactor *= texelMetalness.b;\\\\n#endif\\\\n\\\";\\n\\n\\tvar metalnessmap_pars_fragment = \\\"#ifdef USE_METALNESSMAP\\\\n\\\\tuniform sampler2D metalnessMap;\\\\n#endif\\\";\\n\\n\\tvar morphnormal_vertex = \\\"#ifdef USE_MORPHNORMALS\\\\n\\\\tobjectNormal += ( morphNormal0 - normal ) * morphTargetInfluences[ 0 ];\\\\n\\\\tobjectNormal += ( morphNormal1 - normal ) * morphTargetInfluences[ 1 ];\\\\n\\\\tobjectNormal += ( morphNormal2 - normal ) * morphTargetInfluences[ 2 ];\\\\n\\\\tobjectNormal += ( morphNormal3 - normal ) * morphTargetInfluences[ 3 ];\\\\n#endif\\\\n\\\";\\n\\n\\tvar morphtarget_pars_vertex = \\\"#ifdef USE_MORPHTARGETS\\\\n\\\\t#ifndef USE_MORPHNORMALS\\\\n\\\\tuniform float morphTargetInfluences[ 8 ];\\\\n\\\\t#else\\\\n\\\\tuniform float morphTargetInfluences[ 4 ];\\\\n\\\\t#endif\\\\n#endif\\\";\\n\\n\\tvar morphtarget_vertex = \\\"#ifdef USE_MORPHTARGETS\\\\n\\\\ttransformed += ( morphTarget0 - position ) * morphTargetInfluences[ 0 ];\\\\n\\\\ttransformed += ( morphTarget1 - position ) * morphTargetInfluences[ 1 ];\\\\n\\\\ttransformed += ( morphTarget2 - position ) * morphTargetInfluences[ 2 ];\\\\n\\\\ttransformed += ( morphTarget3 - position ) * morphTargetInfluences[ 3 ];\\\\n\\\\t#ifndef USE_MORPHNORMALS\\\\n\\\\ttransformed += ( morphTarget4 - position ) * morphTargetInfluences[ 4 ];\\\\n\\\\ttransformed += ( morphTarget5 - position ) * morphTargetInfluences[ 5 ];\\\\n\\\\ttransformed += ( morphTarget6 - position ) * morphTargetInfluences[ 6 ];\\\\n\\\\ttransformed += ( morphTarget7 - position ) * morphTargetInfluences[ 7 ];\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar normal_fragment = \\\"#ifdef FLAT_SHADED\\\\n\\\\tvec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );\\\\n\\\\tvec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );\\\\n\\\\tvec3 normal = normalize( cross( fdx, fdy ) );\\\\n#else\\\\n\\\\tvec3 normal = normalize( vNormal );\\\\n\\\\t#ifdef DOUBLE_SIDED\\\\n\\\\t\\\\tnormal = normal * ( float( gl_FrontFacing ) * 2.0 - 1.0 );\\\\n\\\\t#endif\\\\n#endif\\\\n#ifdef USE_NORMALMAP\\\\n\\\\tnormal = perturbNormal2Arb( -vViewPosition, normal );\\\\n#elif defined( USE_BUMPMAP )\\\\n\\\\tnormal = perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );\\\\n#endif\\\\n\\\";\\n\\n\\tvar normalmap_pars_fragment = \\\"#ifdef USE_NORMALMAP\\\\n\\\\tuniform sampler2D normalMap;\\\\n\\\\tuniform vec2 normalScale;\\\\n\\\\tvec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm ) {\\\\n\\\\t\\\\tvec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );\\\\n\\\\t\\\\tvec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );\\\\n\\\\t\\\\tvec2 st0 = dFdx( vUv.st );\\\\n\\\\t\\\\tvec2 st1 = dFdy( vUv.st );\\\\n\\\\t\\\\tvec3 S = normalize( q0 * st1.t - q1 * st0.t );\\\\n\\\\t\\\\tvec3 T = normalize( -q0 * st1.s + q1 * st0.s );\\\\n\\\\t\\\\tvec3 N = normalize( surf_norm );\\\\n\\\\t\\\\tvec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\\\\n\\\\t\\\\tmapN.xy = normalScale * mapN.xy;\\\\n\\\\t\\\\tmat3 tsn = mat3( S, T, N );\\\\n\\\\t\\\\treturn normalize( tsn * mapN );\\\\n\\\\t}\\\\n#endif\\\\n\\\";\\n\\n\\tvar packing = \\\"vec3 packNormalToRGB( const in vec3 normal ) {\\\\n\\\\treturn normalize( normal ) * 0.5 + 0.5;\\\\n}\\\\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\\\\n\\\\treturn 2.0 * rgb.xyz - 1.0;\\\\n}\\\\nconst float PackUpscale = 256. / 255.;const float UnpackDownscale = 255. / 256.;\\\\nconst vec3 PackFactors = vec3( 256. * 256. * 256., 256. * 256.,  256. );\\\\nconst vec4 UnpackFactors = UnpackDownscale / vec4( PackFactors, 1. );\\\\nconst float ShiftRight8 = 1. / 256.;\\\\nvec4 packDepthToRGBA( const in float v ) {\\\\n\\\\tvec4 r = vec4( fract( v * PackFactors ), v );\\\\n\\\\tr.yzw -= r.xyz * ShiftRight8;\\\\treturn r * PackUpscale;\\\\n}\\\\nfloat unpackRGBAToDepth( const in vec4 v ) {\\\\n\\\\treturn dot( v, UnpackFactors );\\\\n}\\\\nfloat viewZToOrthographicDepth( const in float viewZ, const in float near, const in float far ) {\\\\n\\\\treturn ( viewZ + near ) / ( near - far );\\\\n}\\\\nfloat orthographicDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {\\\\n\\\\treturn linearClipZ * ( near - far ) - near;\\\\n}\\\\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\\\\n\\\\treturn (( near + viewZ ) * far ) / (( far - near ) * viewZ );\\\\n}\\\\nfloat perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {\\\\n\\\\treturn ( near * far ) / ( ( far - near ) * invClipZ - far );\\\\n}\\\\n\\\";\\n\\n\\tvar premultiplied_alpha_fragment = \\\"#ifdef PREMULTIPLIED_ALPHA\\\\n\\\\tgl_FragColor.rgb *= gl_FragColor.a;\\\\n#endif\\\\n\\\";\\n\\n\\tvar project_vertex = \\\"vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );\\\\ngl_Position = projectionMatrix * mvPosition;\\\\n\\\";\\n\\n\\tvar dithering_fragment = \\\"#if defined( DITHERING )\\\\n  gl_FragColor.rgb = dithering( gl_FragColor.rgb );\\\\n#endif\\\\n\\\";\\n\\n\\tvar dithering_pars_fragment = \\\"#if defined( DITHERING )\\\\n\\\\tvec3 dithering( vec3 color ) {\\\\n\\\\t\\\\tfloat grid_position = rand( gl_FragCoord.xy );\\\\n\\\\t\\\\tvec3 dither_shift_RGB = vec3( 0.25 / 255.0, -0.25 / 255.0, 0.25 / 255.0 );\\\\n\\\\t\\\\tdither_shift_RGB = mix( 2.0 * dither_shift_RGB, -2.0 * dither_shift_RGB, grid_position );\\\\n\\\\t\\\\treturn color + dither_shift_RGB;\\\\n\\\\t}\\\\n#endif\\\\n\\\";\\n\\n\\tvar roughnessmap_fragment = \\\"float roughnessFactor = roughness;\\\\n#ifdef USE_ROUGHNESSMAP\\\\n\\\\tvec4 texelRoughness = texture2D( roughnessMap, vUv );\\\\n\\\\troughnessFactor *= texelRoughness.g;\\\\n#endif\\\\n\\\";\\n\\n\\tvar roughnessmap_pars_fragment = \\\"#ifdef USE_ROUGHNESSMAP\\\\n\\\\tuniform sampler2D roughnessMap;\\\\n#endif\\\";\\n\\n\\tvar shadowmap_pars_fragment = \\\"#ifdef USE_SHADOWMAP\\\\n\\\\t#if NUM_DIR_LIGHTS > 0\\\\n\\\\t\\\\tuniform sampler2D directionalShadowMap[ NUM_DIR_LIGHTS ];\\\\n\\\\t\\\\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHTS ];\\\\n\\\\t#endif\\\\n\\\\t#if NUM_SPOT_LIGHTS > 0\\\\n\\\\t\\\\tuniform sampler2D spotShadowMap[ NUM_SPOT_LIGHTS ];\\\\n\\\\t\\\\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHTS ];\\\\n\\\\t#endif\\\\n\\\\t#if NUM_POINT_LIGHTS > 0\\\\n\\\\t\\\\tuniform sampler2D pointShadowMap[ NUM_POINT_LIGHTS ];\\\\n\\\\t\\\\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHTS ];\\\\n\\\\t#endif\\\\n\\\\tfloat texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\\\\n\\\\t\\\\treturn step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\\\\n\\\\t}\\\\n\\\\tfloat texture2DShadowLerp( sampler2D depths, vec2 size, vec2 uv, float compare ) {\\\\n\\\\t\\\\tconst vec2 offset = vec2( 0.0, 1.0 );\\\\n\\\\t\\\\tvec2 texelSize = vec2( 1.0 ) / size;\\\\n\\\\t\\\\tvec2 centroidUV = floor( uv * size + 0.5 ) / size;\\\\n\\\\t\\\\tfloat lb = texture2DCompare( depths, centroidUV + texelSize * offset.xx, compare );\\\\n\\\\t\\\\tfloat lt = texture2DCompare( depths, centroidUV + texelSize * offset.xy, compare );\\\\n\\\\t\\\\tfloat rb = texture2DCompare( depths, centroidUV + texelSize * offset.yx, compare );\\\\n\\\\t\\\\tfloat rt = texture2DCompare( depths, centroidUV + texelSize * offset.yy, compare );\\\\n\\\\t\\\\tvec2 f = fract( uv * size + 0.5 );\\\\n\\\\t\\\\tfloat a = mix( lb, lt, f.y );\\\\n\\\\t\\\\tfloat b = mix( rb, rt, f.y );\\\\n\\\\t\\\\tfloat c = mix( a, b, f.x );\\\\n\\\\t\\\\treturn c;\\\\n\\\\t}\\\\n\\\\tfloat getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\\\\n\\\\t\\\\tfloat shadow = 1.0;\\\\n\\\\t\\\\tshadowCoord.xyz /= shadowCoord.w;\\\\n\\\\t\\\\tshadowCoord.z += shadowBias;\\\\n\\\\t\\\\tbvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );\\\\n\\\\t\\\\tbool inFrustum = all( inFrustumVec );\\\\n\\\\t\\\\tbvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );\\\\n\\\\t\\\\tbool frustumTest = all( frustumTestVec );\\\\n\\\\t\\\\tif ( frustumTest ) {\\\\n\\\\t\\\\t#if defined( SHADOWMAP_TYPE_PCF )\\\\n\\\\t\\\\t\\\\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\\\\n\\\\t\\\\t\\\\tfloat dx0 = - texelSize.x * shadowRadius;\\\\n\\\\t\\\\t\\\\tfloat dy0 = - texelSize.y * shadowRadius;\\\\n\\\\t\\\\t\\\\tfloat dx1 = + texelSize.x * shadowRadius;\\\\n\\\\t\\\\t\\\\tfloat dy1 = + texelSize.y * shadowRadius;\\\\n\\\\t\\\\t\\\\tshadow = (\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\\\\n\\\\t\\\\t\\\\t) * ( 1.0 / 9.0 );\\\\n\\\\t\\\\t#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\\\\n\\\\t\\\\t\\\\tvec2 texelSize = vec2( 1.0 ) / shadowMapSize;\\\\n\\\\t\\\\t\\\\tfloat dx0 = - texelSize.x * shadowRadius;\\\\n\\\\t\\\\t\\\\tfloat dy0 = - texelSize.y * shadowRadius;\\\\n\\\\t\\\\t\\\\tfloat dx1 = + texelSize.x * shadowRadius;\\\\n\\\\t\\\\t\\\\tfloat dy1 = + texelSize.y * shadowRadius;\\\\n\\\\t\\\\t\\\\tshadow = (\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy, shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\\\\n\\\\t\\\\t\\\\t) * ( 1.0 / 9.0 );\\\\n\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\tshadow = texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\\\\n\\\\t\\\\t#endif\\\\n\\\\t\\\\t}\\\\n\\\\t\\\\treturn shadow;\\\\n\\\\t}\\\\n\\\\tvec2 cubeToUV( vec3 v, float texelSizeY ) {\\\\n\\\\t\\\\tvec3 absV = abs( v );\\\\n\\\\t\\\\tfloat scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\\\\n\\\\t\\\\tabsV *= scaleToCube;\\\\n\\\\t\\\\tv *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\\\\n\\\\t\\\\tvec2 planar = v.xy;\\\\n\\\\t\\\\tfloat almostATexel = 1.5 * texelSizeY;\\\\n\\\\t\\\\tfloat almostOne = 1.0 - almostATexel;\\\\n\\\\t\\\\tif ( absV.z >= almostOne ) {\\\\n\\\\t\\\\t\\\\tif ( v.z > 0.0 )\\\\n\\\\t\\\\t\\\\t\\\\tplanar.x = 4.0 - v.x;\\\\n\\\\t\\\\t} else if ( absV.x >= almostOne ) {\\\\n\\\\t\\\\t\\\\tfloat signX = sign( v.x );\\\\n\\\\t\\\\t\\\\tplanar.x = v.z * signX + 2.0 * signX;\\\\n\\\\t\\\\t} else if ( absV.y >= almostOne ) {\\\\n\\\\t\\\\t\\\\tfloat signY = sign( v.y );\\\\n\\\\t\\\\t\\\\tplanar.x = v.x + 2.0 * signY + 2.0;\\\\n\\\\t\\\\t\\\\tplanar.y = v.z * signY - 2.0;\\\\n\\\\t\\\\t}\\\\n\\\\t\\\\treturn vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\\\\n\\\\t}\\\\n\\\\tfloat getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord, float shadowCameraNear, float shadowCameraFar ) {\\\\n\\\\t\\\\tvec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\\\\n\\\\t\\\\tvec3 lightToPosition = shadowCoord.xyz;\\\\n\\\\t\\\\tfloat dp = ( length( lightToPosition ) - shadowCameraNear ) / ( shadowCameraFar - shadowCameraNear );\\\\t\\\\tdp += shadowBias;\\\\n\\\\t\\\\tvec3 bd3D = normalize( lightToPosition );\\\\n\\\\t\\\\t#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT )\\\\n\\\\t\\\\t\\\\tvec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\\\\n\\\\t\\\\t\\\\treturn (\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\\\\n\\\\t\\\\t\\\\t\\\\ttexture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\\\\n\\\\t\\\\t\\\\t) * ( 1.0 / 9.0 );\\\\n\\\\t\\\\t#else\\\\n\\\\t\\\\t\\\\treturn texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\\\\n\\\\t\\\\t#endif\\\\n\\\\t}\\\\n#endif\\\\n\\\";\\n\\n\\tvar shadowmap_pars_vertex = \\\"#ifdef USE_SHADOWMAP\\\\n\\\\t#if NUM_DIR_LIGHTS > 0\\\\n\\\\t\\\\tuniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHTS ];\\\\n\\\\t\\\\tvarying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHTS ];\\\\n\\\\t#endif\\\\n\\\\t#if NUM_SPOT_LIGHTS > 0\\\\n\\\\t\\\\tuniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHTS ];\\\\n\\\\t\\\\tvarying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHTS ];\\\\n\\\\t#endif\\\\n\\\\t#if NUM_POINT_LIGHTS > 0\\\\n\\\\t\\\\tuniform mat4 pointShadowMatrix[ NUM_POINT_LIGHTS ];\\\\n\\\\t\\\\tvarying vec4 vPointShadowCoord[ NUM_POINT_LIGHTS ];\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar shadowmap_vertex = \\\"#ifdef USE_SHADOWMAP\\\\n\\\\t#if NUM_DIR_LIGHTS > 0\\\\n\\\\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tvDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * worldPosition;\\\\n\\\\t}\\\\n\\\\t#endif\\\\n\\\\t#if NUM_SPOT_LIGHTS > 0\\\\n\\\\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tvSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * worldPosition;\\\\n\\\\t}\\\\n\\\\t#endif\\\\n\\\\t#if NUM_POINT_LIGHTS > 0\\\\n\\\\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tvPointShadowCoord[ i ] = pointShadowMatrix[ i ] * worldPosition;\\\\n\\\\t}\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar shadowmask_pars_fragment = \\\"float getShadowMask() {\\\\n\\\\tfloat shadow = 1.0;\\\\n\\\\t#ifdef USE_SHADOWMAP\\\\n\\\\t#if NUM_DIR_LIGHTS > 0\\\\n\\\\tDirectionalLight directionalLight;\\\\n\\\\tfor ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tdirectionalLight = directionalLights[ i ];\\\\n\\\\t\\\\tshadow *= bool( directionalLight.shadow ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\\\\n\\\\t}\\\\n\\\\t#endif\\\\n\\\\t#if NUM_SPOT_LIGHTS > 0\\\\n\\\\tSpotLight spotLight;\\\\n\\\\tfor ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tspotLight = spotLights[ i ];\\\\n\\\\t\\\\tshadow *= bool( spotLight.shadow ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\\\\n\\\\t}\\\\n\\\\t#endif\\\\n\\\\t#if NUM_POINT_LIGHTS > 0\\\\n\\\\tPointLight pointLight;\\\\n\\\\tfor ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\\\\n\\\\t\\\\tpointLight = pointLights[ i ];\\\\n\\\\t\\\\tshadow *= bool( pointLight.shadow ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ], pointLight.shadowCameraNear, pointLight.shadowCameraFar ) : 1.0;\\\\n\\\\t}\\\\n\\\\t#endif\\\\n\\\\t#endif\\\\n\\\\treturn shadow;\\\\n}\\\\n\\\";\\n\\n\\tvar skinbase_vertex = \\\"#ifdef USE_SKINNING\\\\n\\\\tmat4 boneMatX = getBoneMatrix( skinIndex.x );\\\\n\\\\tmat4 boneMatY = getBoneMatrix( skinIndex.y );\\\\n\\\\tmat4 boneMatZ = getBoneMatrix( skinIndex.z );\\\\n\\\\tmat4 boneMatW = getBoneMatrix( skinIndex.w );\\\\n#endif\\\";\\n\\n\\tvar skinning_pars_vertex = \\\"#ifdef USE_SKINNING\\\\n\\\\tuniform mat4 bindMatrix;\\\\n\\\\tuniform mat4 bindMatrixInverse;\\\\n\\\\t#ifdef BONE_TEXTURE\\\\n\\\\t\\\\tuniform sampler2D boneTexture;\\\\n\\\\t\\\\tuniform int boneTextureSize;\\\\n\\\\t\\\\tmat4 getBoneMatrix( const in float i ) {\\\\n\\\\t\\\\t\\\\tfloat j = i * 4.0;\\\\n\\\\t\\\\t\\\\tfloat x = mod( j, float( boneTextureSize ) );\\\\n\\\\t\\\\t\\\\tfloat y = floor( j / float( boneTextureSize ) );\\\\n\\\\t\\\\t\\\\tfloat dx = 1.0 / float( boneTextureSize );\\\\n\\\\t\\\\t\\\\tfloat dy = 1.0 / float( boneTextureSize );\\\\n\\\\t\\\\t\\\\ty = dy * ( y + 0.5 );\\\\n\\\\t\\\\t\\\\tvec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\\\\n\\\\t\\\\t\\\\tvec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\\\\n\\\\t\\\\t\\\\tvec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\\\\n\\\\t\\\\t\\\\tvec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\\\\n\\\\t\\\\t\\\\tmat4 bone = mat4( v1, v2, v3, v4 );\\\\n\\\\t\\\\t\\\\treturn bone;\\\\n\\\\t\\\\t}\\\\n\\\\t#else\\\\n\\\\t\\\\tuniform mat4 boneMatrices[ MAX_BONES ];\\\\n\\\\t\\\\tmat4 getBoneMatrix( const in float i ) {\\\\n\\\\t\\\\t\\\\tmat4 bone = boneMatrices[ int(i) ];\\\\n\\\\t\\\\t\\\\treturn bone;\\\\n\\\\t\\\\t}\\\\n\\\\t#endif\\\\n#endif\\\\n\\\";\\n\\n\\tvar skinning_vertex = \\\"#ifdef USE_SKINNING\\\\n\\\\tvec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\\\\n\\\\tvec4 skinned = vec4( 0.0 );\\\\n\\\\tskinned += boneMatX * skinVertex * skinWeight.x;\\\\n\\\\tskinned += boneMatY * skinVertex * skinWeight.y;\\\\n\\\\tskinned += boneMatZ * skinVertex * skinWeight.z;\\\\n\\\\tskinned += boneMatW * skinVertex * skinWeight.w;\\\\n\\\\ttransformed = ( bindMatrixInverse * skinned ).xyz;\\\\n#endif\\\\n\\\";\\n\\n\\tvar skinnormal_vertex = \\\"#ifdef USE_SKINNING\\\\n\\\\tmat4 skinMatrix = mat4( 0.0 );\\\\n\\\\tskinMatrix += skinWeight.x * boneMatX;\\\\n\\\\tskinMatrix += skinWeight.y * boneMatY;\\\\n\\\\tskinMatrix += skinWeight.z * boneMatZ;\\\\n\\\\tskinMatrix += skinWeight.w * boneMatW;\\\\n\\\\tskinMatrix  = bindMatrixInverse * skinMatrix * bindMatrix;\\\\n\\\\tobjectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\\\\n#endif\\\\n\\\";\\n\\n\\tvar specularmap_fragment = \\\"float specularStrength;\\\\n#ifdef USE_SPECULARMAP\\\\n\\\\tvec4 texelSpecular = texture2D( specularMap, vUv );\\\\n\\\\tspecularStrength = texelSpecular.r;\\\\n#else\\\\n\\\\tspecularStrength = 1.0;\\\\n#endif\\\";\\n\\n\\tvar specularmap_pars_fragment = \\\"#ifdef USE_SPECULARMAP\\\\n\\\\tuniform sampler2D specularMap;\\\\n#endif\\\";\\n\\n\\tvar tonemapping_fragment = \\\"#if defined( TONE_MAPPING )\\\\n  gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\\\\n#endif\\\\n\\\";\\n\\n\\tvar tonemapping_pars_fragment = \\\"#ifndef saturate\\\\n\\\\t#define saturate(a) clamp( a, 0.0, 1.0 )\\\\n#endif\\\\nuniform float toneMappingExposure;\\\\nuniform float toneMappingWhitePoint;\\\\nvec3 LinearToneMapping( vec3 color ) {\\\\n\\\\treturn toneMappingExposure * color;\\\\n}\\\\nvec3 ReinhardToneMapping( vec3 color ) {\\\\n\\\\tcolor *= toneMappingExposure;\\\\n\\\\treturn saturate( color / ( vec3( 1.0 ) + color ) );\\\\n}\\\\n#define Uncharted2Helper( x ) max( ( ( x * ( 0.15 * x + 0.10 * 0.50 ) + 0.20 * 0.02 ) / ( x * ( 0.15 * x + 0.50 ) + 0.20 * 0.30 ) ) - 0.02 / 0.30, vec3( 0.0 ) )\\\\nvec3 Uncharted2ToneMapping( vec3 color ) {\\\\n\\\\tcolor *= toneMappingExposure;\\\\n\\\\treturn saturate( Uncharted2Helper( color ) / Uncharted2Helper( vec3( toneMappingWhitePoint ) ) );\\\\n}\\\\nvec3 OptimizedCineonToneMapping( vec3 color ) {\\\\n\\\\tcolor *= toneMappingExposure;\\\\n\\\\tcolor = max( vec3( 0.0 ), color - 0.004 );\\\\n\\\\treturn pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\\\\n}\\\\n\\\";\\n\\n\\tvar uv_pars_fragment = \\\"#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\\\\n\\\\tvarying vec2 vUv;\\\\n#endif\\\";\\n\\n\\tvar uv_pars_vertex = \\\"#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\\\\n\\\\tvarying vec2 vUv;\\\\n\\\\tuniform mat3 uvTransform;\\\\n#endif\\\\n\\\";\\n\\n\\tvar uv_vertex = \\\"#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\\\\n\\\\tvUv = ( uvTransform * vec3( uv, 1 ) ).xy;\\\\n#endif\\\";\\n\\n\\tvar uv2_pars_fragment = \\\"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\\\\n\\\\tvarying vec2 vUv2;\\\\n#endif\\\";\\n\\n\\tvar uv2_pars_vertex = \\\"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\\\\n\\\\tattribute vec2 uv2;\\\\n\\\\tvarying vec2 vUv2;\\\\n#endif\\\";\\n\\n\\tvar uv2_vertex = \\\"#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\\\\n\\\\tvUv2 = uv2;\\\\n#endif\\\";\\n\\n\\tvar worldpos_vertex = \\\"#if defined( USE_ENVMAP ) || defined( DISTANCE ) || defined ( USE_SHADOWMAP )\\\\n\\\\tvec4 worldPosition = modelMatrix * vec4( transformed, 1.0 );\\\\n#endif\\\\n\\\";\\n\\n\\tvar cube_frag = \\\"uniform samplerCube tCube;\\\\nuniform float tFlip;\\\\nuniform float opacity;\\\\nvarying vec3 vWorldPosition;\\\\nvoid main() {\\\\n\\\\tgl_FragColor = textureCube( tCube, vec3( tFlip * vWorldPosition.x, vWorldPosition.yz ) );\\\\n\\\\tgl_FragColor.a *= opacity;\\\\n}\\\\n\\\";\\n\\n\\tvar cube_vert = \\\"varying vec3 vWorldPosition;\\\\n#include <common>\\\\nvoid main() {\\\\n\\\\tvWorldPosition = transformDirection( position, modelMatrix );\\\\n\\\\t#include <begin_vertex>\\\\n\\\\t#include <project_vertex>\\\\n\\\\tgl_Position.z = gl_Position.w;\\\\n}\\\\n\\\";\\n\\n\\tvar depth_frag = \\\"#if DEPTH_PACKING == 3200\\\\n\\\\tuniform float opacity;\\\\n#endif\\\\n#include <common>\\\\n#include <packing>\\\\n#include <uv_pars_fragment>\\\\n#include <map_pars_fragment>\\\\n#include <alphamap_pars_fragment>\\\\n#include <logdepthbuf_pars_fragment>\\\\n#include <clipping_planes_pars_fragment>\\\\nvoid main() {\\\\n\\\\t#include <clipping_planes_fragment>\\\\n\\\\tvec4 diffuseColor = vec4( 1.0 );\\\\n\\\\t#if DEPTH_PACKING == 3200\\\\n\\\\t\\\\tdiffuseColor.a = opacity;\\\\n\\\\t#endif\\\\n\\\\t#include <map_fragment>\\\\n\\\\t#include <alphamap_fragment>\\\\n\\\\t#include <alphatest_fragment>\\\\n\\\\t#include <logdepthbuf_fragment>\\\\n\\\\t#if DEPTH_PACKING == 3200\\\\n\\\\t\\\\tgl_FragColor = vec4( vec3( gl_FragCoord.z ), opacity );\\\\n\\\\t#elif DEPTH_PACKING == 3201\\\\n\\\\t\\\\tgl_FragColor = packDepthToRGBA( gl_FragCoord.z );\\\\n\\\\t#endif\\\\n}\\\\n\\\";\\n\\n\\tvar depth_vert = \\\"#include <common>\\\\n#include <uv_pars_vertex>\\\\n#include <displacementmap_pars_vertex>\\\\n#include <morphtarget_pars_vertex>\\\\n#include <skinning_pars_vertex>\\\\n#include <logdepthbuf_pars_vertex>\\\\n#include <clipping_planes_pars_vertex>\\\\nvoid main() {\\\\n\\\\t#include <uv_vertex>\\\\n\\\\t#include <skinbase_vertex>\\\\n\\\\t#ifdef USE_DISPLACEMENTMAP\\\\n\\\\t\\\\t#include <beginnormal_vertex>\\\\n\\\\t\\\\t#include <morphnormal_vertex>\\\\n\\\\t\\\\t#include <skinnormal_vertex>\\\\n\\\\t#endif\\\\n\\\\t#include <begin_vertex>\\\\n\\\\t#include <morphtarget_vertex>\\\\n\\\\t#include <skinning_vertex>\\\\n\\\\t#include <displacementmap_vertex>\\\\n\\\\t#include <project_vertex>\\\\n\\\\t#include <logdepthbuf_vertex>\\\\n\\\\t#include <clipping_planes_vertex>\\\\n}\\\\n\\\";\\n\\n\\tvar distanceRGBA_frag = \\\"#define DISTANCE\\\\nuniform vec3 referencePosition;\\\\nuniform float nearDistance;\\\\nuniform float farDistance;\\\\nvarying vec3 vWorldPosition;\\\\n#include <common>\\\\n#include <packing>\\\\n#include <uv_pars_fragment>\\\\n#include <map_pars_fragment>\\\\n#include <alphamap_pars_fragment>\\\\n#include <clipping_planes_pars_fragment>\\\\nvoid main () {\\\\n\\\\t#include <clipping_planes_fragment>\\\\n\\\\tvec4 diffuseColor = vec4( 1.0 );\\\\n\\\\t#include <map_fragment>\\\\n\\\\t#include <alphamap_fragment>\\\\n\\\\t#include <alphatest_fragment>\\\\n\\\\tfloat dist = length( vWorldPosition - referencePosition );\\\\n\\\\tdist = ( dist - nearDistance ) / ( farDistance - nearDistance );\\\\n\\\\tdist = saturate( dist );\\\\n\\\\tgl_FragColor = packDepthToRGBA( dist );\\\\n}\\\\n\\\";\\n\\n\\tvar distanceRGBA_vert = \\\"#define DISTANCE\\\\nvarying vec3 vWorldPosition;\\\\n#include <common>\\\\n#include <uv_pars_vertex>\\\\n#include <displacementmap_pars_vertex>\\\\n#include <morphtarget_pars_vertex>\\\\n#include <skinning_pars_vertex>\\\\n#include <clipping_planes_pars_vertex>\\\\nvoid main() {\\\\n\\\\t#include <uv_vertex>\\\\n\\\\t#include <skinbase_vertex>\\\\n\\\\t#ifdef USE_DISPLACEMENTMAP\\\\n\\\\t\\\\t#include <beginnormal_vertex>\\\\n\\\\t\\\\t#include <morphnormal_vertex>\\\\n\\\\t\\\\t#include <skinnormal_vertex>\\\\n\\\\t#endif\\\\n\\\\t#include <begin_vertex>\\\\n\\\\t#include <morphtarget_vertex>\\\\n\\\\t#include <skinning_vertex>\\\\n\\\\t#include <displacementmap_vertex>\\\\n\\\\t#include <project_vertex>\\\\n\\\\t#include <worldpos_vertex>\\\\n\\\\t#include <clipping_planes_vertex>\\\\n\\\\tvWorldPosition = worldPosition.xyz;\\\\n}\\\\n\\\";\\n\\n\\tvar equirect_frag = \\\"uniform sampler2D tEquirect;\\\\nvarying vec3 vWorldPosition;\\\\n#include <common>\\\\nvoid main() {\\\\n\\\\tvec3 direction = normalize( vWorldPosition );\\\\n\\\\tvec2 sampleUV;\\\\n\\\\tsampleUV.y = asin( clamp( direction.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;\\\\n\\\\tsampleUV.x = atan( direction.z, direction.x ) * RECIPROCAL_PI2 + 0.5;\\\\n\\\\tgl_FragColor = texture2D( tEquirect, sampleUV );\\\\n}\\\\n\\\";\\n\\n\\tvar equirect_vert = \\\"varying vec3 vWorldPosition;\\\\n#include <common>\\\\nvoid main() {\\\\n\\\\tvWorldPosition = transformDirection( position, modelMatrix );\\\\n\\\\t#include <begin_vertex>\\\\n\\\\t#include <project_vertex>\\\\n}\\\\n\\\";\\n\\n\\tvar linedashed_frag = \\\"uniform vec3 diffuse;\\\\nuniform float opacity;\\\\nuniform float dashSize;\\\\nuniform float totalSize;\\\\nvarying float vLineDistance;\\\\n#include <common>\\\\n#include <color_pars_fragment>\\\\n#include <fog_pars_fragment>\\\\n#include <logdepthbuf_pars_fragment>\\\\n#include <clipping_planes_pars_fragment>\\\\nvoid main() {\\\\n\\\\t#include <clipping_planes_fragment>\\\\n\\\\tif ( mod( vLineDistance, totalSize ) > dashSize ) {\\\\n\\\\t\\\\tdiscard;\\\\n\\\\t}\\\\n\\\\tvec3 outgoingLight = vec3( 0.0 );\\\\n\\\\tvec4 diffuseColor = vec4( diffuse, opacity );\\\\n\\\\t#include <logdepthbuf_fragment>\\\\n\\\\t#include <color_fragment>\\\\n\\\\toutgoingLight = diffuseColor.rgb;\\\\n\\\\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\\\\n\\\\t#include <premultiplied_alpha_fragment>\\\\n\\\\t#include <tonemapping_fragment>\\\\n\\\\t#include <encodings_fragment>\\\\n\\\\t#include <fog_fragment>\\\\n}\\\\n\\\";\\n\\n\\tvar linedashed_vert = \\\"uniform float scale;\\\\nattribute float lineDistance;\\\\nvarying float vLineDistance;\\\\n#include <common>\\\\n#include <color_pars_vertex>\\\\n#include <fog_pars_vertex>\\\\n#include <logdepthbuf_pars_vertex>\\\\n#include <clipping_planes_pars_vertex>\\\\nvoid main() {\\\\n\\\\t#include <color_vertex>\\\\n\\\\tvLineDistance = scale * lineDistance;\\\\n\\\\tvec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\\\\n\\\\tgl_Position = projectionMatrix * mvPosition;\\\\n\\\\t#include <logdepthbuf_vertex>\\\\n\\\\t#include <clipping_planes_vertex>\\\\n\\\\t#include <fog_vertex>\\\\n}\\\\n\\\";\\n\\n\\tvar meshbasic_frag = \\\"uniform vec3 diffuse;\\\\nuniform float opacity;\\\\n#ifndef FLAT_SHADED\\\\n\\\\tvarying vec3 vNormal;\\\\n#endif\\\\n#include <common>\\\\n#include <color_pars_fragment>\\\\n#include <uv_pars_fragment>\\\\n#include <uv2_pars_fragment>\\\\n#include <map_pars_fragment>\\\\n#include <alphamap_pars_fragment>\\\\n#include <aomap_pars_fragment>\\\\n#include <lightmap_pars_fragment>\\\\n#include <envmap_pars_fragment>\\\\n#include <fog_pars_fragment>\\\\n#include <specularmap_pars_fragment>\\\\n#include <logdepthbuf_pars_fragment>\\\\n#include <clipping_planes_pars_fragment>\\\\nvoid main() {\\\\n\\\\t#include <clipping_planes_fragment>\\\\n\\\\tvec4 diffuseColor = vec4( diffuse, opacity );\\\\n\\\\t#include <logdepthbuf_fragment>\\\\n\\\\t#include <map_fragment>\\\\n\\\\t#include <color_fragment>\\\\n\\\\t#include <alphamap_fragment>\\\\n\\\\t#include <alphatest_fragment>\\\\n\\\\t#include <specularmap_fragment>\\\\n\\\\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\\\\n\\\\t#ifdef USE_LIGHTMAP\\\\n\\\\t\\\\treflectedLight.indirectDiffuse += texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\\\\n\\\\t#else\\\\n\\\\t\\\\treflectedLight.indirectDiffuse += vec3( 1.0 );\\\\n\\\\t#endif\\\\n\\\\t#include <aomap_fragment>\\\\n\\\\treflectedLight.indirectDiffuse *= diffuseColor.rgb;\\\\n\\\\tvec3 outgoingLight = reflectedLight.indirectDiffuse;\\\\n\\\\t#include <envmap_fragment>\\\\n\\\\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\\\\n\\\\t#include <premultiplied_alpha_fragment>\\\\n\\\\t#include <tonemapping_fragment>\\\\n\\\\t#include <encodings_fragment>\\\\n\\\\t#include <fog_fragment>\\\\n}\\\\n\\\";\\n\\n\\tvar meshbasic_vert = \\\"#include <common>\\\\n#include <uv_pars_vertex>\\\\n#include <uv2_pars_vertex>\\\\n#include <envmap_pars_vertex>\\\\n#include <color_pars_vertex>\\\\n#include <fog_pars_vertex>\\\\n#include <morphtarget_pars_vertex>\\\\n#include <skinning_pars_vertex>\\\\n#include <logdepthbuf_pars_vertex>\\\\n#include <clipping_planes_pars_vertex>\\\\nvoid main() {\\\\n\\\\t#include <uv_vertex>\\\\n\\\\t#include <uv2_vertex>\\\\n\\\\t#include <color_vertex>\\\\n\\\\t#include <skinbase_vertex>\\\\n\\\\t#ifdef USE_ENVMAP\\\\n\\\\t#include <beginnormal_vertex>\\\\n\\\\t#include <morphnormal_vertex>\\\\n\\\\t#include <skinnormal_vertex>\\\\n\\\\t#include <defaultnormal_vertex>\\\\n\\\\t#endif\\\\n\\\\t#include <begin_vertex>\\\\n\\\\t#include <morphtarget_vertex>\\\\n\\\\t#include <skinning_vertex>\\\\n\\\\t#include <project_vertex>\\\\n\\\\t#include <logdepthbuf_vertex>\\\\n\\\\t#include <worldpos_vertex>\\\\n\\\\t#include <clipping_planes_vertex>\\\\n\\\\t#include <envmap_vertex>\\\\n\\\\t#include <fog_vertex>\\\\n}\\\\n\\\";\\n\\n\\tvar meshlambert_frag = \\\"uniform vec3 diffuse;\\\\nuniform vec3 emissive;\\\\nuniform float opacity;\\\\nvarying vec3 vLightFront;\\\\n#ifdef DOUBLE_SIDED\\\\n\\\\tvarying vec3 vLightBack;\\\\n#endif\\\\n#include <common>\\\\n#include <packing>\\\\n#include <dithering_pars_fragment>\\\\n#include <color_pars_fragment>\\\\n#include <uv_pars_fragment>\\\\n#include <uv2_pars_fragment>\\\\n#include <map_pars_fragment>\\\\n#include <alphamap_pars_fragment>\\\\n#include <aomap_pars_fragment>\\\\n#include <lightmap_pars_fragment>\\\\n#include <emissivemap_pars_fragment>\\\\n#include <envmap_pars_fragment>\\\\n#include <bsdfs>\\\\n#include <lights_pars>\\\\n#include <fog_pars_fragment>\\\\n#include <shadowmap_pars_fragment>\\\\n#include <shadowmask_pars_fragment>\\\\n#include <specularmap_pars_fragment>\\\\n#include <logdepthbuf_pars_fragment>\\\\n#include <clipping_planes_pars_fragment>\\\\nvoid main() {\\\\n\\\\t#include <clipping_planes_fragment>\\\\n\\\\tvec4 diffuseColor = vec4( diffuse, opacity );\\\\n\\\\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\\\\n\\\\tvec3 totalEmissiveRadiance = emissive;\\\\n\\\\t#include <logdepthbuf_fragment>\\\\n\\\\t#include <map_fragment>\\\\n\\\\t#include <color_fragment>\\\\n\\\\t#include <alphamap_fragment>\\\\n\\\\t#include <alphatest_fragment>\\\\n\\\\t#include <specularmap_fragment>\\\\n\\\\t#include <emissivemap_fragment>\\\\n\\\\treflectedLight.indirectDiffuse = getAmbientLightIrradiance( ambientLightColor );\\\\n\\\\t#include <lightmap_fragment>\\\\n\\\\treflectedLight.indirectDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb );\\\\n\\\\t#ifdef DOUBLE_SIDED\\\\n\\\\t\\\\treflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;\\\\n\\\\t#else\\\\n\\\\t\\\\treflectedLight.directDiffuse = vLightFront;\\\\n\\\\t#endif\\\\n\\\\treflectedLight.directDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask();\\\\n\\\\t#include <aomap_fragment>\\\\n\\\\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\\\\n\\\\t#include <envmap_fragment>\\\\n\\\\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\\\\n\\\\t#include <tonemapping_fragment>\\\\n\\\\t#include <encodings_fragment>\\\\n\\\\t#include <fog_fragment>\\\\n\\\\t#include <premultiplied_alpha_fragment>\\\\n\\\\t#include <dithering_fragment>\\\\n}\\\\n\\\";\\n\\n\\tvar meshlambert_vert = \\\"#define LAMBERT\\\\nvarying vec3 vLightFront;\\\\n#ifdef DOUBLE_SIDED\\\\n\\\\tvarying vec3 vLightBack;\\\\n#endif\\\\n#include <common>\\\\n#include <uv_pars_vertex>\\\\n#include <uv2_pars_vertex>\\\\n#include <envmap_pars_vertex>\\\\n#include <bsdfs>\\\\n#include <lights_pars>\\\\n#include <color_pars_vertex>\\\\n#include <fog_pars_vertex>\\\\n#include <morphtarget_pars_vertex>\\\\n#include <skinning_pars_vertex>\\\\n#include <shadowmap_pars_vertex>\\\\n#include <logdepthbuf_pars_vertex>\\\\n#include <clipping_planes_pars_vertex>\\\\nvoid main() {\\\\n\\\\t#include <uv_vertex>\\\\n\\\\t#include <uv2_vertex>\\\\n\\\\t#include <color_vertex>\\\\n\\\\t#include <beginnormal_vertex>\\\\n\\\\t#include <morphnormal_vertex>\\\\n\\\\t#include <skinbase_vertex>\\\\n\\\\t#include <skinnormal_vertex>\\\\n\\\\t#include <defaultnormal_vertex>\\\\n\\\\t#include <begin_vertex>\\\\n\\\\t#include <morphtarget_vertex>\\\\n\\\\t#include <skinning_vertex>\\\\n\\\\t#include <project_vertex>\\\\n\\\\t#include <logdepthbuf_vertex>\\\\n\\\\t#include <clipping_planes_vertex>\\\\n\\\\t#include <worldpos_vertex>\\\\n\\\\t#include <envmap_vertex>\\\\n\\\\t#include <lights_lambert_vertex>\\\\n\\\\t#include <shadowmap_vertex>\\\\n\\\\t#include <fog_vertex>\\\\n}\\\\n\\\";\\n\\n\\tvar meshphong_frag = \\\"#define PHONG\\\\nuniform vec3 diffuse;\\\\nuniform vec3 emissive;\\\\nuniform vec3 specular;\\\\nuniform float shininess;\\\\nuniform float opacity;\\\\n#include <common>\\\\n#include <packing>\\\\n#include <dithering_pars_fragment>\\\\n#include <color_pars_fragment>\\\\n#include <uv_pars_fragment>\\\\n#include <uv2_pars_fragment>\\\\n#include <map_pars_fragment>\\\\n#include <alphamap_pars_fragment>\\\\n#include <aomap_pars_fragment>\\\\n#include <lightmap_pars_fragment>\\\\n#include <emissivemap_pars_fragment>\\\\n#include <envmap_pars_fragment>\\\\n#include <gradientmap_pars_fragment>\\\\n#include <fog_pars_fragment>\\\\n#include <bsdfs>\\\\n#include <lights_pars>\\\\n#include <lights_phong_pars_fragment>\\\\n#include <shadowmap_pars_fragment>\\\\n#include <bumpmap_pars_fragment>\\\\n#include <normalmap_pars_fragment>\\\\n#include <specularmap_pars_fragment>\\\\n#include <logdepthbuf_pars_fragment>\\\\n#include <clipping_planes_pars_fragment>\\\\nvoid main() {\\\\n\\\\t#include <clipping_planes_fragment>\\\\n\\\\tvec4 diffuseColor = vec4( diffuse, opacity );\\\\n\\\\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\\\\n\\\\tvec3 totalEmissiveRadiance = emissive;\\\\n\\\\t#include <logdepthbuf_fragment>\\\\n\\\\t#include <map_fragment>\\\\n\\\\t#include <color_fragment>\\\\n\\\\t#include <alphamap_fragment>\\\\n\\\\t#include <alphatest_fragment>\\\\n\\\\t#include <specularmap_fragment>\\\\n\\\\t#include <normal_fragment>\\\\n\\\\t#include <emissivemap_fragment>\\\\n\\\\t#include <lights_phong_fragment>\\\\n\\\\t#include <lights_template>\\\\n\\\\t#include <aomap_fragment>\\\\n\\\\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\\\\n\\\\t#include <envmap_fragment>\\\\n\\\\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\\\\n\\\\t#include <tonemapping_fragment>\\\\n\\\\t#include <encodings_fragment>\\\\n\\\\t#include <fog_fragment>\\\\n\\\\t#include <premultiplied_alpha_fragment>\\\\n\\\\t#include <dithering_fragment>\\\\n}\\\\n\\\";\\n\\n\\tvar meshphong_vert = \\\"#define PHONG\\\\nvarying vec3 vViewPosition;\\\\n#ifndef FLAT_SHADED\\\\n\\\\tvarying vec3 vNormal;\\\\n#endif\\\\n#include <common>\\\\n#include <uv_pars_vertex>\\\\n#include <uv2_pars_vertex>\\\\n#include <displacementmap_pars_vertex>\\\\n#include <envmap_pars_vertex>\\\\n#include <color_pars_vertex>\\\\n#include <fog_pars_vertex>\\\\n#include <morphtarget_pars_vertex>\\\\n#include <skinning_pars_vertex>\\\\n#include <shadowmap_pars_vertex>\\\\n#include <logdepthbuf_pars_vertex>\\\\n#include <clipping_planes_pars_vertex>\\\\nvoid main() {\\\\n\\\\t#include <uv_vertex>\\\\n\\\\t#include <uv2_vertex>\\\\n\\\\t#include <color_vertex>\\\\n\\\\t#include <beginnormal_vertex>\\\\n\\\\t#include <morphnormal_vertex>\\\\n\\\\t#include <skinbase_vertex>\\\\n\\\\t#include <skinnormal_vertex>\\\\n\\\\t#include <defaultnormal_vertex>\\\\n#ifndef FLAT_SHADED\\\\n\\\\tvNormal = normalize( transformedNormal );\\\\n#endif\\\\n\\\\t#include <begin_vertex>\\\\n\\\\t#include <morphtarget_vertex>\\\\n\\\\t#include <skinning_vertex>\\\\n\\\\t#include <displacementmap_vertex>\\\\n\\\\t#include <project_vertex>\\\\n\\\\t#include <logdepthbuf_vertex>\\\\n\\\\t#include <clipping_planes_vertex>\\\\n\\\\tvViewPosition = - mvPosition.xyz;\\\\n\\\\t#include <worldpos_vertex>\\\\n\\\\t#include <envmap_vertex>\\\\n\\\\t#include <shadowmap_vertex>\\\\n\\\\t#include <fog_vertex>\\\\n}\\\\n\\\";\\n\\n\\tvar meshphysical_frag = \\\"#define PHYSICAL\\\\nuniform vec3 diffuse;\\\\nuniform vec3 emissive;\\\\nuniform float roughness;\\\\nuniform float metalness;\\\\nuniform float opacity;\\\\n#ifndef STANDARD\\\\n\\\\tuniform float clearCoat;\\\\n\\\\tuniform float clearCoatRoughness;\\\\n#endif\\\\nvarying vec3 vViewPosition;\\\\n#ifndef FLAT_SHADED\\\\n\\\\tvarying vec3 vNormal;\\\\n#endif\\\\n#include <common>\\\\n#include <packing>\\\\n#include <dithering_pars_fragment>\\\\n#include <color_pars_fragment>\\\\n#include <uv_pars_fragment>\\\\n#include <uv2_pars_fragment>\\\\n#include <map_pars_fragment>\\\\n#include <alphamap_pars_fragment>\\\\n#include <aomap_pars_fragment>\\\\n#include <lightmap_pars_fragment>\\\\n#include <emissivemap_pars_fragment>\\\\n#include <envmap_pars_fragment>\\\\n#include <fog_pars_fragment>\\\\n#include <bsdfs>\\\\n#include <cube_uv_reflection_fragment>\\\\n#include <lights_pars>\\\\n#include <lights_physical_pars_fragment>\\\\n#include <shadowmap_pars_fragment>\\\\n#include <bumpmap_pars_fragment>\\\\n#include <normalmap_pars_fragment>\\\\n#include <roughnessmap_pars_fragment>\\\\n#include <metalnessmap_pars_fragment>\\\\n#include <logdepthbuf_pars_fragment>\\\\n#include <clipping_planes_pars_fragment>\\\\nvoid main() {\\\\n\\\\t#include <clipping_planes_fragment>\\\\n\\\\tvec4 diffuseColor = vec4( diffuse, opacity );\\\\n\\\\tReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\\\\n\\\\tvec3 totalEmissiveRadiance = emissive;\\\\n\\\\t#include <logdepthbuf_fragment>\\\\n\\\\t#include <map_fragment>\\\\n\\\\t#include <color_fragment>\\\\n\\\\t#include <alphamap_fragment>\\\\n\\\\t#include <alphatest_fragment>\\\\n\\\\t#include <roughnessmap_fragment>\\\\n\\\\t#include <metalnessmap_fragment>\\\\n\\\\t#include <normal_fragment>\\\\n\\\\t#include <emissivemap_fragment>\\\\n\\\\t#include <lights_physical_fragment>\\\\n\\\\t#include <lights_template>\\\\n\\\\t#include <aomap_fragment>\\\\n\\\\tvec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\\\\n\\\\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\\\\n\\\\t#include <tonemapping_fragment>\\\\n\\\\t#include <encodings_fragment>\\\\n\\\\t#include <fog_fragment>\\\\n\\\\t#include <premultiplied_alpha_fragment>\\\\n\\\\t#include <dithering_fragment>\\\\n}\\\\n\\\";\\n\\n\\tvar meshphysical_vert = \\\"#define PHYSICAL\\\\nvarying vec3 vViewPosition;\\\\n#ifndef FLAT_SHADED\\\\n\\\\tvarying vec3 vNormal;\\\\n#endif\\\\n#include <common>\\\\n#include <uv_pars_vertex>\\\\n#include <uv2_pars_vertex>\\\\n#include <displacementmap_pars_vertex>\\\\n#include <color_pars_vertex>\\\\n#include <fog_pars_vertex>\\\\n#include <morphtarget_pars_vertex>\\\\n#include <skinning_pars_vertex>\\\\n#include <shadowmap_pars_vertex>\\\\n#include <logdepthbuf_pars_vertex>\\\\n#include <clipping_planes_pars_vertex>\\\\nvoid main() {\\\\n\\\\t#include <uv_vertex>\\\\n\\\\t#include <uv2_vertex>\\\\n\\\\t#include <color_vertex>\\\\n\\\\t#include <beginnormal_vertex>\\\\n\\\\t#include <morphnormal_vertex>\\\\n\\\\t#include <skinbase_vertex>\\\\n\\\\t#include <skinnormal_vertex>\\\\n\\\\t#include <defaultnormal_vertex>\\\\n#ifndef FLAT_SHADED\\\\n\\\\tvNormal = normalize( transformedNormal );\\\\n#endif\\\\n\\\\t#include <begin_vertex>\\\\n\\\\t#include <morphtarget_vertex>\\\\n\\\\t#include <skinning_vertex>\\\\n\\\\t#include <displacementmap_vertex>\\\\n\\\\t#include <project_vertex>\\\\n\\\\t#include <logdepthbuf_vertex>\\\\n\\\\t#include <clipping_planes_vertex>\\\\n\\\\tvViewPosition = - mvPosition.xyz;\\\\n\\\\t#include <worldpos_vertex>\\\\n\\\\t#include <shadowmap_vertex>\\\\n\\\\t#include <fog_vertex>\\\\n}\\\\n\\\";\\n\\n\\tvar normal_frag = \\\"#define NORMAL\\\\nuniform float opacity;\\\\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP )\\\\n\\\\tvarying vec3 vViewPosition;\\\\n#endif\\\\n#ifndef FLAT_SHADED\\\\n\\\\tvarying vec3 vNormal;\\\\n#endif\\\\n#include <packing>\\\\n#include <uv_pars_fragment>\\\\n#include <bumpmap_pars_fragment>\\\\n#include <normalmap_pars_fragment>\\\\n#include <logdepthbuf_pars_fragment>\\\\nvoid main() {\\\\n\\\\t#include <logdepthbuf_fragment>\\\\n\\\\t#include <normal_fragment>\\\\n\\\\tgl_FragColor = vec4( packNormalToRGB( normal ), opacity );\\\\n}\\\\n\\\";\\n\\n\\tvar normal_vert = \\\"#define NORMAL\\\\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP )\\\\n\\\\tvarying vec3 vViewPosition;\\\\n#endif\\\\n#ifndef FLAT_SHADED\\\\n\\\\tvarying vec3 vNormal;\\\\n#endif\\\\n#include <uv_pars_vertex>\\\\n#include <displacementmap_pars_vertex>\\\\n#include <morphtarget_pars_vertex>\\\\n#include <skinning_pars_vertex>\\\\n#include <logdepthbuf_pars_vertex>\\\\nvoid main() {\\\\n\\\\t#include <uv_vertex>\\\\n\\\\t#include <beginnormal_vertex>\\\\n\\\\t#include <morphnormal_vertex>\\\\n\\\\t#include <skinbase_vertex>\\\\n\\\\t#include <skinnormal_vertex>\\\\n\\\\t#include <defaultnormal_vertex>\\\\n#ifndef FLAT_SHADED\\\\n\\\\tvNormal = normalize( transformedNormal );\\\\n#endif\\\\n\\\\t#include <begin_vertex>\\\\n\\\\t#include <morphtarget_vertex>\\\\n\\\\t#include <skinning_vertex>\\\\n\\\\t#include <displacementmap_vertex>\\\\n\\\\t#include <project_vertex>\\\\n\\\\t#include <logdepthbuf_vertex>\\\\n#if defined( FLAT_SHADED ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP )\\\\n\\\\tvViewPosition = - mvPosition.xyz;\\\\n#endif\\\\n}\\\\n\\\";\\n\\n\\tvar points_frag = \\\"uniform vec3 diffuse;\\\\nuniform float opacity;\\\\n#include <common>\\\\n#include <packing>\\\\n#include <color_pars_fragment>\\\\n#include <map_particle_pars_fragment>\\\\n#include <fog_pars_fragment>\\\\n#include <shadowmap_pars_fragment>\\\\n#include <logdepthbuf_pars_fragment>\\\\n#include <clipping_planes_pars_fragment>\\\\nvoid main() {\\\\n\\\\t#include <clipping_planes_fragment>\\\\n\\\\tvec3 outgoingLight = vec3( 0.0 );\\\\n\\\\tvec4 diffuseColor = vec4( diffuse, opacity );\\\\n\\\\t#include <logdepthbuf_fragment>\\\\n\\\\t#include <map_particle_fragment>\\\\n\\\\t#include <color_fragment>\\\\n\\\\t#include <alphatest_fragment>\\\\n\\\\toutgoingLight = diffuseColor.rgb;\\\\n\\\\tgl_FragColor = vec4( outgoingLight, diffuseColor.a );\\\\n\\\\t#include <premultiplied_alpha_fragment>\\\\n\\\\t#include <tonemapping_fragment>\\\\n\\\\t#include <encodings_fragment>\\\\n\\\\t#include <fog_fragment>\\\\n}\\\\n\\\";\\n\\n\\tvar points_vert = \\\"uniform float size;\\\\nuniform float scale;\\\\n#include <common>\\\\n#include <color_pars_vertex>\\\\n#include <fog_pars_vertex>\\\\n#include <shadowmap_pars_vertex>\\\\n#include <logdepthbuf_pars_vertex>\\\\n#include <clipping_planes_pars_vertex>\\\\nvoid main() {\\\\n\\\\t#include <color_vertex>\\\\n\\\\t#include <begin_vertex>\\\\n\\\\t#include <project_vertex>\\\\n\\\\t#ifdef USE_SIZEATTENUATION\\\\n\\\\t\\\\tgl_PointSize = size * ( scale / - mvPosition.z );\\\\n\\\\t#else\\\\n\\\\t\\\\tgl_PointSize = size;\\\\n\\\\t#endif\\\\n\\\\t#include <logdepthbuf_vertex>\\\\n\\\\t#include <clipping_planes_vertex>\\\\n\\\\t#include <worldpos_vertex>\\\\n\\\\t#include <shadowmap_vertex>\\\\n\\\\t#include <fog_vertex>\\\\n}\\\\n\\\";\\n\\n\\tvar shadow_frag = \\\"uniform vec3 color;\\\\nuniform float opacity;\\\\n#include <common>\\\\n#include <packing>\\\\n#include <fog_pars_fragment>\\\\n#include <bsdfs>\\\\n#include <lights_pars>\\\\n#include <shadowmap_pars_fragment>\\\\n#include <shadowmask_pars_fragment>\\\\nvoid main() {\\\\n\\\\tgl_FragColor = vec4( color, opacity * ( 1.0 - getShadowMask() ) );\\\\n\\\\t#include <fog_fragment>\\\\n}\\\\n\\\";\\n\\n\\tvar shadow_vert = \\\"#include <fog_pars_vertex>\\\\n#include <shadowmap_pars_vertex>\\\\nvoid main() {\\\\n\\\\t#include <begin_vertex>\\\\n\\\\t#include <project_vertex>\\\\n\\\\t#include <worldpos_vertex>\\\\n\\\\t#include <shadowmap_vertex>\\\\n\\\\t#include <fog_vertex>\\\\n}\\\\n\\\";\\n\\n\\tvar ShaderChunk = {\\n\\t\\talphamap_fragment: alphamap_fragment,\\n\\t\\talphamap_pars_fragment: alphamap_pars_fragment,\\n\\t\\talphatest_fragment: alphatest_fragment,\\n\\t\\taomap_fragment: aomap_fragment,\\n\\t\\taomap_pars_fragment: aomap_pars_fragment,\\n\\t\\tbegin_vertex: begin_vertex,\\n\\t\\tbeginnormal_vertex: beginnormal_vertex,\\n\\t\\tbsdfs: bsdfs,\\n\\t\\tbumpmap_pars_fragment: bumpmap_pars_fragment,\\n\\t\\tclipping_planes_fragment: clipping_planes_fragment,\\n\\t\\tclipping_planes_pars_fragment: clipping_planes_pars_fragment,\\n\\t\\tclipping_planes_pars_vertex: clipping_planes_pars_vertex,\\n\\t\\tclipping_planes_vertex: clipping_planes_vertex,\\n\\t\\tcolor_fragment: color_fragment,\\n\\t\\tcolor_pars_fragment: color_pars_fragment,\\n\\t\\tcolor_pars_vertex: color_pars_vertex,\\n\\t\\tcolor_vertex: color_vertex,\\n\\t\\tcommon: common,\\n\\t\\tcube_uv_reflection_fragment: cube_uv_reflection_fragment,\\n\\t\\tdefaultnormal_vertex: defaultnormal_vertex,\\n\\t\\tdisplacementmap_pars_vertex: displacementmap_pars_vertex,\\n\\t\\tdisplacementmap_vertex: displacementmap_vertex,\\n\\t\\temissivemap_fragment: emissivemap_fragment,\\n\\t\\temissivemap_pars_fragment: emissivemap_pars_fragment,\\n\\t\\tencodings_fragment: encodings_fragment,\\n\\t\\tencodings_pars_fragment: encodings_pars_fragment,\\n\\t\\tenvmap_fragment: envmap_fragment,\\n\\t\\tenvmap_pars_fragment: envmap_pars_fragment,\\n\\t\\tenvmap_pars_vertex: envmap_pars_vertex,\\n\\t\\tenvmap_vertex: envmap_vertex,\\n\\t\\tfog_vertex: fog_vertex,\\n\\t\\tfog_pars_vertex: fog_pars_vertex,\\n\\t\\tfog_fragment: fog_fragment,\\n\\t\\tfog_pars_fragment: fog_pars_fragment,\\n\\t\\tgradientmap_pars_fragment: gradientmap_pars_fragment,\\n\\t\\tlightmap_fragment: lightmap_fragment,\\n\\t\\tlightmap_pars_fragment: lightmap_pars_fragment,\\n\\t\\tlights_lambert_vertex: lights_lambert_vertex,\\n\\t\\tlights_pars: lights_pars,\\n\\t\\tlights_phong_fragment: lights_phong_fragment,\\n\\t\\tlights_phong_pars_fragment: lights_phong_pars_fragment,\\n\\t\\tlights_physical_fragment: lights_physical_fragment,\\n\\t\\tlights_physical_pars_fragment: lights_physical_pars_fragment,\\n\\t\\tlights_template: lights_template,\\n\\t\\tlogdepthbuf_fragment: logdepthbuf_fragment,\\n\\t\\tlogdepthbuf_pars_fragment: logdepthbuf_pars_fragment,\\n\\t\\tlogdepthbuf_pars_vertex: logdepthbuf_pars_vertex,\\n\\t\\tlogdepthbuf_vertex: logdepthbuf_vertex,\\n\\t\\tmap_fragment: map_fragment,\\n\\t\\tmap_pars_fragment: map_pars_fragment,\\n\\t\\tmap_particle_fragment: map_particle_fragment,\\n\\t\\tmap_particle_pars_fragment: map_particle_pars_fragment,\\n\\t\\tmetalnessmap_fragment: metalnessmap_fragment,\\n\\t\\tmetalnessmap_pars_fragment: metalnessmap_pars_fragment,\\n\\t\\tmorphnormal_vertex: morphnormal_vertex,\\n\\t\\tmorphtarget_pars_vertex: morphtarget_pars_vertex,\\n\\t\\tmorphtarget_vertex: morphtarget_vertex,\\n\\t\\tnormal_fragment: normal_fragment,\\n\\t\\tnormalmap_pars_fragment: normalmap_pars_fragment,\\n\\t\\tpacking: packing,\\n\\t\\tpremultiplied_alpha_fragment: premultiplied_alpha_fragment,\\n\\t\\tproject_vertex: project_vertex,\\n\\t\\tdithering_fragment: dithering_fragment,\\n\\t\\tdithering_pars_fragment: dithering_pars_fragment,\\n\\t\\troughnessmap_fragment: roughnessmap_fragment,\\n\\t\\troughnessmap_pars_fragment: roughnessmap_pars_fragment,\\n\\t\\tshadowmap_pars_fragment: shadowmap_pars_fragment,\\n\\t\\tshadowmap_pars_vertex: shadowmap_pars_vertex,\\n\\t\\tshadowmap_vertex: shadowmap_vertex,\\n\\t\\tshadowmask_pars_fragment: shadowmask_pars_fragment,\\n\\t\\tskinbase_vertex: skinbase_vertex,\\n\\t\\tskinning_pars_vertex: skinning_pars_vertex,\\n\\t\\tskinning_vertex: skinning_vertex,\\n\\t\\tskinnormal_vertex: skinnormal_vertex,\\n\\t\\tspecularmap_fragment: specularmap_fragment,\\n\\t\\tspecularmap_pars_fragment: specularmap_pars_fragment,\\n\\t\\ttonemapping_fragment: tonemapping_fragment,\\n\\t\\ttonemapping_pars_fragment: tonemapping_pars_fragment,\\n\\t\\tuv_pars_fragment: uv_pars_fragment,\\n\\t\\tuv_pars_vertex: uv_pars_vertex,\\n\\t\\tuv_vertex: uv_vertex,\\n\\t\\tuv2_pars_fragment: uv2_pars_fragment,\\n\\t\\tuv2_pars_vertex: uv2_pars_vertex,\\n\\t\\tuv2_vertex: uv2_vertex,\\n\\t\\tworldpos_vertex: worldpos_vertex,\\n\\n\\t\\tcube_frag: cube_frag,\\n\\t\\tcube_vert: cube_vert,\\n\\t\\tdepth_frag: depth_frag,\\n\\t\\tdepth_vert: depth_vert,\\n\\t\\tdistanceRGBA_frag: distanceRGBA_frag,\\n\\t\\tdistanceRGBA_vert: distanceRGBA_vert,\\n\\t\\tequirect_frag: equirect_frag,\\n\\t\\tequirect_vert: equirect_vert,\\n\\t\\tlinedashed_frag: linedashed_frag,\\n\\t\\tlinedashed_vert: linedashed_vert,\\n\\t\\tmeshbasic_frag: meshbasic_frag,\\n\\t\\tmeshbasic_vert: meshbasic_vert,\\n\\t\\tmeshlambert_frag: meshlambert_frag,\\n\\t\\tmeshlambert_vert: meshlambert_vert,\\n\\t\\tmeshphong_frag: meshphong_frag,\\n\\t\\tmeshphong_vert: meshphong_vert,\\n\\t\\tmeshphysical_frag: meshphysical_frag,\\n\\t\\tmeshphysical_vert: meshphysical_vert,\\n\\t\\tnormal_frag: normal_frag,\\n\\t\\tnormal_vert: normal_vert,\\n\\t\\tpoints_frag: points_frag,\\n\\t\\tpoints_vert: points_vert,\\n\\t\\tshadow_frag: shadow_frag,\\n\\t\\tshadow_vert: shadow_vert\\n\\t};\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t */\\n\\n\\tvar ShaderLib = {\\n\\n\\t\\tbasic: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.common,\\n\\t\\t\\t\\tUniformsLib.specularmap,\\n\\t\\t\\t\\tUniformsLib.envmap,\\n\\t\\t\\t\\tUniformsLib.aomap,\\n\\t\\t\\t\\tUniformsLib.lightmap,\\n\\t\\t\\t\\tUniformsLib.fog\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.meshbasic_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.meshbasic_frag\\n\\n\\t\\t},\\n\\n\\t\\tlambert: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.common,\\n\\t\\t\\t\\tUniformsLib.specularmap,\\n\\t\\t\\t\\tUniformsLib.envmap,\\n\\t\\t\\t\\tUniformsLib.aomap,\\n\\t\\t\\t\\tUniformsLib.lightmap,\\n\\t\\t\\t\\tUniformsLib.emissivemap,\\n\\t\\t\\t\\tUniformsLib.fog,\\n\\t\\t\\t\\tUniformsLib.lights,\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\temissive: { value: new Color( 0x000000 ) }\\n\\t\\t\\t\\t}\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.meshlambert_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.meshlambert_frag\\n\\n\\t\\t},\\n\\n\\t\\tphong: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.common,\\n\\t\\t\\t\\tUniformsLib.specularmap,\\n\\t\\t\\t\\tUniformsLib.envmap,\\n\\t\\t\\t\\tUniformsLib.aomap,\\n\\t\\t\\t\\tUniformsLib.lightmap,\\n\\t\\t\\t\\tUniformsLib.emissivemap,\\n\\t\\t\\t\\tUniformsLib.bumpmap,\\n\\t\\t\\t\\tUniformsLib.normalmap,\\n\\t\\t\\t\\tUniformsLib.displacementmap,\\n\\t\\t\\t\\tUniformsLib.gradientmap,\\n\\t\\t\\t\\tUniformsLib.fog,\\n\\t\\t\\t\\tUniformsLib.lights,\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\temissive: { value: new Color( 0x000000 ) },\\n\\t\\t\\t\\t\\tspecular: { value: new Color( 0x111111 ) },\\n\\t\\t\\t\\t\\tshininess: { value: 30 }\\n\\t\\t\\t\\t}\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.meshphong_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.meshphong_frag\\n\\n\\t\\t},\\n\\n\\t\\tstandard: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.common,\\n\\t\\t\\t\\tUniformsLib.envmap,\\n\\t\\t\\t\\tUniformsLib.aomap,\\n\\t\\t\\t\\tUniformsLib.lightmap,\\n\\t\\t\\t\\tUniformsLib.emissivemap,\\n\\t\\t\\t\\tUniformsLib.bumpmap,\\n\\t\\t\\t\\tUniformsLib.normalmap,\\n\\t\\t\\t\\tUniformsLib.displacementmap,\\n\\t\\t\\t\\tUniformsLib.roughnessmap,\\n\\t\\t\\t\\tUniformsLib.metalnessmap,\\n\\t\\t\\t\\tUniformsLib.fog,\\n\\t\\t\\t\\tUniformsLib.lights,\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\temissive: { value: new Color( 0x000000 ) },\\n\\t\\t\\t\\t\\troughness: { value: 0.5 },\\n\\t\\t\\t\\t\\tmetalness: { value: 0.5 },\\n\\t\\t\\t\\t\\tenvMapIntensity: { value: 1 } // temporary\\n\\t\\t\\t\\t}\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.meshphysical_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.meshphysical_frag\\n\\n\\t\\t},\\n\\n\\t\\tpoints: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.points,\\n\\t\\t\\t\\tUniformsLib.fog\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.points_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.points_frag\\n\\n\\t\\t},\\n\\n\\t\\tdashed: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.common,\\n\\t\\t\\t\\tUniformsLib.fog,\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tscale: { value: 1 },\\n\\t\\t\\t\\t\\tdashSize: { value: 1 },\\n\\t\\t\\t\\t\\ttotalSize: { value: 2 }\\n\\t\\t\\t\\t}\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.linedashed_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.linedashed_frag\\n\\n\\t\\t},\\n\\n\\t\\tdepth: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.common,\\n\\t\\t\\t\\tUniformsLib.displacementmap\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.depth_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.depth_frag\\n\\n\\t\\t},\\n\\n\\t\\tnormal: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.common,\\n\\t\\t\\t\\tUniformsLib.bumpmap,\\n\\t\\t\\t\\tUniformsLib.normalmap,\\n\\t\\t\\t\\tUniformsLib.displacementmap,\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\topacity: { value: 1.0 }\\n\\t\\t\\t\\t}\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.normal_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.normal_frag\\n\\n\\t\\t},\\n\\n\\t\\t/* -------------------------------------------------------------------------\\n\\t\\t//\\tCube map shader\\n\\t\\t ------------------------------------------------------------------------- */\\n\\n\\t\\tcube: {\\n\\n\\t\\t\\tuniforms: {\\n\\t\\t\\t\\ttCube: { value: null },\\n\\t\\t\\t\\ttFlip: { value: - 1 },\\n\\t\\t\\t\\topacity: { value: 1.0 }\\n\\t\\t\\t},\\n\\n\\t\\t\\tvertexShader: ShaderChunk.cube_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.cube_frag\\n\\n\\t\\t},\\n\\n\\t\\tequirect: {\\n\\n\\t\\t\\tuniforms: {\\n\\t\\t\\t\\ttEquirect: { value: null },\\n\\t\\t\\t},\\n\\n\\t\\t\\tvertexShader: ShaderChunk.equirect_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.equirect_frag\\n\\n\\t\\t},\\n\\n\\t\\tdistanceRGBA: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.common,\\n\\t\\t\\t\\tUniformsLib.displacementmap,\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\treferencePosition: { value: new Vector3() },\\n\\t\\t\\t\\t\\tnearDistance: { value: 1 },\\n\\t\\t\\t\\t\\tfarDistance: { value: 1000 }\\n\\t\\t\\t\\t}\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.distanceRGBA_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.distanceRGBA_frag\\n\\n\\t\\t},\\n\\n\\t\\tshadow: {\\n\\n\\t\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\t\\tUniformsLib.lights,\\n\\t\\t\\t\\tUniformsLib.fog,\\n\\t\\t\\t\\t{\\n\\t\\t\\t\\t\\tcolor: { value: new Color( 0x00000 ) },\\n\\t\\t\\t\\t\\topacity: { value: 1.0 }\\n\\t\\t\\t\\t},\\n\\t\\t\\t] ),\\n\\n\\t\\t\\tvertexShader: ShaderChunk.shadow_vert,\\n\\t\\t\\tfragmentShader: ShaderChunk.shadow_frag\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\tShaderLib.physical = {\\n\\n\\t\\tuniforms: UniformsUtils.merge( [\\n\\t\\t\\tShaderLib.standard.uniforms,\\n\\t\\t\\t{\\n\\t\\t\\t\\tclearCoat: { value: 0 },\\n\\t\\t\\t\\tclearCoatRoughness: { value: 0 }\\n\\t\\t\\t}\\n\\t\\t] ),\\n\\n\\t\\tvertexShader: ShaderChunk.meshphysical_vert,\\n\\t\\tfragmentShader: ShaderChunk.meshphysical_frag\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author bhouston / http://clara.io\\n\\t */\\n\\n\\tfunction Box2( min, max ) {\\n\\n\\t\\tthis.min = ( min !== undefined ) ? min : new Vector2( + Infinity, + Infinity );\\n\\t\\tthis.max = ( max !== undefined ) ? max : new Vector2( - Infinity, - Infinity );\\n\\n\\t}\\n\\n\\tObject.assign( Box2.prototype, {\\n\\n\\t\\tset: function ( min, max ) {\\n\\n\\t\\t\\tthis.min.copy( min );\\n\\t\\t\\tthis.max.copy( max );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromPoints: function ( points ) {\\n\\n\\t\\t\\tthis.makeEmpty();\\n\\n\\t\\t\\tfor ( var i = 0, il = points.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.expandByPoint( points[ i ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromCenterAndSize: function () {\\n\\n\\t\\t\\tvar v1 = new Vector2();\\n\\n\\t\\t\\treturn function setFromCenterAndSize( center, size ) {\\n\\n\\t\\t\\t\\tvar halfSize = v1.copy( size ).multiplyScalar( 0.5 );\\n\\t\\t\\t\\tthis.min.copy( center ).sub( halfSize );\\n\\t\\t\\t\\tthis.max.copy( center ).add( halfSize );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( box ) {\\n\\n\\t\\t\\tthis.min.copy( box.min );\\n\\t\\t\\tthis.max.copy( box.max );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeEmpty: function () {\\n\\n\\t\\t\\tthis.min.x = this.min.y = + Infinity;\\n\\t\\t\\tthis.max.x = this.max.y = - Infinity;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tisEmpty: function () {\\n\\n\\t\\t\\t// this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes\\n\\n\\t\\t\\treturn ( this.max.x < this.min.x ) || ( this.max.y < this.min.y );\\n\\n\\t\\t},\\n\\n\\t\\tgetCenter: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector2();\\n\\t\\t\\treturn this.isEmpty() ? result.set( 0, 0 ) : result.addVectors( this.min, this.max ).multiplyScalar( 0.5 );\\n\\n\\t\\t},\\n\\n\\t\\tgetSize: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector2();\\n\\t\\t\\treturn this.isEmpty() ? result.set( 0, 0 ) : result.subVectors( this.max, this.min );\\n\\n\\t\\t},\\n\\n\\t\\texpandByPoint: function ( point ) {\\n\\n\\t\\t\\tthis.min.min( point );\\n\\t\\t\\tthis.max.max( point );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\texpandByVector: function ( vector ) {\\n\\n\\t\\t\\tthis.min.sub( vector );\\n\\t\\t\\tthis.max.add( vector );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\texpandByScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.min.addScalar( - scalar );\\n\\t\\t\\tthis.max.addScalar( scalar );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcontainsPoint: function ( point ) {\\n\\n\\t\\t\\treturn point.x < this.min.x || point.x > this.max.x ||\\n\\t\\t\\t\\tpoint.y < this.min.y || point.y > this.max.y ? false : true;\\n\\n\\t\\t},\\n\\n\\t\\tcontainsBox: function ( box ) {\\n\\n\\t\\t\\treturn this.min.x <= box.min.x && box.max.x <= this.max.x &&\\n\\t\\t\\t\\tthis.min.y <= box.min.y && box.max.y <= this.max.y;\\n\\n\\t\\t},\\n\\n\\t\\tgetParameter: function ( point, optionalTarget ) {\\n\\n\\t\\t\\t// This can potentially have a divide by zero if the box\\n\\t\\t\\t// has a size dimension of 0.\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector2();\\n\\n\\t\\t\\treturn result.set(\\n\\t\\t\\t\\t( point.x - this.min.x ) / ( this.max.x - this.min.x ),\\n\\t\\t\\t\\t( point.y - this.min.y ) / ( this.max.y - this.min.y )\\n\\t\\t\\t);\\n\\n\\t\\t},\\n\\n\\t\\tintersectsBox: function ( box ) {\\n\\n\\t\\t\\t// using 4 splitting planes to rule out intersections\\n\\n\\t\\t\\treturn box.max.x < this.min.x || box.min.x > this.max.x ||\\n\\t\\t\\t\\tbox.max.y < this.min.y || box.min.y > this.max.y ? false : true;\\n\\n\\t\\t},\\n\\n\\t\\tclampPoint: function ( point, optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector2();\\n\\t\\t\\treturn result.copy( point ).clamp( this.min, this.max );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToPoint: function () {\\n\\n\\t\\t\\tvar v1 = new Vector2();\\n\\n\\t\\t\\treturn function distanceToPoint( point ) {\\n\\n\\t\\t\\t\\tvar clampedPoint = v1.copy( point ).clamp( this.min, this.max );\\n\\t\\t\\t\\treturn clampedPoint.sub( point ).length();\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tintersect: function ( box ) {\\n\\n\\t\\t\\tthis.min.max( box.min );\\n\\t\\t\\tthis.max.min( box.max );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tunion: function ( box ) {\\n\\n\\t\\t\\tthis.min.min( box.min );\\n\\t\\t\\tthis.max.max( box.max );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttranslate: function ( offset ) {\\n\\n\\t\\t\\tthis.min.add( offset );\\n\\t\\t\\tthis.max.add( offset );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( box ) {\\n\\n\\t\\t\\treturn box.min.equals( this.min ) && box.max.equals( this.max );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction WebGLFlareRenderer( renderer, gl, state, textures, capabilities ) {\\n\\n\\t\\tvar vertexBuffer, elementBuffer;\\n\\t\\tvar shader, program, attributes, uniforms;\\n\\n\\t\\tvar tempTexture, occlusionTexture;\\n\\n\\t\\tfunction init() {\\n\\n\\t\\t\\tvar vertices = new Float32Array( [\\n\\t\\t\\t\\t- 1, - 1, 0, 0,\\n\\t\\t\\t\\t  1, - 1, 1, 0,\\n\\t\\t\\t\\t  1, 1, 1, 1,\\n\\t\\t\\t\\t- 1, 1, 0, 1\\n\\t\\t\\t] );\\n\\n\\t\\t\\tvar faces = new Uint16Array( [\\n\\t\\t\\t\\t0, 1, 2,\\n\\t\\t\\t\\t0, 2, 3\\n\\t\\t\\t] );\\n\\n\\t\\t\\t// buffers\\n\\n\\t\\t\\tvertexBuffer = gl.createBuffer();\\n\\t\\t\\telementBuffer = gl.createBuffer();\\n\\n\\t\\t\\tgl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer );\\n\\t\\t\\tgl.bufferData( gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW );\\n\\n\\t\\t\\tgl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer );\\n\\t\\t\\tgl.bufferData( gl.ELEMENT_ARRAY_BUFFER, faces, gl.STATIC_DRAW );\\n\\n\\t\\t\\t// textures\\n\\n\\t\\t\\ttempTexture = gl.createTexture();\\n\\t\\t\\tocclusionTexture = gl.createTexture();\\n\\n\\t\\t\\tstate.bindTexture( gl.TEXTURE_2D, tempTexture );\\n\\t\\t\\tgl.texImage2D( gl.TEXTURE_2D, 0, gl.RGB, 16, 16, 0, gl.RGB, gl.UNSIGNED_BYTE, null );\\n\\t\\t\\tgl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE );\\n\\t\\t\\tgl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE );\\n\\t\\t\\tgl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST );\\n\\t\\t\\tgl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST );\\n\\n\\t\\t\\tstate.bindTexture( gl.TEXTURE_2D, occlusionTexture );\\n\\t\\t\\tgl.texImage2D( gl.TEXTURE_2D, 0, gl.RGBA, 16, 16, 0, gl.RGBA, gl.UNSIGNED_BYTE, null );\\n\\t\\t\\tgl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE );\\n\\t\\t\\tgl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE );\\n\\t\\t\\tgl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST );\\n\\t\\t\\tgl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST );\\n\\n\\t\\t\\tshader = {\\n\\n\\t\\t\\t\\tvertexShader: [\\n\\n\\t\\t\\t\\t\\t'uniform lowp int renderType;',\\n\\n\\t\\t\\t\\t\\t'uniform vec3 screenPosition;',\\n\\t\\t\\t\\t\\t'uniform vec2 scale;',\\n\\t\\t\\t\\t\\t'uniform float rotation;',\\n\\n\\t\\t\\t\\t\\t'uniform sampler2D occlusionMap;',\\n\\n\\t\\t\\t\\t\\t'attribute vec2 position;',\\n\\t\\t\\t\\t\\t'attribute vec2 uv;',\\n\\n\\t\\t\\t\\t\\t'varying vec2 vUV;',\\n\\t\\t\\t\\t\\t'varying float vVisibility;',\\n\\n\\t\\t\\t\\t\\t'void main() {',\\n\\n\\t\\t\\t\\t\\t'\\tvUV = uv;',\\n\\n\\t\\t\\t\\t\\t'\\tvec2 pos = position;',\\n\\n\\t\\t\\t\\t\\t'\\tif ( renderType == 2 ) {',\\n\\n\\t\\t\\t\\t\\t'\\t\\tvec4 visibility = texture2D( occlusionMap, vec2( 0.1, 0.1 ) );',\\n\\t\\t\\t\\t\\t'\\t\\tvisibility += texture2D( occlusionMap, vec2( 0.5, 0.1 ) );',\\n\\t\\t\\t\\t\\t'\\t\\tvisibility += texture2D( occlusionMap, vec2( 0.9, 0.1 ) );',\\n\\t\\t\\t\\t\\t'\\t\\tvisibility += texture2D( occlusionMap, vec2( 0.9, 0.5 ) );',\\n\\t\\t\\t\\t\\t'\\t\\tvisibility += texture2D( occlusionMap, vec2( 0.9, 0.9 ) );',\\n\\t\\t\\t\\t\\t'\\t\\tvisibility += texture2D( occlusionMap, vec2( 0.5, 0.9 ) );',\\n\\t\\t\\t\\t\\t'\\t\\tvisibility += texture2D( occlusionMap, vec2( 0.1, 0.9 ) );',\\n\\t\\t\\t\\t\\t'\\t\\tvisibility += texture2D( occlusionMap, vec2( 0.1, 0.5 ) );',\\n\\t\\t\\t\\t\\t'\\t\\tvisibility += texture2D( occlusionMap, vec2( 0.5, 0.5 ) );',\\n\\n\\t\\t\\t\\t\\t'\\t\\tvVisibility =        visibility.r / 9.0;',\\n\\t\\t\\t\\t\\t'\\t\\tvVisibility *= 1.0 - visibility.g / 9.0;',\\n\\t\\t\\t\\t\\t'\\t\\tvVisibility *=       visibility.b / 9.0;',\\n\\t\\t\\t\\t\\t'\\t\\tvVisibility *= 1.0 - visibility.a / 9.0;',\\n\\n\\t\\t\\t\\t\\t'\\t\\tpos.x = cos( rotation ) * position.x - sin( rotation ) * position.y;',\\n\\t\\t\\t\\t\\t'\\t\\tpos.y = sin( rotation ) * position.x + cos( rotation ) * position.y;',\\n\\n\\t\\t\\t\\t\\t'\\t}',\\n\\n\\t\\t\\t\\t\\t'\\tgl_Position = vec4( ( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );',\\n\\n\\t\\t\\t\\t\\t'}'\\n\\n\\t\\t\\t\\t].join( '\\\\n' ),\\n\\n\\t\\t\\t\\tfragmentShader: [\\n\\n\\t\\t\\t\\t\\t'uniform lowp int renderType;',\\n\\n\\t\\t\\t\\t\\t'uniform sampler2D map;',\\n\\t\\t\\t\\t\\t'uniform float opacity;',\\n\\t\\t\\t\\t\\t'uniform vec3 color;',\\n\\n\\t\\t\\t\\t\\t'varying vec2 vUV;',\\n\\t\\t\\t\\t\\t'varying float vVisibility;',\\n\\n\\t\\t\\t\\t\\t'void main() {',\\n\\n\\t\\t\\t\\t\\t// pink square\\n\\n\\t\\t\\t\\t\\t'\\tif ( renderType == 0 ) {',\\n\\n\\t\\t\\t\\t\\t'\\t\\tgl_FragColor = vec4( 1.0, 0.0, 1.0, 0.0 );',\\n\\n\\t\\t\\t\\t\\t// restore\\n\\n\\t\\t\\t\\t\\t'\\t} else if ( renderType == 1 ) {',\\n\\n\\t\\t\\t\\t\\t'\\t\\tgl_FragColor = texture2D( map, vUV );',\\n\\n\\t\\t\\t\\t\\t// flare\\n\\n\\t\\t\\t\\t\\t'\\t} else {',\\n\\n\\t\\t\\t\\t\\t'\\t\\tvec4 texture = texture2D( map, vUV );',\\n\\t\\t\\t\\t\\t'\\t\\ttexture.a *= opacity * vVisibility;',\\n\\t\\t\\t\\t\\t'\\t\\tgl_FragColor = texture;',\\n\\t\\t\\t\\t\\t'\\t\\tgl_FragColor.rgb *= color;',\\n\\n\\t\\t\\t\\t\\t'\\t}',\\n\\n\\t\\t\\t\\t\\t'}'\\n\\n\\t\\t\\t\\t].join( '\\\\n' )\\n\\n\\t\\t\\t};\\n\\n\\t\\t\\tprogram = createProgram( shader );\\n\\n\\t\\t\\tattributes = {\\n\\t\\t\\t\\tvertex: gl.getAttribLocation( program, 'position' ),\\n\\t\\t\\t\\tuv: gl.getAttribLocation( program, 'uv' )\\n\\t\\t\\t};\\n\\n\\t\\t\\tuniforms = {\\n\\t\\t\\t\\trenderType: gl.getUniformLocation( program, 'renderType' ),\\n\\t\\t\\t\\tmap: gl.getUniformLocation( program, 'map' ),\\n\\t\\t\\t\\tocclusionMap: gl.getUniformLocation( program, 'occlusionMap' ),\\n\\t\\t\\t\\topacity: gl.getUniformLocation( program, 'opacity' ),\\n\\t\\t\\t\\tcolor: gl.getUniformLocation( program, 'color' ),\\n\\t\\t\\t\\tscale: gl.getUniformLocation( program, 'scale' ),\\n\\t\\t\\t\\trotation: gl.getUniformLocation( program, 'rotation' ),\\n\\t\\t\\t\\tscreenPosition: gl.getUniformLocation( program, 'screenPosition' )\\n\\t\\t\\t};\\n\\n\\t\\t}\\n\\n\\t\\t/*\\n\\t\\t * Render lens flares\\n\\t\\t * Method: renders 16x16 0xff00ff-colored points scattered over the light source area,\\n\\t\\t *         reads these back and calculates occlusion.\\n\\t\\t */\\n\\n\\t\\tthis.render = function ( flares, scene, camera, viewport ) {\\n\\n\\t\\t\\tif ( flares.length === 0 ) return;\\n\\n\\t\\t\\tvar tempPosition = new Vector3();\\n\\n\\t\\t\\tvar invAspect = viewport.w / viewport.z,\\n\\t\\t\\t\\thalfViewportWidth = viewport.z * 0.5,\\n\\t\\t\\t\\thalfViewportHeight = viewport.w * 0.5;\\n\\n\\t\\t\\tvar size = 16 / viewport.w,\\n\\t\\t\\t\\tscale = new Vector2( size * invAspect, size );\\n\\n\\t\\t\\tvar screenPosition = new Vector3( 1, 1, 0 ),\\n\\t\\t\\t\\tscreenPositionPixels = new Vector2( 1, 1 );\\n\\n\\t\\t\\tvar validArea = new Box2();\\n\\n\\t\\t\\tvalidArea.min.set( viewport.x, viewport.y );\\n\\t\\t\\tvalidArea.max.set( viewport.x + ( viewport.z - 16 ), viewport.y + ( viewport.w - 16 ) );\\n\\n\\t\\t\\tif ( program === undefined ) {\\n\\n\\t\\t\\t\\tinit();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tstate.useProgram( program );\\n\\n\\t\\t\\tstate.initAttributes();\\n\\t\\t\\tstate.enableAttribute( attributes.vertex );\\n\\t\\t\\tstate.enableAttribute( attributes.uv );\\n\\t\\t\\tstate.disableUnusedAttributes();\\n\\n\\t\\t\\t// loop through all lens flares to update their occlusion and positions\\n\\t\\t\\t// setup gl and common used attribs/uniforms\\n\\n\\t\\t\\tgl.uniform1i( uniforms.occlusionMap, 0 );\\n\\t\\t\\tgl.uniform1i( uniforms.map, 1 );\\n\\n\\t\\t\\tgl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer );\\n\\t\\t\\tgl.vertexAttribPointer( attributes.vertex, 2, gl.FLOAT, false, 2 * 8, 0 );\\n\\t\\t\\tgl.vertexAttribPointer( attributes.uv, 2, gl.FLOAT, false, 2 * 8, 8 );\\n\\n\\t\\t\\tgl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer );\\n\\n\\t\\t\\tstate.disable( gl.CULL_FACE );\\n\\t\\t\\tstate.buffers.depth.setMask( false );\\n\\n\\t\\t\\tfor ( var i = 0, l = flares.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tsize = 16 / viewport.w;\\n\\t\\t\\t\\tscale.set( size * invAspect, size );\\n\\n\\t\\t\\t\\t// calc object screen position\\n\\n\\t\\t\\t\\tvar flare = flares[ i ];\\n\\n\\t\\t\\t\\ttempPosition.set( flare.matrixWorld.elements[ 12 ], flare.matrixWorld.elements[ 13 ], flare.matrixWorld.elements[ 14 ] );\\n\\n\\t\\t\\t\\ttempPosition.applyMatrix4( camera.matrixWorldInverse );\\n\\t\\t\\t\\ttempPosition.applyMatrix4( camera.projectionMatrix );\\n\\n\\t\\t\\t\\t// setup arrays for gl programs\\n\\n\\t\\t\\t\\tscreenPosition.copy( tempPosition );\\n\\n\\t\\t\\t\\t// horizontal and vertical coordinate of the lower left corner of the pixels to copy\\n\\n\\t\\t\\t\\tscreenPositionPixels.x = viewport.x + ( screenPosition.x * halfViewportWidth ) + halfViewportWidth - 8;\\n\\t\\t\\t\\tscreenPositionPixels.y = viewport.y + ( screenPosition.y * halfViewportHeight ) + halfViewportHeight - 8;\\n\\n\\t\\t\\t\\t// screen cull\\n\\n\\t\\t\\t\\tif ( validArea.containsPoint( screenPositionPixels ) === true ) {\\n\\n\\t\\t\\t\\t\\t// save current RGB to temp texture\\n\\n\\t\\t\\t\\t\\tstate.activeTexture( gl.TEXTURE0 );\\n\\t\\t\\t\\t\\tstate.bindTexture( gl.TEXTURE_2D, null );\\n\\t\\t\\t\\t\\tstate.activeTexture( gl.TEXTURE1 );\\n\\t\\t\\t\\t\\tstate.bindTexture( gl.TEXTURE_2D, tempTexture );\\n\\t\\t\\t\\t\\tgl.copyTexImage2D( gl.TEXTURE_2D, 0, gl.RGB, screenPositionPixels.x, screenPositionPixels.y, 16, 16, 0 );\\n\\n\\n\\t\\t\\t\\t\\t// render pink quad\\n\\n\\t\\t\\t\\t\\tgl.uniform1i( uniforms.renderType, 0 );\\n\\t\\t\\t\\t\\tgl.uniform2f( uniforms.scale, scale.x, scale.y );\\n\\t\\t\\t\\t\\tgl.uniform3f( uniforms.screenPosition, screenPosition.x, screenPosition.y, screenPosition.z );\\n\\n\\t\\t\\t\\t\\tstate.disable( gl.BLEND );\\n\\t\\t\\t\\t\\tstate.enable( gl.DEPTH_TEST );\\n\\n\\t\\t\\t\\t\\tgl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );\\n\\n\\n\\t\\t\\t\\t\\t// copy result to occlusionMap\\n\\n\\t\\t\\t\\t\\tstate.activeTexture( gl.TEXTURE0 );\\n\\t\\t\\t\\t\\tstate.bindTexture( gl.TEXTURE_2D, occlusionTexture );\\n\\t\\t\\t\\t\\tgl.copyTexImage2D( gl.TEXTURE_2D, 0, gl.RGBA, screenPositionPixels.x, screenPositionPixels.y, 16, 16, 0 );\\n\\n\\n\\t\\t\\t\\t\\t// restore graphics\\n\\n\\t\\t\\t\\t\\tgl.uniform1i( uniforms.renderType, 1 );\\n\\t\\t\\t\\t\\tstate.disable( gl.DEPTH_TEST );\\n\\n\\t\\t\\t\\t\\tstate.activeTexture( gl.TEXTURE1 );\\n\\t\\t\\t\\t\\tstate.bindTexture( gl.TEXTURE_2D, tempTexture );\\n\\t\\t\\t\\t\\tgl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );\\n\\n\\n\\t\\t\\t\\t\\t// update object positions\\n\\n\\t\\t\\t\\t\\tflare.positionScreen.copy( screenPosition );\\n\\n\\t\\t\\t\\t\\tif ( flare.customUpdateCallback ) {\\n\\n\\t\\t\\t\\t\\t\\tflare.customUpdateCallback( flare );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tflare.updateLensFlares();\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t// render flares\\n\\n\\t\\t\\t\\t\\tgl.uniform1i( uniforms.renderType, 2 );\\n\\t\\t\\t\\t\\tstate.enable( gl.BLEND );\\n\\n\\t\\t\\t\\t\\tfor ( var j = 0, jl = flare.lensFlares.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar sprite = flare.lensFlares[ j ];\\n\\n\\t\\t\\t\\t\\t\\tif ( sprite.opacity > 0.001 && sprite.scale > 0.001 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tscreenPosition.x = sprite.x;\\n\\t\\t\\t\\t\\t\\t\\tscreenPosition.y = sprite.y;\\n\\t\\t\\t\\t\\t\\t\\tscreenPosition.z = sprite.z;\\n\\n\\t\\t\\t\\t\\t\\t\\tsize = sprite.size * sprite.scale / viewport.w;\\n\\n\\t\\t\\t\\t\\t\\t\\tscale.x = size * invAspect;\\n\\t\\t\\t\\t\\t\\t\\tscale.y = size;\\n\\n\\t\\t\\t\\t\\t\\t\\tgl.uniform3f( uniforms.screenPosition, screenPosition.x, screenPosition.y, screenPosition.z );\\n\\t\\t\\t\\t\\t\\t\\tgl.uniform2f( uniforms.scale, scale.x, scale.y );\\n\\t\\t\\t\\t\\t\\t\\tgl.uniform1f( uniforms.rotation, sprite.rotation );\\n\\n\\t\\t\\t\\t\\t\\t\\tgl.uniform1f( uniforms.opacity, sprite.opacity );\\n\\t\\t\\t\\t\\t\\t\\tgl.uniform3f( uniforms.color, sprite.color.r, sprite.color.g, sprite.color.b );\\n\\n\\t\\t\\t\\t\\t\\t\\tstate.setBlending( sprite.blending, sprite.blendEquation, sprite.blendSrc, sprite.blendDst );\\n\\n\\t\\t\\t\\t\\t\\t\\ttextures.setTexture2D( sprite.texture, 1 );\\n\\n\\t\\t\\t\\t\\t\\t\\tgl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// restore gl\\n\\n\\t\\t\\tstate.enable( gl.CULL_FACE );\\n\\t\\t\\tstate.enable( gl.DEPTH_TEST );\\n\\t\\t\\tstate.buffers.depth.setMask( true );\\n\\n\\t\\t\\tstate.reset();\\n\\n\\t\\t};\\n\\n\\t\\tfunction createProgram( shader ) {\\n\\n\\t\\t\\tvar program = gl.createProgram();\\n\\n\\t\\t\\tvar fragmentShader = gl.createShader( gl.FRAGMENT_SHADER );\\n\\t\\t\\tvar vertexShader = gl.createShader( gl.VERTEX_SHADER );\\n\\n\\t\\t\\tvar prefix = 'precision ' + capabilities.precision + ' float;\\\\n';\\n\\n\\t\\t\\tgl.shaderSource( fragmentShader, prefix + shader.fragmentShader );\\n\\t\\t\\tgl.shaderSource( vertexShader, prefix + shader.vertexShader );\\n\\n\\t\\t\\tgl.compileShader( fragmentShader );\\n\\t\\t\\tgl.compileShader( vertexShader );\\n\\n\\t\\t\\tgl.attachShader( program, fragmentShader );\\n\\t\\t\\tgl.attachShader( program, vertexShader );\\n\\n\\t\\t\\tgl.linkProgram( program );\\n\\n\\t\\t\\treturn program;\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction CanvasTexture( canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) {\\n\\n\\t\\tTexture.call( this, canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );\\n\\n\\t\\tthis.needsUpdate = true;\\n\\n\\t}\\n\\n\\tCanvasTexture.prototype = Object.create( Texture.prototype );\\n\\tCanvasTexture.prototype.constructor = CanvasTexture;\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction WebGLSpriteRenderer( renderer, gl, state, textures, capabilities ) {\\n\\n\\t\\tvar vertexBuffer, elementBuffer;\\n\\t\\tvar program, attributes, uniforms;\\n\\n\\t\\tvar texture;\\n\\n\\t\\t// decompose matrixWorld\\n\\n\\t\\tvar spritePosition = new Vector3();\\n\\t\\tvar spriteRotation = new Quaternion();\\n\\t\\tvar spriteScale = new Vector3();\\n\\n\\t\\tfunction init() {\\n\\n\\t\\t\\tvar vertices = new Float32Array( [\\n\\t\\t\\t\\t- 0.5, - 0.5, 0, 0,\\n\\t\\t\\t\\t  0.5, - 0.5, 1, 0,\\n\\t\\t\\t\\t  0.5, 0.5, 1, 1,\\n\\t\\t\\t\\t- 0.5, 0.5, 0, 1\\n\\t\\t\\t] );\\n\\n\\t\\t\\tvar faces = new Uint16Array( [\\n\\t\\t\\t\\t0, 1, 2,\\n\\t\\t\\t\\t0, 2, 3\\n\\t\\t\\t] );\\n\\n\\t\\t\\tvertexBuffer = gl.createBuffer();\\n\\t\\t\\telementBuffer = gl.createBuffer();\\n\\n\\t\\t\\tgl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer );\\n\\t\\t\\tgl.bufferData( gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW );\\n\\n\\t\\t\\tgl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer );\\n\\t\\t\\tgl.bufferData( gl.ELEMENT_ARRAY_BUFFER, faces, gl.STATIC_DRAW );\\n\\n\\t\\t\\tprogram = createProgram();\\n\\n\\t\\t\\tattributes = {\\n\\t\\t\\t\\tposition: gl.getAttribLocation( program, 'position' ),\\n\\t\\t\\t\\tuv: gl.getAttribLocation( program, 'uv' )\\n\\t\\t\\t};\\n\\n\\t\\t\\tuniforms = {\\n\\t\\t\\t\\tuvOffset: gl.getUniformLocation( program, 'uvOffset' ),\\n\\t\\t\\t\\tuvScale: gl.getUniformLocation( program, 'uvScale' ),\\n\\n\\t\\t\\t\\trotation: gl.getUniformLocation( program, 'rotation' ),\\n\\t\\t\\t\\tscale: gl.getUniformLocation( program, 'scale' ),\\n\\n\\t\\t\\t\\tcolor: gl.getUniformLocation( program, 'color' ),\\n\\t\\t\\t\\tmap: gl.getUniformLocation( program, 'map' ),\\n\\t\\t\\t\\topacity: gl.getUniformLocation( program, 'opacity' ),\\n\\n\\t\\t\\t\\tmodelViewMatrix: gl.getUniformLocation( program, 'modelViewMatrix' ),\\n\\t\\t\\t\\tprojectionMatrix: gl.getUniformLocation( program, 'projectionMatrix' ),\\n\\n\\t\\t\\t\\tfogType: gl.getUniformLocation( program, 'fogType' ),\\n\\t\\t\\t\\tfogDensity: gl.getUniformLocation( program, 'fogDensity' ),\\n\\t\\t\\t\\tfogNear: gl.getUniformLocation( program, 'fogNear' ),\\n\\t\\t\\t\\tfogFar: gl.getUniformLocation( program, 'fogFar' ),\\n\\t\\t\\t\\tfogColor: gl.getUniformLocation( program, 'fogColor' ),\\n\\t\\t\\t\\tfogDepth: gl.getUniformLocation( program, 'fogDepth' ),\\n\\n\\t\\t\\t\\talphaTest: gl.getUniformLocation( program, 'alphaTest' )\\n\\t\\t\\t};\\n\\n\\t\\t\\tvar canvas = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' );\\n\\t\\t\\tcanvas.width = 8;\\n\\t\\t\\tcanvas.height = 8;\\n\\n\\t\\t\\tvar context = canvas.getContext( '2d' );\\n\\t\\t\\tcontext.fillStyle = 'white';\\n\\t\\t\\tcontext.fillRect( 0, 0, 8, 8 );\\n\\n\\t\\t\\ttexture = new CanvasTexture( canvas );\\n\\n\\t\\t}\\n\\n\\t\\tthis.render = function ( sprites, scene, camera ) {\\n\\n\\t\\t\\tif ( sprites.length === 0 ) return;\\n\\n\\t\\t\\t// setup gl\\n\\n\\t\\t\\tif ( program === undefined ) {\\n\\n\\t\\t\\t\\tinit();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tstate.useProgram( program );\\n\\n\\t\\t\\tstate.initAttributes();\\n\\t\\t\\tstate.enableAttribute( attributes.position );\\n\\t\\t\\tstate.enableAttribute( attributes.uv );\\n\\t\\t\\tstate.disableUnusedAttributes();\\n\\n\\t\\t\\tstate.disable( gl.CULL_FACE );\\n\\t\\t\\tstate.enable( gl.BLEND );\\n\\n\\t\\t\\tgl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer );\\n\\t\\t\\tgl.vertexAttribPointer( attributes.position, 2, gl.FLOAT, false, 2 * 8, 0 );\\n\\t\\t\\tgl.vertexAttribPointer( attributes.uv, 2, gl.FLOAT, false, 2 * 8, 8 );\\n\\n\\t\\t\\tgl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer );\\n\\n\\t\\t\\tgl.uniformMatrix4fv( uniforms.projectionMatrix, false, camera.projectionMatrix.elements );\\n\\n\\t\\t\\tstate.activeTexture( gl.TEXTURE0 );\\n\\t\\t\\tgl.uniform1i( uniforms.map, 0 );\\n\\n\\t\\t\\tvar oldFogType = 0;\\n\\t\\t\\tvar sceneFogType = 0;\\n\\t\\t\\tvar fog = scene.fog;\\n\\n\\t\\t\\tif ( fog ) {\\n\\n\\t\\t\\t\\tgl.uniform3f( uniforms.fogColor, fog.color.r, fog.color.g, fog.color.b );\\n\\n\\t\\t\\t\\tif ( fog.isFog ) {\\n\\n\\t\\t\\t\\t\\tgl.uniform1f( uniforms.fogNear, fog.near );\\n\\t\\t\\t\\t\\tgl.uniform1f( uniforms.fogFar, fog.far );\\n\\n\\t\\t\\t\\t\\tgl.uniform1i( uniforms.fogType, 1 );\\n\\t\\t\\t\\t\\toldFogType = 1;\\n\\t\\t\\t\\t\\tsceneFogType = 1;\\n\\n\\t\\t\\t\\t} else if ( fog.isFogExp2 ) {\\n\\n\\t\\t\\t\\t\\tgl.uniform1f( uniforms.fogDensity, fog.density );\\n\\n\\t\\t\\t\\t\\tgl.uniform1i( uniforms.fogType, 2 );\\n\\t\\t\\t\\t\\toldFogType = 2;\\n\\t\\t\\t\\t\\tsceneFogType = 2;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tgl.uniform1i( uniforms.fogType, 0 );\\n\\t\\t\\t\\toldFogType = 0;\\n\\t\\t\\t\\tsceneFogType = 0;\\n\\n\\t\\t\\t}\\n\\n\\n\\t\\t\\t// update positions and sort\\n\\n\\t\\t\\tfor ( var i = 0, l = sprites.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar sprite = sprites[ i ];\\n\\n\\t\\t\\t\\tsprite.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, sprite.matrixWorld );\\n\\t\\t\\t\\tsprite.z = - sprite.modelViewMatrix.elements[ 14 ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tsprites.sort( painterSortStable );\\n\\n\\t\\t\\t// render all sprites\\n\\n\\t\\t\\tvar scale = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = sprites.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar sprite = sprites[ i ];\\n\\t\\t\\t\\tvar material = sprite.material;\\n\\n\\t\\t\\t\\tif ( material.visible === false ) continue;\\n\\n\\t\\t\\t\\tsprite.onBeforeRender( renderer, scene, camera, undefined, material, undefined );\\n\\n\\t\\t\\t\\tgl.uniform1f( uniforms.alphaTest, material.alphaTest );\\n\\t\\t\\t\\tgl.uniformMatrix4fv( uniforms.modelViewMatrix, false, sprite.modelViewMatrix.elements );\\n\\n\\t\\t\\t\\tsprite.matrixWorld.decompose( spritePosition, spriteRotation, spriteScale );\\n\\n\\t\\t\\t\\tscale[ 0 ] = spriteScale.x;\\n\\t\\t\\t\\tscale[ 1 ] = spriteScale.y;\\n\\n\\t\\t\\t\\tvar fogType = 0;\\n\\n\\t\\t\\t\\tif ( scene.fog && material.fog ) {\\n\\n\\t\\t\\t\\t\\tfogType = sceneFogType;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( oldFogType !== fogType ) {\\n\\n\\t\\t\\t\\t\\tgl.uniform1i( uniforms.fogType, fogType );\\n\\t\\t\\t\\t\\toldFogType = fogType;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( material.map !== null ) {\\n\\n\\t\\t\\t\\t\\tgl.uniform2f( uniforms.uvOffset, material.map.offset.x, material.map.offset.y );\\n\\t\\t\\t\\t\\tgl.uniform2f( uniforms.uvScale, material.map.repeat.x, material.map.repeat.y );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tgl.uniform2f( uniforms.uvOffset, 0, 0 );\\n\\t\\t\\t\\t\\tgl.uniform2f( uniforms.uvScale, 1, 1 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgl.uniform1f( uniforms.opacity, material.opacity );\\n\\t\\t\\t\\tgl.uniform3f( uniforms.color, material.color.r, material.color.g, material.color.b );\\n\\n\\t\\t\\t\\tgl.uniform1f( uniforms.rotation, material.rotation );\\n\\t\\t\\t\\tgl.uniform2fv( uniforms.scale, scale );\\n\\n\\t\\t\\t\\tstate.setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha, material.premultipliedAlpha );\\n\\t\\t\\t\\tstate.buffers.depth.setTest( material.depthTest );\\n\\t\\t\\t\\tstate.buffers.depth.setMask( material.depthWrite );\\n\\t\\t\\t\\tstate.buffers.color.setMask( material.colorWrite );\\n\\n\\t\\t\\t\\ttextures.setTexture2D( material.map || texture, 0 );\\n\\n\\t\\t\\t\\tgl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );\\n\\n\\t\\t\\t\\tsprite.onAfterRender( renderer, scene, camera, undefined, material, undefined );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// restore gl\\n\\n\\t\\t\\tstate.enable( gl.CULL_FACE );\\n\\n\\t\\t\\tstate.reset();\\n\\n\\t\\t};\\n\\n\\t\\tfunction createProgram() {\\n\\n\\t\\t\\tvar program = gl.createProgram();\\n\\n\\t\\t\\tvar vertexShader = gl.createShader( gl.VERTEX_SHADER );\\n\\t\\t\\tvar fragmentShader = gl.createShader( gl.FRAGMENT_SHADER );\\n\\n\\t\\t\\tgl.shaderSource( vertexShader, [\\n\\n\\t\\t\\t\\t'precision ' + capabilities.precision + ' float;',\\n\\n\\t\\t\\t\\t'#define SHADER_NAME ' + 'SpriteMaterial',\\n\\n\\t\\t\\t\\t'uniform mat4 modelViewMatrix;',\\n\\t\\t\\t\\t'uniform mat4 projectionMatrix;',\\n\\t\\t\\t\\t'uniform float rotation;',\\n\\t\\t\\t\\t'uniform vec2 scale;',\\n\\t\\t\\t\\t'uniform vec2 uvOffset;',\\n\\t\\t\\t\\t'uniform vec2 uvScale;',\\n\\n\\t\\t\\t\\t'attribute vec2 position;',\\n\\t\\t\\t\\t'attribute vec2 uv;',\\n\\n\\t\\t\\t\\t'varying vec2 vUV;',\\n\\t\\t\\t\\t'varying float fogDepth;',\\n\\n\\t\\t\\t\\t'void main() {',\\n\\n\\t\\t\\t\\t'\\tvUV = uvOffset + uv * uvScale;',\\n\\n\\t\\t\\t\\t'\\tvec2 alignedPosition = position * scale;',\\n\\n\\t\\t\\t\\t'\\tvec2 rotatedPosition;',\\n\\t\\t\\t\\t'\\trotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;',\\n\\t\\t\\t\\t'\\trotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;',\\n\\n\\t\\t\\t\\t'\\tvec4 mvPosition;',\\n\\n\\t\\t\\t\\t'\\tmvPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );',\\n\\t\\t\\t\\t'\\tmvPosition.xy += rotatedPosition;',\\n\\n\\t\\t\\t\\t'\\tgl_Position = projectionMatrix * mvPosition;',\\n\\n\\t\\t\\t\\t'\\tfogDepth = - mvPosition.z;',\\n\\n\\t\\t\\t\\t'}'\\n\\n\\t\\t\\t].join( '\\\\n' ) );\\n\\n\\t\\t\\tgl.shaderSource( fragmentShader, [\\n\\n\\t\\t\\t\\t'precision ' + capabilities.precision + ' float;',\\n\\n\\t\\t\\t\\t'#define SHADER_NAME ' + 'SpriteMaterial',\\n\\n\\t\\t\\t\\t'uniform vec3 color;',\\n\\t\\t\\t\\t'uniform sampler2D map;',\\n\\t\\t\\t\\t'uniform float opacity;',\\n\\n\\t\\t\\t\\t'uniform int fogType;',\\n\\t\\t\\t\\t'uniform vec3 fogColor;',\\n\\t\\t\\t\\t'uniform float fogDensity;',\\n\\t\\t\\t\\t'uniform float fogNear;',\\n\\t\\t\\t\\t'uniform float fogFar;',\\n\\t\\t\\t\\t'uniform float alphaTest;',\\n\\n\\t\\t\\t\\t'varying vec2 vUV;',\\n\\t\\t\\t\\t'varying float fogDepth;',\\n\\n\\t\\t\\t\\t'void main() {',\\n\\n\\t\\t\\t\\t'\\tvec4 texture = texture2D( map, vUV );',\\n\\n\\t\\t\\t\\t'\\tgl_FragColor = vec4( color * texture.xyz, texture.a * opacity );',\\n\\n\\t\\t\\t\\t'\\tif ( gl_FragColor.a < alphaTest ) discard;',\\n\\n\\t\\t\\t\\t'\\tif ( fogType > 0 ) {',\\n\\n\\t\\t\\t\\t'\\t\\tfloat fogFactor = 0.0;',\\n\\n\\t\\t\\t\\t'\\t\\tif ( fogType == 1 ) {',\\n\\n\\t\\t\\t\\t'\\t\\t\\tfogFactor = smoothstep( fogNear, fogFar, fogDepth );',\\n\\n\\t\\t\\t\\t'\\t\\t} else {',\\n\\n\\t\\t\\t\\t'\\t\\t\\tconst float LOG2 = 1.442695;',\\n\\t\\t\\t\\t'\\t\\t\\tfogFactor = exp2( - fogDensity * fogDensity * fogDepth * fogDepth * LOG2 );',\\n\\t\\t\\t\\t'\\t\\t\\tfogFactor = 1.0 - clamp( fogFactor, 0.0, 1.0 );',\\n\\n\\t\\t\\t\\t'\\t\\t}',\\n\\n\\t\\t\\t\\t'\\t\\tgl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );',\\n\\n\\t\\t\\t\\t'\\t}',\\n\\n\\t\\t\\t\\t'}'\\n\\n\\t\\t\\t].join( '\\\\n' ) );\\n\\n\\t\\t\\tgl.compileShader( vertexShader );\\n\\t\\t\\tgl.compileShader( fragmentShader );\\n\\n\\t\\t\\tgl.attachShader( program, vertexShader );\\n\\t\\t\\tgl.attachShader( program, fragmentShader );\\n\\n\\t\\t\\tgl.linkProgram( program );\\n\\n\\t\\t\\treturn program;\\n\\n\\t\\t}\\n\\n\\t\\tfunction painterSortStable( a, b ) {\\n\\n\\t\\t\\tif ( a.renderOrder !== b.renderOrder ) {\\n\\n\\t\\t\\t\\treturn a.renderOrder - b.renderOrder;\\n\\n\\t\\t\\t} else if ( a.z !== b.z ) {\\n\\n\\t\\t\\t\\treturn b.z - a.z;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\treturn b.id - a.id;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tvar materialId = 0;\\n\\n\\tfunction Material() {\\n\\n\\t\\tObject.defineProperty( this, 'id', { value: materialId ++ } );\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.name = '';\\n\\t\\tthis.type = 'Material';\\n\\n\\t\\tthis.fog = true;\\n\\t\\tthis.lights = true;\\n\\n\\t\\tthis.blending = NormalBlending;\\n\\t\\tthis.side = FrontSide;\\n\\t\\tthis.flatShading = false;\\n\\t\\tthis.vertexColors = NoColors; // THREE.NoColors, THREE.VertexColors, THREE.FaceColors\\n\\n\\t\\tthis.opacity = 1;\\n\\t\\tthis.transparent = false;\\n\\n\\t\\tthis.blendSrc = SrcAlphaFactor;\\n\\t\\tthis.blendDst = OneMinusSrcAlphaFactor;\\n\\t\\tthis.blendEquation = AddEquation;\\n\\t\\tthis.blendSrcAlpha = null;\\n\\t\\tthis.blendDstAlpha = null;\\n\\t\\tthis.blendEquationAlpha = null;\\n\\n\\t\\tthis.depthFunc = LessEqualDepth;\\n\\t\\tthis.depthTest = true;\\n\\t\\tthis.depthWrite = true;\\n\\n\\t\\tthis.clippingPlanes = null;\\n\\t\\tthis.clipIntersection = false;\\n\\t\\tthis.clipShadows = false;\\n\\n\\t\\tthis.colorWrite = true;\\n\\n\\t\\tthis.precision = null; // override the renderer's default precision for this material\\n\\n\\t\\tthis.polygonOffset = false;\\n\\t\\tthis.polygonOffsetFactor = 0;\\n\\t\\tthis.polygonOffsetUnits = 0;\\n\\n\\t\\tthis.dithering = false;\\n\\n\\t\\tthis.alphaTest = 0;\\n\\t\\tthis.premultipliedAlpha = false;\\n\\n\\t\\tthis.overdraw = 0; // Overdrawn pixels (typically between 0 and 1) for fixing antialiasing gaps in CanvasRenderer\\n\\n\\t\\tthis.visible = true;\\n\\n\\t\\tthis.userData = {};\\n\\n\\t\\tthis.needsUpdate = true;\\n\\n\\t}\\n\\n\\tMaterial.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {\\n\\n\\t\\tconstructor: Material,\\n\\n\\t\\tisMaterial: true,\\n\\n\\t\\tonBeforeCompile: function () {},\\n\\n\\t\\tsetValues: function ( values ) {\\n\\n\\t\\t\\tif ( values === undefined ) return;\\n\\n\\t\\t\\tfor ( var key in values ) {\\n\\n\\t\\t\\t\\tvar newValue = values[ key ];\\n\\n\\t\\t\\t\\tif ( newValue === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( \\\"THREE.Material: '\\\" + key + \\\"' parameter is undefined.\\\" );\\n\\t\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// for backward compatability if shading is set in the constructor\\n\\t\\t\\t\\tif ( key === 'shading' ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.' + this.type + ': .shading has been removed. Use the boolean .flatShading instead.' );\\n\\t\\t\\t\\t\\tthis.flatShading = ( newValue === FlatShading ) ? true : false;\\n\\t\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar currentValue = this[ key ];\\n\\n\\t\\t\\t\\tif ( currentValue === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( \\\"THREE.\\\" + this.type + \\\": '\\\" + key + \\\"' is not a property of this material.\\\" );\\n\\t\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( currentValue && currentValue.isColor ) {\\n\\n\\t\\t\\t\\t\\tcurrentValue.set( newValue );\\n\\n\\t\\t\\t\\t} else if ( ( currentValue && currentValue.isVector3 ) && ( newValue && newValue.isVector3 ) ) {\\n\\n\\t\\t\\t\\t\\tcurrentValue.copy( newValue );\\n\\n\\t\\t\\t\\t} else if ( key === 'overdraw' ) {\\n\\n\\t\\t\\t\\t\\t// ensure overdraw is backwards-compatible with legacy boolean type\\n\\t\\t\\t\\t\\tthis[ key ] = Number( newValue );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthis[ key ] = newValue;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\tvar isRoot = ( meta === undefined || typeof meta === 'string' );\\n\\n\\t\\t\\tif ( isRoot ) {\\n\\n\\t\\t\\t\\tmeta = {\\n\\t\\t\\t\\t\\ttextures: {},\\n\\t\\t\\t\\t\\timages: {}\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar data = {\\n\\t\\t\\t\\tmetadata: {\\n\\t\\t\\t\\t\\tversion: 4.5,\\n\\t\\t\\t\\t\\ttype: 'Material',\\n\\t\\t\\t\\t\\tgenerator: 'Material.toJSON'\\n\\t\\t\\t\\t}\\n\\t\\t\\t};\\n\\n\\t\\t\\t// standard Material serialization\\n\\t\\t\\tdata.uuid = this.uuid;\\n\\t\\t\\tdata.type = this.type;\\n\\n\\t\\t\\tif ( this.name !== '' ) data.name = this.name;\\n\\n\\t\\t\\tif ( this.color && this.color.isColor ) data.color = this.color.getHex();\\n\\n\\t\\t\\tif ( this.roughness !== undefined ) data.roughness = this.roughness;\\n\\t\\t\\tif ( this.metalness !== undefined ) data.metalness = this.metalness;\\n\\n\\t\\t\\tif ( this.emissive && this.emissive.isColor ) data.emissive = this.emissive.getHex();\\n\\t\\t\\tif ( this.emissiveIntensity !== 1 ) data.emissiveIntensity = this.emissiveIntensity;\\n\\n\\t\\t\\tif ( this.specular && this.specular.isColor ) data.specular = this.specular.getHex();\\n\\t\\t\\tif ( this.shininess !== undefined ) data.shininess = this.shininess;\\n\\t\\t\\tif ( this.clearCoat !== undefined ) data.clearCoat = this.clearCoat;\\n\\t\\t\\tif ( this.clearCoatRoughness !== undefined ) data.clearCoatRoughness = this.clearCoatRoughness;\\n\\n\\t\\t\\tif ( this.map && this.map.isTexture ) data.map = this.map.toJSON( meta ).uuid;\\n\\t\\t\\tif ( this.alphaMap && this.alphaMap.isTexture ) data.alphaMap = this.alphaMap.toJSON( meta ).uuid;\\n\\t\\t\\tif ( this.lightMap && this.lightMap.isTexture ) data.lightMap = this.lightMap.toJSON( meta ).uuid;\\n\\t\\t\\tif ( this.bumpMap && this.bumpMap.isTexture ) {\\n\\n\\t\\t\\t\\tdata.bumpMap = this.bumpMap.toJSON( meta ).uuid;\\n\\t\\t\\t\\tdata.bumpScale = this.bumpScale;\\n\\n\\t\\t\\t}\\n\\t\\t\\tif ( this.normalMap && this.normalMap.isTexture ) {\\n\\n\\t\\t\\t\\tdata.normalMap = this.normalMap.toJSON( meta ).uuid;\\n\\t\\t\\t\\tdata.normalScale = this.normalScale.toArray();\\n\\n\\t\\t\\t}\\n\\t\\t\\tif ( this.displacementMap && this.displacementMap.isTexture ) {\\n\\n\\t\\t\\t\\tdata.displacementMap = this.displacementMap.toJSON( meta ).uuid;\\n\\t\\t\\t\\tdata.displacementScale = this.displacementScale;\\n\\t\\t\\t\\tdata.displacementBias = this.displacementBias;\\n\\n\\t\\t\\t}\\n\\t\\t\\tif ( this.roughnessMap && this.roughnessMap.isTexture ) data.roughnessMap = this.roughnessMap.toJSON( meta ).uuid;\\n\\t\\t\\tif ( this.metalnessMap && this.metalnessMap.isTexture ) data.metalnessMap = this.metalnessMap.toJSON( meta ).uuid;\\n\\n\\t\\t\\tif ( this.emissiveMap && this.emissiveMap.isTexture ) data.emissiveMap = this.emissiveMap.toJSON( meta ).uuid;\\n\\t\\t\\tif ( this.specularMap && this.specularMap.isTexture ) data.specularMap = this.specularMap.toJSON( meta ).uuid;\\n\\n\\t\\t\\tif ( this.envMap && this.envMap.isTexture ) {\\n\\n\\t\\t\\t\\tdata.envMap = this.envMap.toJSON( meta ).uuid;\\n\\t\\t\\t\\tdata.reflectivity = this.reflectivity; // Scale behind envMap\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.gradientMap && this.gradientMap.isTexture ) {\\n\\n\\t\\t\\t\\tdata.gradientMap = this.gradientMap.toJSON( meta ).uuid;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.size !== undefined ) data.size = this.size;\\n\\t\\t\\tif ( this.sizeAttenuation !== undefined ) data.sizeAttenuation = this.sizeAttenuation;\\n\\n\\t\\t\\tif ( this.blending !== NormalBlending ) data.blending = this.blending;\\n\\t\\t\\tif ( this.flatShading === true ) data.flatShading = this.flatShading;\\n\\t\\t\\tif ( this.side !== FrontSide ) data.side = this.side;\\n\\t\\t\\tif ( this.vertexColors !== NoColors ) data.vertexColors = this.vertexColors;\\n\\n\\t\\t\\tif ( this.opacity < 1 ) data.opacity = this.opacity;\\n\\t\\t\\tif ( this.transparent === true ) data.transparent = this.transparent;\\n\\n\\t\\t\\tdata.depthFunc = this.depthFunc;\\n\\t\\t\\tdata.depthTest = this.depthTest;\\n\\t\\t\\tdata.depthWrite = this.depthWrite;\\n\\n\\t\\t\\t// rotation (SpriteMaterial)\\n\\t\\t\\tif ( this.rotation !== 0 ) data.rotation = this.rotation;\\n\\n\\t\\t\\tif ( this.linewidth !== 1 ) data.linewidth = this.linewidth;\\n\\t\\t\\tif ( this.dashSize !== undefined ) data.dashSize = this.dashSize;\\n\\t\\t\\tif ( this.gapSize !== undefined ) data.gapSize = this.gapSize;\\n\\t\\t\\tif ( this.scale !== undefined ) data.scale = this.scale;\\n\\n\\t\\t\\tif ( this.dithering === true ) data.dithering = true;\\n\\n\\t\\t\\tif ( this.alphaTest > 0 ) data.alphaTest = this.alphaTest;\\n\\t\\t\\tif ( this.premultipliedAlpha === true ) data.premultipliedAlpha = this.premultipliedAlpha;\\n\\n\\t\\t\\tif ( this.wireframe === true ) data.wireframe = this.wireframe;\\n\\t\\t\\tif ( this.wireframeLinewidth > 1 ) data.wireframeLinewidth = this.wireframeLinewidth;\\n\\t\\t\\tif ( this.wireframeLinecap !== 'round' ) data.wireframeLinecap = this.wireframeLinecap;\\n\\t\\t\\tif ( this.wireframeLinejoin !== 'round' ) data.wireframeLinejoin = this.wireframeLinejoin;\\n\\n\\t\\t\\tif ( this.morphTargets === true ) data.morphTargets = true;\\n\\t\\t\\tif ( this.skinning === true ) data.skinning = true;\\n\\n\\t\\t\\tif ( this.visible === false ) data.visible = false;\\n\\t\\t\\tif ( JSON.stringify( this.userData ) !== '{}' ) data.userData = this.userData;\\n\\n\\t\\t\\t// TODO: Copied from Object3D.toJSON\\n\\n\\t\\t\\tfunction extractFromCache( cache ) {\\n\\n\\t\\t\\t\\tvar values = [];\\n\\n\\t\\t\\t\\tfor ( var key in cache ) {\\n\\n\\t\\t\\t\\t\\tvar data = cache[ key ];\\n\\t\\t\\t\\t\\tdelete data.metadata;\\n\\t\\t\\t\\t\\tvalues.push( data );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn values;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( isRoot ) {\\n\\n\\t\\t\\t\\tvar textures = extractFromCache( meta.textures );\\n\\t\\t\\t\\tvar images = extractFromCache( meta.images );\\n\\n\\t\\t\\t\\tif ( textures.length > 0 ) data.textures = textures;\\n\\t\\t\\t\\tif ( images.length > 0 ) data.images = images;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tthis.name = source.name;\\n\\n\\t\\t\\tthis.fog = source.fog;\\n\\t\\t\\tthis.lights = source.lights;\\n\\n\\t\\t\\tthis.blending = source.blending;\\n\\t\\t\\tthis.side = source.side;\\n\\t\\t\\tthis.flatShading = source.flatShading;\\n\\t\\t\\tthis.vertexColors = source.vertexColors;\\n\\n\\t\\t\\tthis.opacity = source.opacity;\\n\\t\\t\\tthis.transparent = source.transparent;\\n\\n\\t\\t\\tthis.blendSrc = source.blendSrc;\\n\\t\\t\\tthis.blendDst = source.blendDst;\\n\\t\\t\\tthis.blendEquation = source.blendEquation;\\n\\t\\t\\tthis.blendSrcAlpha = source.blendSrcAlpha;\\n\\t\\t\\tthis.blendDstAlpha = source.blendDstAlpha;\\n\\t\\t\\tthis.blendEquationAlpha = source.blendEquationAlpha;\\n\\n\\t\\t\\tthis.depthFunc = source.depthFunc;\\n\\t\\t\\tthis.depthTest = source.depthTest;\\n\\t\\t\\tthis.depthWrite = source.depthWrite;\\n\\n\\t\\t\\tthis.colorWrite = source.colorWrite;\\n\\n\\t\\t\\tthis.precision = source.precision;\\n\\n\\t\\t\\tthis.polygonOffset = source.polygonOffset;\\n\\t\\t\\tthis.polygonOffsetFactor = source.polygonOffsetFactor;\\n\\t\\t\\tthis.polygonOffsetUnits = source.polygonOffsetUnits;\\n\\n\\t\\t\\tthis.dithering = source.dithering;\\n\\n\\t\\t\\tthis.alphaTest = source.alphaTest;\\n\\t\\t\\tthis.premultipliedAlpha = source.premultipliedAlpha;\\n\\n\\t\\t\\tthis.overdraw = source.overdraw;\\n\\n\\t\\t\\tthis.visible = source.visible;\\n\\t\\t\\tthis.userData = JSON.parse( JSON.stringify( source.userData ) );\\n\\n\\t\\t\\tthis.clipShadows = source.clipShadows;\\n\\t\\t\\tthis.clipIntersection = source.clipIntersection;\\n\\n\\t\\t\\tvar srcPlanes = source.clippingPlanes,\\n\\t\\t\\t\\tdstPlanes = null;\\n\\n\\t\\t\\tif ( srcPlanes !== null ) {\\n\\n\\t\\t\\t\\tvar n = srcPlanes.length;\\n\\t\\t\\t\\tdstPlanes = new Array( n );\\n\\n\\t\\t\\t\\tfor ( var i = 0; i !== n; ++ i )\\n\\t\\t\\t\\t\\tdstPlanes[ i ] = srcPlanes[ i ].clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.clippingPlanes = dstPlanes;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdispose: function () {\\n\\n\\t\\t\\tthis.dispatchEvent( { type: 'dispose' } );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author bhouston / https://clara.io\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t *\\n\\t * parameters = {\\n\\t *\\n\\t *  opacity: <float>,\\n\\t *\\n\\t *  map: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  alphaMap: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  displacementMap: new THREE.Texture( <Image> ),\\n\\t *  displacementScale: <float>,\\n\\t *  displacementBias: <float>,\\n\\t *\\n\\t *  wireframe: <boolean>,\\n\\t *  wireframeLinewidth: <float>\\n\\t * }\\n\\t */\\n\\n\\tfunction MeshDepthMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'MeshDepthMaterial';\\n\\n\\t\\tthis.depthPacking = BasicDepthPacking;\\n\\n\\t\\tthis.skinning = false;\\n\\t\\tthis.morphTargets = false;\\n\\n\\t\\tthis.map = null;\\n\\n\\t\\tthis.alphaMap = null;\\n\\n\\t\\tthis.displacementMap = null;\\n\\t\\tthis.displacementScale = 1;\\n\\t\\tthis.displacementBias = 0;\\n\\n\\t\\tthis.wireframe = false;\\n\\t\\tthis.wireframeLinewidth = 1;\\n\\n\\t\\tthis.fog = false;\\n\\t\\tthis.lights = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshDepthMaterial.prototype = Object.create( Material.prototype );\\n\\tMeshDepthMaterial.prototype.constructor = MeshDepthMaterial;\\n\\n\\tMeshDepthMaterial.prototype.isMeshDepthMaterial = true;\\n\\n\\tMeshDepthMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.depthPacking = source.depthPacking;\\n\\n\\t\\tthis.skinning = source.skinning;\\n\\t\\tthis.morphTargets = source.morphTargets;\\n\\n\\t\\tthis.map = source.map;\\n\\n\\t\\tthis.alphaMap = source.alphaMap;\\n\\n\\t\\tthis.displacementMap = source.displacementMap;\\n\\t\\tthis.displacementScale = source.displacementScale;\\n\\t\\tthis.displacementBias = source.displacementBias;\\n\\n\\t\\tthis.wireframe = source.wireframe;\\n\\t\\tthis.wireframeLinewidth = source.wireframeLinewidth;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t *\\n\\t * parameters = {\\n\\t *\\n\\t *  referencePosition: <float>,\\n\\t *  nearDistance: <float>,\\n\\t *  farDistance: <float>,\\n\\t *\\n\\t *  skinning: <bool>,\\n\\t *  morphTargets: <bool>,\\n\\t *\\n\\t *  map: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  alphaMap: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  displacementMap: new THREE.Texture( <Image> ),\\n\\t *  displacementScale: <float>,\\n\\t *  displacementBias: <float>\\n\\t *\\n\\t * }\\n\\t */\\n\\n\\tfunction MeshDistanceMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'MeshDistanceMaterial';\\n\\n\\t\\tthis.referencePosition = new Vector3();\\n\\t\\tthis.nearDistance = 1;\\n\\t\\tthis.farDistance = 1000;\\n\\n\\t\\tthis.skinning = false;\\n\\t\\tthis.morphTargets = false;\\n\\n\\t\\tthis.map = null;\\n\\n\\t\\tthis.alphaMap = null;\\n\\n\\t\\tthis.displacementMap = null;\\n\\t\\tthis.displacementScale = 1;\\n\\t\\tthis.displacementBias = 0;\\n\\n\\t\\tthis.fog = false;\\n\\t\\tthis.lights = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshDistanceMaterial.prototype = Object.create( Material.prototype );\\n\\tMeshDistanceMaterial.prototype.constructor = MeshDistanceMaterial;\\n\\n\\tMeshDistanceMaterial.prototype.isMeshDistanceMaterial = true;\\n\\n\\tMeshDistanceMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.referencePosition.copy( source.referencePosition );\\n\\t\\tthis.nearDistance = source.nearDistance;\\n\\t\\tthis.farDistance = source.farDistance;\\n\\n\\t\\tthis.skinning = source.skinning;\\n\\t\\tthis.morphTargets = source.morphTargets;\\n\\n\\t\\tthis.map = source.map;\\n\\n\\t\\tthis.alphaMap = source.alphaMap;\\n\\n\\t\\tthis.displacementMap = source.displacementMap;\\n\\t\\tthis.displacementScale = source.displacementScale;\\n\\t\\tthis.displacementBias = source.displacementBias;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author bhouston / http://clara.io\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction Box3( min, max ) {\\n\\n\\t\\tthis.min = ( min !== undefined ) ? min : new Vector3( + Infinity, + Infinity, + Infinity );\\n\\t\\tthis.max = ( max !== undefined ) ? max : new Vector3( - Infinity, - Infinity, - Infinity );\\n\\n\\t}\\n\\n\\tObject.assign( Box3.prototype, {\\n\\n\\t\\tisBox3: true,\\n\\n\\t\\tset: function ( min, max ) {\\n\\n\\t\\t\\tthis.min.copy( min );\\n\\t\\t\\tthis.max.copy( max );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromArray: function ( array ) {\\n\\n\\t\\t\\tvar minX = + Infinity;\\n\\t\\t\\tvar minY = + Infinity;\\n\\t\\t\\tvar minZ = + Infinity;\\n\\n\\t\\t\\tvar maxX = - Infinity;\\n\\t\\t\\tvar maxY = - Infinity;\\n\\t\\t\\tvar maxZ = - Infinity;\\n\\n\\t\\t\\tfor ( var i = 0, l = array.length; i < l; i += 3 ) {\\n\\n\\t\\t\\t\\tvar x = array[ i ];\\n\\t\\t\\t\\tvar y = array[ i + 1 ];\\n\\t\\t\\t\\tvar z = array[ i + 2 ];\\n\\n\\t\\t\\t\\tif ( x < minX ) minX = x;\\n\\t\\t\\t\\tif ( y < minY ) minY = y;\\n\\t\\t\\t\\tif ( z < minZ ) minZ = z;\\n\\n\\t\\t\\t\\tif ( x > maxX ) maxX = x;\\n\\t\\t\\t\\tif ( y > maxY ) maxY = y;\\n\\t\\t\\t\\tif ( z > maxZ ) maxZ = z;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.min.set( minX, minY, minZ );\\n\\t\\t\\tthis.max.set( maxX, maxY, maxZ );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromBufferAttribute: function ( attribute ) {\\n\\n\\t\\t\\tvar minX = + Infinity;\\n\\t\\t\\tvar minY = + Infinity;\\n\\t\\t\\tvar minZ = + Infinity;\\n\\n\\t\\t\\tvar maxX = - Infinity;\\n\\t\\t\\tvar maxY = - Infinity;\\n\\t\\t\\tvar maxZ = - Infinity;\\n\\n\\t\\t\\tfor ( var i = 0, l = attribute.count; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar x = attribute.getX( i );\\n\\t\\t\\t\\tvar y = attribute.getY( i );\\n\\t\\t\\t\\tvar z = attribute.getZ( i );\\n\\n\\t\\t\\t\\tif ( x < minX ) minX = x;\\n\\t\\t\\t\\tif ( y < minY ) minY = y;\\n\\t\\t\\t\\tif ( z < minZ ) minZ = z;\\n\\n\\t\\t\\t\\tif ( x > maxX ) maxX = x;\\n\\t\\t\\t\\tif ( y > maxY ) maxY = y;\\n\\t\\t\\t\\tif ( z > maxZ ) maxZ = z;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.min.set( minX, minY, minZ );\\n\\t\\t\\tthis.max.set( maxX, maxY, maxZ );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromPoints: function ( points ) {\\n\\n\\t\\t\\tthis.makeEmpty();\\n\\n\\t\\t\\tfor ( var i = 0, il = points.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.expandByPoint( points[ i ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromCenterAndSize: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function setFromCenterAndSize( center, size ) {\\n\\n\\t\\t\\t\\tvar halfSize = v1.copy( size ).multiplyScalar( 0.5 );\\n\\n\\t\\t\\t\\tthis.min.copy( center ).sub( halfSize );\\n\\t\\t\\t\\tthis.max.copy( center ).add( halfSize );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tsetFromObject: function ( object ) {\\n\\n\\t\\t\\tthis.makeEmpty();\\n\\n\\t\\t\\treturn this.expandByObject( object );\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( box ) {\\n\\n\\t\\t\\tthis.min.copy( box.min );\\n\\t\\t\\tthis.max.copy( box.max );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tmakeEmpty: function () {\\n\\n\\t\\t\\tthis.min.x = this.min.y = this.min.z = + Infinity;\\n\\t\\t\\tthis.max.x = this.max.y = this.max.z = - Infinity;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tisEmpty: function () {\\n\\n\\t\\t\\t// this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes\\n\\n\\t\\t\\treturn ( this.max.x < this.min.x ) || ( this.max.y < this.min.y ) || ( this.max.z < this.min.z );\\n\\n\\t\\t},\\n\\n\\t\\tgetCenter: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\t\\t\\treturn this.isEmpty() ? result.set( 0, 0, 0 ) : result.addVectors( this.min, this.max ).multiplyScalar( 0.5 );\\n\\n\\t\\t},\\n\\n\\t\\tgetSize: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\t\\t\\treturn this.isEmpty() ? result.set( 0, 0, 0 ) : result.subVectors( this.max, this.min );\\n\\n\\t\\t},\\n\\n\\t\\texpandByPoint: function ( point ) {\\n\\n\\t\\t\\tthis.min.min( point );\\n\\t\\t\\tthis.max.max( point );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\texpandByVector: function ( vector ) {\\n\\n\\t\\t\\tthis.min.sub( vector );\\n\\t\\t\\tthis.max.add( vector );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\texpandByScalar: function ( scalar ) {\\n\\n\\t\\t\\tthis.min.addScalar( - scalar );\\n\\t\\t\\tthis.max.addScalar( scalar );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\texpandByObject: function () {\\n\\n\\t\\t\\t// Computes the world-axis-aligned bounding box of an object (including its children),\\n\\t\\t\\t// accounting for both the object's, and children's, world transforms\\n\\n\\t\\t\\tvar scope, i, l;\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\tfunction traverse( node ) {\\n\\n\\t\\t\\t\\tvar geometry = node.geometry;\\n\\n\\t\\t\\t\\tif ( geometry !== undefined ) {\\n\\n\\t\\t\\t\\t\\tif ( geometry.isGeometry ) {\\n\\n\\t\\t\\t\\t\\t\\tvar vertices = geometry.vertices;\\n\\n\\t\\t\\t\\t\\t\\tfor ( i = 0, l = vertices.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tv1.copy( vertices[ i ] );\\n\\t\\t\\t\\t\\t\\t\\tv1.applyMatrix4( node.matrixWorld );\\n\\n\\t\\t\\t\\t\\t\\t\\tscope.expandByPoint( v1 );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else if ( geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\t\\t\\tvar attribute = geometry.attributes.position;\\n\\n\\t\\t\\t\\t\\t\\tif ( attribute !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( i = 0, l = attribute.count; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tv1.fromBufferAttribute( attribute, i ).applyMatrix4( node.matrixWorld );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tscope.expandByPoint( v1 );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn function expandByObject( object ) {\\n\\n\\t\\t\\t\\tscope = this;\\n\\n\\t\\t\\t\\tobject.updateMatrixWorld( true );\\n\\n\\t\\t\\t\\tobject.traverse( traverse );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tcontainsPoint: function ( point ) {\\n\\n\\t\\t\\treturn point.x < this.min.x || point.x > this.max.x ||\\n\\t\\t\\t\\tpoint.y < this.min.y || point.y > this.max.y ||\\n\\t\\t\\t\\tpoint.z < this.min.z || point.z > this.max.z ? false : true;\\n\\n\\t\\t},\\n\\n\\t\\tcontainsBox: function ( box ) {\\n\\n\\t\\t\\treturn this.min.x <= box.min.x && box.max.x <= this.max.x &&\\n\\t\\t\\t\\tthis.min.y <= box.min.y && box.max.y <= this.max.y &&\\n\\t\\t\\t\\tthis.min.z <= box.min.z && box.max.z <= this.max.z;\\n\\n\\t\\t},\\n\\n\\t\\tgetParameter: function ( point, optionalTarget ) {\\n\\n\\t\\t\\t// This can potentially have a divide by zero if the box\\n\\t\\t\\t// has a size dimension of 0.\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\treturn result.set(\\n\\t\\t\\t\\t( point.x - this.min.x ) / ( this.max.x - this.min.x ),\\n\\t\\t\\t\\t( point.y - this.min.y ) / ( this.max.y - this.min.y ),\\n\\t\\t\\t\\t( point.z - this.min.z ) / ( this.max.z - this.min.z )\\n\\t\\t\\t);\\n\\n\\t\\t},\\n\\n\\t\\tintersectsBox: function ( box ) {\\n\\n\\t\\t\\t// using 6 splitting planes to rule out intersections.\\n\\t\\t\\treturn box.max.x < this.min.x || box.min.x > this.max.x ||\\n\\t\\t\\t\\tbox.max.y < this.min.y || box.min.y > this.max.y ||\\n\\t\\t\\t\\tbox.max.z < this.min.z || box.min.z > this.max.z ? false : true;\\n\\n\\t\\t},\\n\\n\\t\\tintersectsSphere: ( function () {\\n\\n\\t\\t\\tvar closestPoint = new Vector3();\\n\\n\\t\\t\\treturn function intersectsSphere( sphere ) {\\n\\n\\t\\t\\t\\t// Find the point on the AABB closest to the sphere center.\\n\\t\\t\\t\\tthis.clampPoint( sphere.center, closestPoint );\\n\\n\\t\\t\\t\\t// If that point is inside the sphere, the AABB and sphere intersect.\\n\\t\\t\\t\\treturn closestPoint.distanceToSquared( sphere.center ) <= ( sphere.radius * sphere.radius );\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )(),\\n\\n\\t\\tintersectsPlane: function ( plane ) {\\n\\n\\t\\t\\t// We compute the minimum and maximum dot product values. If those values\\n\\t\\t\\t// are on the same side (back or front) of the plane, then there is no intersection.\\n\\n\\t\\t\\tvar min, max;\\n\\n\\t\\t\\tif ( plane.normal.x > 0 ) {\\n\\n\\t\\t\\t\\tmin = plane.normal.x * this.min.x;\\n\\t\\t\\t\\tmax = plane.normal.x * this.max.x;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tmin = plane.normal.x * this.max.x;\\n\\t\\t\\t\\tmax = plane.normal.x * this.min.x;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( plane.normal.y > 0 ) {\\n\\n\\t\\t\\t\\tmin += plane.normal.y * this.min.y;\\n\\t\\t\\t\\tmax += plane.normal.y * this.max.y;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tmin += plane.normal.y * this.max.y;\\n\\t\\t\\t\\tmax += plane.normal.y * this.min.y;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( plane.normal.z > 0 ) {\\n\\n\\t\\t\\t\\tmin += plane.normal.z * this.min.z;\\n\\t\\t\\t\\tmax += plane.normal.z * this.max.z;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tmin += plane.normal.z * this.max.z;\\n\\t\\t\\t\\tmax += plane.normal.z * this.min.z;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn ( min <= plane.constant && max >= plane.constant );\\n\\n\\t\\t},\\n\\n\\t\\tclampPoint: function ( point, optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\t\\t\\treturn result.copy( point ).clamp( this.min, this.max );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToPoint: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function distanceToPoint( point ) {\\n\\n\\t\\t\\t\\tvar clampedPoint = v1.copy( point ).clamp( this.min, this.max );\\n\\t\\t\\t\\treturn clampedPoint.sub( point ).length();\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tgetBoundingSphere: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function getBoundingSphere( optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Sphere();\\n\\n\\t\\t\\t\\tthis.getCenter( result.center );\\n\\n\\t\\t\\t\\tresult.radius = this.getSize( v1 ).length() * 0.5;\\n\\n\\t\\t\\t\\treturn result;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tintersect: function ( box ) {\\n\\n\\t\\t\\tthis.min.max( box.min );\\n\\t\\t\\tthis.max.min( box.max );\\n\\n\\t\\t\\t// ensure that if there is no overlap, the result is fully empty, not slightly empty with non-inf/+inf values that will cause subsequence intersects to erroneously return valid values.\\n\\t\\t\\tif ( this.isEmpty() ) this.makeEmpty();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tunion: function ( box ) {\\n\\n\\t\\t\\tthis.min.min( box.min );\\n\\t\\t\\tthis.max.max( box.max );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tapplyMatrix4: function () {\\n\\n\\t\\t\\tvar points = [\\n\\t\\t\\t\\tnew Vector3(),\\n\\t\\t\\t\\tnew Vector3(),\\n\\t\\t\\t\\tnew Vector3(),\\n\\t\\t\\t\\tnew Vector3(),\\n\\t\\t\\t\\tnew Vector3(),\\n\\t\\t\\t\\tnew Vector3(),\\n\\t\\t\\t\\tnew Vector3(),\\n\\t\\t\\t\\tnew Vector3()\\n\\t\\t\\t];\\n\\n\\t\\t\\treturn function applyMatrix4( matrix ) {\\n\\n\\t\\t\\t\\t// transform of empty box is an empty box.\\n\\t\\t\\t\\tif ( this.isEmpty() ) return this;\\n\\n\\t\\t\\t\\t// NOTE: I am using a binary pattern to specify all 2^3 combinations below\\n\\t\\t\\t\\tpoints[ 0 ].set( this.min.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 000\\n\\t\\t\\t\\tpoints[ 1 ].set( this.min.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 001\\n\\t\\t\\t\\tpoints[ 2 ].set( this.min.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 010\\n\\t\\t\\t\\tpoints[ 3 ].set( this.min.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 011\\n\\t\\t\\t\\tpoints[ 4 ].set( this.max.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 100\\n\\t\\t\\t\\tpoints[ 5 ].set( this.max.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 101\\n\\t\\t\\t\\tpoints[ 6 ].set( this.max.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 110\\n\\t\\t\\t\\tpoints[ 7 ].set( this.max.x, this.max.y, this.max.z ).applyMatrix4( matrix );\\t// 111\\n\\n\\t\\t\\t\\tthis.setFromPoints( points );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttranslate: function ( offset ) {\\n\\n\\t\\t\\tthis.min.add( offset );\\n\\t\\t\\tthis.max.add( offset );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( box ) {\\n\\n\\t\\t\\treturn box.min.equals( this.min ) && box.max.equals( this.max );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author bhouston / http://clara.io\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Sphere( center, radius ) {\\n\\n\\t\\tthis.center = ( center !== undefined ) ? center : new Vector3();\\n\\t\\tthis.radius = ( radius !== undefined ) ? radius : 0;\\n\\n\\t}\\n\\n\\tObject.assign( Sphere.prototype, {\\n\\n\\t\\tset: function ( center, radius ) {\\n\\n\\t\\t\\tthis.center.copy( center );\\n\\t\\t\\tthis.radius = radius;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromPoints: function () {\\n\\n\\t\\t\\tvar box = new Box3();\\n\\n\\t\\t\\treturn function setFromPoints( points, optionalCenter ) {\\n\\n\\t\\t\\t\\tvar center = this.center;\\n\\n\\t\\t\\t\\tif ( optionalCenter !== undefined ) {\\n\\n\\t\\t\\t\\t\\tcenter.copy( optionalCenter );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tbox.setFromPoints( points ).getCenter( center );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar maxRadiusSq = 0;\\n\\n\\t\\t\\t\\tfor ( var i = 0, il = points.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tmaxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( points[ i ] ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.radius = Math.sqrt( maxRadiusSq );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( sphere ) {\\n\\n\\t\\t\\tthis.center.copy( sphere.center );\\n\\t\\t\\tthis.radius = sphere.radius;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tempty: function () {\\n\\n\\t\\t\\treturn ( this.radius <= 0 );\\n\\n\\t\\t},\\n\\n\\t\\tcontainsPoint: function ( point ) {\\n\\n\\t\\t\\treturn ( point.distanceToSquared( this.center ) <= ( this.radius * this.radius ) );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToPoint: function ( point ) {\\n\\n\\t\\t\\treturn ( point.distanceTo( this.center ) - this.radius );\\n\\n\\t\\t},\\n\\n\\t\\tintersectsSphere: function ( sphere ) {\\n\\n\\t\\t\\tvar radiusSum = this.radius + sphere.radius;\\n\\n\\t\\t\\treturn sphere.center.distanceToSquared( this.center ) <= ( radiusSum * radiusSum );\\n\\n\\t\\t},\\n\\n\\t\\tintersectsBox: function ( box ) {\\n\\n\\t\\t\\treturn box.intersectsSphere( this );\\n\\n\\t\\t},\\n\\n\\t\\tintersectsPlane: function ( plane ) {\\n\\n\\t\\t\\treturn Math.abs( plane.distanceToPoint( this.center ) ) <= this.radius;\\n\\n\\t\\t},\\n\\n\\t\\tclampPoint: function ( point, optionalTarget ) {\\n\\n\\t\\t\\tvar deltaLengthSq = this.center.distanceToSquared( point );\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\tresult.copy( point );\\n\\n\\t\\t\\tif ( deltaLengthSq > ( this.radius * this.radius ) ) {\\n\\n\\t\\t\\t\\tresult.sub( this.center ).normalize();\\n\\t\\t\\t\\tresult.multiplyScalar( this.radius ).add( this.center );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn result;\\n\\n\\t\\t},\\n\\n\\t\\tgetBoundingBox: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar box = optionalTarget || new Box3();\\n\\n\\t\\t\\tbox.set( this.center, this.center );\\n\\t\\t\\tbox.expandByScalar( this.radius );\\n\\n\\t\\t\\treturn box;\\n\\n\\t\\t},\\n\\n\\t\\tapplyMatrix4: function ( matrix ) {\\n\\n\\t\\t\\tthis.center.applyMatrix4( matrix );\\n\\t\\t\\tthis.radius = this.radius * matrix.getMaxScaleOnAxis();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttranslate: function ( offset ) {\\n\\n\\t\\t\\tthis.center.add( offset );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( sphere ) {\\n\\n\\t\\t\\treturn sphere.center.equals( this.center ) && ( sphere.radius === this.radius );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author bhouston / http://clara.io\\n\\t */\\n\\n\\tfunction Plane( normal, constant ) {\\n\\n\\t\\t// normal is assumed to be normalized\\n\\n\\t\\tthis.normal = ( normal !== undefined ) ? normal : new Vector3( 1, 0, 0 );\\n\\t\\tthis.constant = ( constant !== undefined ) ? constant : 0;\\n\\n\\t}\\n\\n\\tObject.assign( Plane.prototype, {\\n\\n\\t\\tset: function ( normal, constant ) {\\n\\n\\t\\t\\tthis.normal.copy( normal );\\n\\t\\t\\tthis.constant = constant;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetComponents: function ( x, y, z, w ) {\\n\\n\\t\\t\\tthis.normal.set( x, y, z );\\n\\t\\t\\tthis.constant = w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromNormalAndCoplanarPoint: function ( normal, point ) {\\n\\n\\t\\t\\tthis.normal.copy( normal );\\n\\t\\t\\tthis.constant = - point.dot( this.normal );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromCoplanarPoints: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\t\\t\\tvar v2 = new Vector3();\\n\\n\\t\\t\\treturn function setFromCoplanarPoints( a, b, c ) {\\n\\n\\t\\t\\t\\tvar normal = v1.subVectors( c, b ).cross( v2.subVectors( a, b ) ).normalize();\\n\\n\\t\\t\\t\\t// Q: should an error be thrown if normal is zero (e.g. degenerate plane)?\\n\\n\\t\\t\\t\\tthis.setFromNormalAndCoplanarPoint( normal, a );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( plane ) {\\n\\n\\t\\t\\tthis.normal.copy( plane.normal );\\n\\t\\t\\tthis.constant = plane.constant;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tnormalize: function () {\\n\\n\\t\\t\\t// Note: will lead to a divide by zero if the plane is invalid.\\n\\n\\t\\t\\tvar inverseNormalLength = 1.0 / this.normal.length();\\n\\t\\t\\tthis.normal.multiplyScalar( inverseNormalLength );\\n\\t\\t\\tthis.constant *= inverseNormalLength;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tnegate: function () {\\n\\n\\t\\t\\tthis.constant *= - 1;\\n\\t\\t\\tthis.normal.negate();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToPoint: function ( point ) {\\n\\n\\t\\t\\treturn this.normal.dot( point ) + this.constant;\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToSphere: function ( sphere ) {\\n\\n\\t\\t\\treturn this.distanceToPoint( sphere.center ) - sphere.radius;\\n\\n\\t\\t},\\n\\n\\t\\tprojectPoint: function ( point, optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\treturn result.copy( this.normal ).multiplyScalar( - this.distanceToPoint( point ) ).add( point );\\n\\n\\t\\t},\\n\\n\\t\\tintersectLine: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function intersectLine( line, optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\t\\tvar direction = line.delta( v1 );\\n\\n\\t\\t\\t\\tvar denominator = this.normal.dot( direction );\\n\\n\\t\\t\\t\\tif ( denominator === 0 ) {\\n\\n\\t\\t\\t\\t\\t// line is coplanar, return origin\\n\\t\\t\\t\\t\\tif ( this.distanceToPoint( line.start ) === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\treturn result.copy( line.start );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t// Unsure if this is the correct method to handle this case.\\n\\t\\t\\t\\t\\treturn undefined;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar t = - ( line.start.dot( this.normal ) + this.constant ) / denominator;\\n\\n\\t\\t\\t\\tif ( t < 0 || t > 1 ) {\\n\\n\\t\\t\\t\\t\\treturn undefined;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn result.copy( direction ).multiplyScalar( t ).add( line.start );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tintersectsLine: function ( line ) {\\n\\n\\t\\t\\t// Note: this tests if a line intersects the plane, not whether it (or its end-points) are coplanar with it.\\n\\n\\t\\t\\tvar startSign = this.distanceToPoint( line.start );\\n\\t\\t\\tvar endSign = this.distanceToPoint( line.end );\\n\\n\\t\\t\\treturn ( startSign < 0 && endSign > 0 ) || ( endSign < 0 && startSign > 0 );\\n\\n\\t\\t},\\n\\n\\t\\tintersectsBox: function ( box ) {\\n\\n\\t\\t\\treturn box.intersectsPlane( this );\\n\\n\\t\\t},\\n\\n\\t\\tintersectsSphere: function ( sphere ) {\\n\\n\\t\\t\\treturn sphere.intersectsPlane( this );\\n\\n\\t\\t},\\n\\n\\t\\tcoplanarPoint: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\treturn result.copy( this.normal ).multiplyScalar( - this.constant );\\n\\n\\t\\t},\\n\\n\\t\\tapplyMatrix4: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\t\\t\\tvar m1 = new Matrix3();\\n\\n\\t\\t\\treturn function applyMatrix4( matrix, optionalNormalMatrix ) {\\n\\n\\t\\t\\t\\tvar normalMatrix = optionalNormalMatrix || m1.getNormalMatrix( matrix );\\n\\n\\t\\t\\t\\tvar referencePoint = this.coplanarPoint( v1 ).applyMatrix4( matrix );\\n\\n\\t\\t\\t\\tvar normal = this.normal.applyMatrix3( normalMatrix ).normalize();\\n\\n\\t\\t\\t\\tthis.constant = - referencePoint.dot( normal );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttranslate: function ( offset ) {\\n\\n\\t\\t\\tthis.constant -= offset.dot( this.normal );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( plane ) {\\n\\n\\t\\t\\treturn plane.normal.equals( this.normal ) && ( plane.constant === this.constant );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author bhouston / http://clara.io\\n\\t */\\n\\n\\tfunction Frustum( p0, p1, p2, p3, p4, p5 ) {\\n\\n\\t\\tthis.planes = [\\n\\n\\t\\t\\t( p0 !== undefined ) ? p0 : new Plane(),\\n\\t\\t\\t( p1 !== undefined ) ? p1 : new Plane(),\\n\\t\\t\\t( p2 !== undefined ) ? p2 : new Plane(),\\n\\t\\t\\t( p3 !== undefined ) ? p3 : new Plane(),\\n\\t\\t\\t( p4 !== undefined ) ? p4 : new Plane(),\\n\\t\\t\\t( p5 !== undefined ) ? p5 : new Plane()\\n\\n\\t\\t];\\n\\n\\t}\\n\\n\\tObject.assign( Frustum.prototype, {\\n\\n\\t\\tset: function ( p0, p1, p2, p3, p4, p5 ) {\\n\\n\\t\\t\\tvar planes = this.planes;\\n\\n\\t\\t\\tplanes[ 0 ].copy( p0 );\\n\\t\\t\\tplanes[ 1 ].copy( p1 );\\n\\t\\t\\tplanes[ 2 ].copy( p2 );\\n\\t\\t\\tplanes[ 3 ].copy( p3 );\\n\\t\\t\\tplanes[ 4 ].copy( p4 );\\n\\t\\t\\tplanes[ 5 ].copy( p5 );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( frustum ) {\\n\\n\\t\\t\\tvar planes = this.planes;\\n\\n\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\tplanes[ i ].copy( frustum.planes[ i ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromMatrix: function ( m ) {\\n\\n\\t\\t\\tvar planes = this.planes;\\n\\t\\t\\tvar me = m.elements;\\n\\t\\t\\tvar me0 = me[ 0 ], me1 = me[ 1 ], me2 = me[ 2 ], me3 = me[ 3 ];\\n\\t\\t\\tvar me4 = me[ 4 ], me5 = me[ 5 ], me6 = me[ 6 ], me7 = me[ 7 ];\\n\\t\\t\\tvar me8 = me[ 8 ], me9 = me[ 9 ], me10 = me[ 10 ], me11 = me[ 11 ];\\n\\t\\t\\tvar me12 = me[ 12 ], me13 = me[ 13 ], me14 = me[ 14 ], me15 = me[ 15 ];\\n\\n\\t\\t\\tplanes[ 0 ].setComponents( me3 - me0, me7 - me4, me11 - me8, me15 - me12 ).normalize();\\n\\t\\t\\tplanes[ 1 ].setComponents( me3 + me0, me7 + me4, me11 + me8, me15 + me12 ).normalize();\\n\\t\\t\\tplanes[ 2 ].setComponents( me3 + me1, me7 + me5, me11 + me9, me15 + me13 ).normalize();\\n\\t\\t\\tplanes[ 3 ].setComponents( me3 - me1, me7 - me5, me11 - me9, me15 - me13 ).normalize();\\n\\t\\t\\tplanes[ 4 ].setComponents( me3 - me2, me7 - me6, me11 - me10, me15 - me14 ).normalize();\\n\\t\\t\\tplanes[ 5 ].setComponents( me3 + me2, me7 + me6, me11 + me10, me15 + me14 ).normalize();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tintersectsObject: function () {\\n\\n\\t\\t\\tvar sphere = new Sphere();\\n\\n\\t\\t\\treturn function intersectsObject( object ) {\\n\\n\\t\\t\\t\\tvar geometry = object.geometry;\\n\\n\\t\\t\\t\\tif ( geometry.boundingSphere === null )\\n\\t\\t\\t\\t\\tgeometry.computeBoundingSphere();\\n\\n\\t\\t\\t\\tsphere.copy( geometry.boundingSphere )\\n\\t\\t\\t\\t\\t.applyMatrix4( object.matrixWorld );\\n\\n\\t\\t\\t\\treturn this.intersectsSphere( sphere );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tintersectsSprite: function () {\\n\\n\\t\\t\\tvar sphere = new Sphere();\\n\\n\\t\\t\\treturn function intersectsSprite( sprite ) {\\n\\n\\t\\t\\t\\tsphere.center.set( 0, 0, 0 );\\n\\t\\t\\t\\tsphere.radius = 0.7071067811865476;\\n\\t\\t\\t\\tsphere.applyMatrix4( sprite.matrixWorld );\\n\\n\\t\\t\\t\\treturn this.intersectsSphere( sphere );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tintersectsSphere: function ( sphere ) {\\n\\n\\t\\t\\tvar planes = this.planes;\\n\\t\\t\\tvar center = sphere.center;\\n\\t\\t\\tvar negRadius = - sphere.radius;\\n\\n\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\tvar distance = planes[ i ].distanceToPoint( center );\\n\\n\\t\\t\\t\\tif ( distance < negRadius ) {\\n\\n\\t\\t\\t\\t\\treturn false;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn true;\\n\\n\\t\\t},\\n\\n\\t\\tintersectsBox: function () {\\n\\n\\t\\t\\tvar p1 = new Vector3(),\\n\\t\\t\\t\\tp2 = new Vector3();\\n\\n\\t\\t\\treturn function intersectsBox( box ) {\\n\\n\\t\\t\\t\\tvar planes = this.planes;\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar plane = planes[ i ];\\n\\n\\t\\t\\t\\t\\tp1.x = plane.normal.x > 0 ? box.min.x : box.max.x;\\n\\t\\t\\t\\t\\tp2.x = plane.normal.x > 0 ? box.max.x : box.min.x;\\n\\t\\t\\t\\t\\tp1.y = plane.normal.y > 0 ? box.min.y : box.max.y;\\n\\t\\t\\t\\t\\tp2.y = plane.normal.y > 0 ? box.max.y : box.min.y;\\n\\t\\t\\t\\t\\tp1.z = plane.normal.z > 0 ? box.min.z : box.max.z;\\n\\t\\t\\t\\t\\tp2.z = plane.normal.z > 0 ? box.max.z : box.min.z;\\n\\n\\t\\t\\t\\t\\tvar d1 = plane.distanceToPoint( p1 );\\n\\t\\t\\t\\t\\tvar d2 = plane.distanceToPoint( p2 );\\n\\n\\t\\t\\t\\t\\t// if both outside plane, no intersection\\n\\n\\t\\t\\t\\t\\tif ( d1 < 0 && d2 < 0 ) {\\n\\n\\t\\t\\t\\t\\t\\treturn false;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn true;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tcontainsPoint: function ( point ) {\\n\\n\\t\\t\\tvar planes = this.planes;\\n\\n\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\tif ( planes[ i ].distanceToPoint( point ) < 0 ) {\\n\\n\\t\\t\\t\\t\\treturn false;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn true;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLShadowMap( _renderer, _objects, maxTextureSize ) {\\n\\n\\t\\tvar _frustum = new Frustum(),\\n\\t\\t\\t_projScreenMatrix = new Matrix4(),\\n\\n\\t\\t\\t_shadowMapSize = new Vector2(),\\n\\t\\t\\t_maxShadowMapSize = new Vector2( maxTextureSize, maxTextureSize ),\\n\\n\\t\\t\\t_lookTarget = new Vector3(),\\n\\t\\t\\t_lightPositionWorld = new Vector3(),\\n\\n\\t\\t\\t_MorphingFlag = 1,\\n\\t\\t\\t_SkinningFlag = 2,\\n\\n\\t\\t\\t_NumberOfMaterialVariants = ( _MorphingFlag | _SkinningFlag ) + 1,\\n\\n\\t\\t\\t_depthMaterials = new Array( _NumberOfMaterialVariants ),\\n\\t\\t\\t_distanceMaterials = new Array( _NumberOfMaterialVariants ),\\n\\n\\t\\t\\t_materialCache = {};\\n\\n\\t\\tvar cubeDirections = [\\n\\t\\t\\tnew Vector3( 1, 0, 0 ), new Vector3( - 1, 0, 0 ), new Vector3( 0, 0, 1 ),\\n\\t\\t\\tnew Vector3( 0, 0, - 1 ), new Vector3( 0, 1, 0 ), new Vector3( 0, - 1, 0 )\\n\\t\\t];\\n\\n\\t\\tvar cubeUps = [\\n\\t\\t\\tnew Vector3( 0, 1, 0 ), new Vector3( 0, 1, 0 ), new Vector3( 0, 1, 0 ),\\n\\t\\t\\tnew Vector3( 0, 1, 0 ), new Vector3( 0, 0, 1 ),\\tnew Vector3( 0, 0, - 1 )\\n\\t\\t];\\n\\n\\t\\tvar cube2DViewPorts = [\\n\\t\\t\\tnew Vector4(), new Vector4(), new Vector4(),\\n\\t\\t\\tnew Vector4(), new Vector4(), new Vector4()\\n\\t\\t];\\n\\n\\t\\t// init\\n\\n\\t\\tfor ( var i = 0; i !== _NumberOfMaterialVariants; ++ i ) {\\n\\n\\t\\t\\tvar useMorphing = ( i & _MorphingFlag ) !== 0;\\n\\t\\t\\tvar useSkinning = ( i & _SkinningFlag ) !== 0;\\n\\n\\t\\t\\tvar depthMaterial = new MeshDepthMaterial( {\\n\\n\\t\\t\\t\\tdepthPacking: RGBADepthPacking,\\n\\n\\t\\t\\t\\tmorphTargets: useMorphing,\\n\\t\\t\\t\\tskinning: useSkinning\\n\\n\\t\\t\\t} );\\n\\n\\t\\t\\t_depthMaterials[ i ] = depthMaterial;\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar distanceMaterial = new MeshDistanceMaterial( {\\n\\n\\t\\t\\t\\tmorphTargets: useMorphing,\\n\\t\\t\\t\\tskinning: useSkinning\\n\\n\\t\\t\\t} );\\n\\n\\t\\t\\t_distanceMaterials[ i ] = distanceMaterial;\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tvar scope = this;\\n\\n\\t\\tthis.enabled = false;\\n\\n\\t\\tthis.autoUpdate = true;\\n\\t\\tthis.needsUpdate = false;\\n\\n\\t\\tthis.type = PCFShadowMap;\\n\\n\\t\\tthis.renderReverseSided = true;\\n\\t\\tthis.renderSingleSided = true;\\n\\n\\t\\tthis.render = function ( lights, scene, camera ) {\\n\\n\\t\\t\\tif ( scope.enabled === false ) return;\\n\\t\\t\\tif ( scope.autoUpdate === false && scope.needsUpdate === false ) return;\\n\\n\\t\\t\\tif ( lights.length === 0 ) return;\\n\\n\\t\\t\\t// TODO Clean up (needed in case of contextlost)\\n\\t\\t\\tvar _gl = _renderer.context;\\n\\t\\t\\tvar _state = _renderer.state;\\n\\n\\t\\t\\t// Set GL state for depth map.\\n\\t\\t\\t_state.disable( _gl.BLEND );\\n\\t\\t\\t_state.buffers.color.setClear( 1, 1, 1, 1 );\\n\\t\\t\\t_state.buffers.depth.setTest( true );\\n\\t\\t\\t_state.setScissorTest( false );\\n\\n\\t\\t\\t// render depth map\\n\\n\\t\\t\\tvar faceCount;\\n\\n\\t\\t\\tfor ( var i = 0, il = lights.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar light = lights[ i ];\\n\\t\\t\\t\\tvar shadow = light.shadow;\\n\\t\\t\\t\\tvar isPointLight = light && light.isPointLight;\\n\\n\\t\\t\\t\\tif ( shadow === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLShadowMap:', light, 'has no shadow.' );\\n\\t\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar shadowCamera = shadow.camera;\\n\\n\\t\\t\\t\\t_shadowMapSize.copy( shadow.mapSize );\\n\\t\\t\\t\\t_shadowMapSize.min( _maxShadowMapSize );\\n\\n\\t\\t\\t\\tif ( isPointLight ) {\\n\\n\\t\\t\\t\\t\\tvar vpWidth = _shadowMapSize.x;\\n\\t\\t\\t\\t\\tvar vpHeight = _shadowMapSize.y;\\n\\n\\t\\t\\t\\t\\t// These viewports map a cube-map onto a 2D texture with the\\n\\t\\t\\t\\t\\t// following orientation:\\n\\t\\t\\t\\t\\t//\\n\\t\\t\\t\\t\\t//  xzXZ\\n\\t\\t\\t\\t\\t//   y Y\\n\\t\\t\\t\\t\\t//\\n\\t\\t\\t\\t\\t// X - Positive x direction\\n\\t\\t\\t\\t\\t// x - Negative x direction\\n\\t\\t\\t\\t\\t// Y - Positive y direction\\n\\t\\t\\t\\t\\t// y - Negative y direction\\n\\t\\t\\t\\t\\t// Z - Positive z direction\\n\\t\\t\\t\\t\\t// z - Negative z direction\\n\\n\\t\\t\\t\\t\\t// positive X\\n\\t\\t\\t\\t\\tcube2DViewPorts[ 0 ].set( vpWidth * 2, vpHeight, vpWidth, vpHeight );\\n\\t\\t\\t\\t\\t// negative X\\n\\t\\t\\t\\t\\tcube2DViewPorts[ 1 ].set( 0, vpHeight, vpWidth, vpHeight );\\n\\t\\t\\t\\t\\t// positive Z\\n\\t\\t\\t\\t\\tcube2DViewPorts[ 2 ].set( vpWidth * 3, vpHeight, vpWidth, vpHeight );\\n\\t\\t\\t\\t\\t// negative Z\\n\\t\\t\\t\\t\\tcube2DViewPorts[ 3 ].set( vpWidth, vpHeight, vpWidth, vpHeight );\\n\\t\\t\\t\\t\\t// positive Y\\n\\t\\t\\t\\t\\tcube2DViewPorts[ 4 ].set( vpWidth * 3, 0, vpWidth, vpHeight );\\n\\t\\t\\t\\t\\t// negative Y\\n\\t\\t\\t\\t\\tcube2DViewPorts[ 5 ].set( vpWidth, 0, vpWidth, vpHeight );\\n\\n\\t\\t\\t\\t\\t_shadowMapSize.x *= 4.0;\\n\\t\\t\\t\\t\\t_shadowMapSize.y *= 2.0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( shadow.map === null ) {\\n\\n\\t\\t\\t\\t\\tvar pars = { minFilter: NearestFilter, magFilter: NearestFilter, format: RGBAFormat };\\n\\n\\t\\t\\t\\t\\tshadow.map = new WebGLRenderTarget( _shadowMapSize.x, _shadowMapSize.y, pars );\\n\\t\\t\\t\\t\\tshadow.map.texture.name = light.name + \\\".shadowMap\\\";\\n\\n\\t\\t\\t\\t\\tshadowCamera.updateProjectionMatrix();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( shadow.isSpotLightShadow ) {\\n\\n\\t\\t\\t\\t\\tshadow.update( light );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar shadowMap = shadow.map;\\n\\t\\t\\t\\tvar shadowMatrix = shadow.matrix;\\n\\n\\t\\t\\t\\t_lightPositionWorld.setFromMatrixPosition( light.matrixWorld );\\n\\t\\t\\t\\tshadowCamera.position.copy( _lightPositionWorld );\\n\\n\\t\\t\\t\\tif ( isPointLight ) {\\n\\n\\t\\t\\t\\t\\tfaceCount = 6;\\n\\n\\t\\t\\t\\t\\t// for point lights we set the shadow matrix to be a translation-only matrix\\n\\t\\t\\t\\t\\t// equal to inverse of the light's position\\n\\n\\t\\t\\t\\t\\tshadowMatrix.makeTranslation( - _lightPositionWorld.x, - _lightPositionWorld.y, - _lightPositionWorld.z );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tfaceCount = 1;\\n\\n\\t\\t\\t\\t\\t_lookTarget.setFromMatrixPosition( light.target.matrixWorld );\\n\\t\\t\\t\\t\\tshadowCamera.lookAt( _lookTarget );\\n\\t\\t\\t\\t\\tshadowCamera.updateMatrixWorld();\\n\\n\\t\\t\\t\\t\\t// compute shadow matrix\\n\\n\\t\\t\\t\\t\\tshadowMatrix.set(\\n\\t\\t\\t\\t\\t\\t0.5, 0.0, 0.0, 0.5,\\n\\t\\t\\t\\t\\t\\t0.0, 0.5, 0.0, 0.5,\\n\\t\\t\\t\\t\\t\\t0.0, 0.0, 0.5, 0.5,\\n\\t\\t\\t\\t\\t\\t0.0, 0.0, 0.0, 1.0\\n\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\tshadowMatrix.multiply( shadowCamera.projectionMatrix );\\n\\t\\t\\t\\t\\tshadowMatrix.multiply( shadowCamera.matrixWorldInverse );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t_renderer.setRenderTarget( shadowMap );\\n\\t\\t\\t\\t_renderer.clear();\\n\\n\\t\\t\\t\\t// render shadow map for each cube face (if omni-directional) or\\n\\t\\t\\t\\t// run a single pass if not\\n\\n\\t\\t\\t\\tfor ( var face = 0; face < faceCount; face ++ ) {\\n\\n\\t\\t\\t\\t\\tif ( isPointLight ) {\\n\\n\\t\\t\\t\\t\\t\\t_lookTarget.copy( shadowCamera.position );\\n\\t\\t\\t\\t\\t\\t_lookTarget.add( cubeDirections[ face ] );\\n\\t\\t\\t\\t\\t\\tshadowCamera.up.copy( cubeUps[ face ] );\\n\\t\\t\\t\\t\\t\\tshadowCamera.lookAt( _lookTarget );\\n\\t\\t\\t\\t\\t\\tshadowCamera.updateMatrixWorld();\\n\\n\\t\\t\\t\\t\\t\\tvar vpDimensions = cube2DViewPorts[ face ];\\n\\t\\t\\t\\t\\t\\t_state.viewport( vpDimensions );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t// update camera matrices and frustum\\n\\n\\t\\t\\t\\t\\t_projScreenMatrix.multiplyMatrices( shadowCamera.projectionMatrix, shadowCamera.matrixWorldInverse );\\n\\t\\t\\t\\t\\t_frustum.setFromMatrix( _projScreenMatrix );\\n\\n\\t\\t\\t\\t\\t// set object matrices & frustum culling\\n\\n\\t\\t\\t\\t\\trenderObject( scene, camera, shadowCamera, isPointLight );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tscope.needsUpdate = false;\\n\\n\\t\\t};\\n\\n\\t\\tfunction getDepthMaterial( object, material, isPointLight, lightPositionWorld, shadowCameraNear, shadowCameraFar ) {\\n\\n\\t\\t\\tvar geometry = object.geometry;\\n\\n\\t\\t\\tvar result = null;\\n\\n\\t\\t\\tvar materialVariants = _depthMaterials;\\n\\t\\t\\tvar customMaterial = object.customDepthMaterial;\\n\\n\\t\\t\\tif ( isPointLight ) {\\n\\n\\t\\t\\t\\tmaterialVariants = _distanceMaterials;\\n\\t\\t\\t\\tcustomMaterial = object.customDistanceMaterial;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( ! customMaterial ) {\\n\\n\\t\\t\\t\\tvar useMorphing = false;\\n\\n\\t\\t\\t\\tif ( material.morphTargets ) {\\n\\n\\t\\t\\t\\t\\tif ( geometry && geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\t\\t\\tuseMorphing = geometry.morphAttributes && geometry.morphAttributes.position && geometry.morphAttributes.position.length > 0;\\n\\n\\t\\t\\t\\t\\t} else if ( geometry && geometry.isGeometry ) {\\n\\n\\t\\t\\t\\t\\t\\tuseMorphing = geometry.morphTargets && geometry.morphTargets.length > 0;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( object.isSkinnedMesh && material.skinning === false ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLShadowMap: THREE.SkinnedMesh with material.skinning set to false:', object );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar useSkinning = object.isSkinnedMesh && material.skinning;\\n\\n\\t\\t\\t\\tvar variantIndex = 0;\\n\\n\\t\\t\\t\\tif ( useMorphing ) variantIndex |= _MorphingFlag;\\n\\t\\t\\t\\tif ( useSkinning ) variantIndex |= _SkinningFlag;\\n\\n\\t\\t\\t\\tresult = materialVariants[ variantIndex ];\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tresult = customMaterial;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( _renderer.localClippingEnabled &&\\n\\t\\t\\t\\t\\tmaterial.clipShadows === true &&\\n\\t\\t\\t\\t\\tmaterial.clippingPlanes.length !== 0 ) {\\n\\n\\t\\t\\t\\t// in this case we need a unique material instance reflecting the\\n\\t\\t\\t\\t// appropriate state\\n\\n\\t\\t\\t\\tvar keyA = result.uuid, keyB = material.uuid;\\n\\n\\t\\t\\t\\tvar materialsForVariant = _materialCache[ keyA ];\\n\\n\\t\\t\\t\\tif ( materialsForVariant === undefined ) {\\n\\n\\t\\t\\t\\t\\tmaterialsForVariant = {};\\n\\t\\t\\t\\t\\t_materialCache[ keyA ] = materialsForVariant;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar cachedMaterial = materialsForVariant[ keyB ];\\n\\n\\t\\t\\t\\tif ( cachedMaterial === undefined ) {\\n\\n\\t\\t\\t\\t\\tcachedMaterial = result.clone();\\n\\t\\t\\t\\t\\tmaterialsForVariant[ keyB ] = cachedMaterial;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tresult = cachedMaterial;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tresult.visible = material.visible;\\n\\t\\t\\tresult.wireframe = material.wireframe;\\n\\n\\t\\t\\tvar side = material.side;\\n\\n\\t\\t\\tif ( scope.renderSingleSided && side == DoubleSide ) {\\n\\n\\t\\t\\t\\tside = FrontSide;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( scope.renderReverseSided ) {\\n\\n\\t\\t\\t\\tif ( side === FrontSide ) side = BackSide;\\n\\t\\t\\t\\telse if ( side === BackSide ) side = FrontSide;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tresult.side = side;\\n\\n\\t\\t\\tresult.clipShadows = material.clipShadows;\\n\\t\\t\\tresult.clippingPlanes = material.clippingPlanes;\\n\\t\\t\\tresult.clipIntersection = material.clipIntersection;\\n\\n\\t\\t\\tresult.wireframeLinewidth = material.wireframeLinewidth;\\n\\t\\t\\tresult.linewidth = material.linewidth;\\n\\n\\t\\t\\tif ( isPointLight && result.isMeshDistanceMaterial ) {\\n\\n\\t\\t\\t\\tresult.referencePosition.copy( lightPositionWorld );\\n\\t\\t\\t\\tresult.nearDistance = shadowCameraNear;\\n\\t\\t\\t\\tresult.farDistance = shadowCameraFar;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn result;\\n\\n\\t\\t}\\n\\n\\t\\tfunction renderObject( object, camera, shadowCamera, isPointLight ) {\\n\\n\\t\\t\\tif ( object.visible === false ) return;\\n\\n\\t\\t\\tvar visible = object.layers.test( camera.layers );\\n\\n\\t\\t\\tif ( visible && ( object.isMesh || object.isLine || object.isPoints ) ) {\\n\\n\\t\\t\\t\\tif ( object.castShadow && ( ! object.frustumCulled || _frustum.intersectsObject( object ) ) ) {\\n\\n\\t\\t\\t\\t\\tobject.modelViewMatrix.multiplyMatrices( shadowCamera.matrixWorldInverse, object.matrixWorld );\\n\\n\\t\\t\\t\\t\\tvar geometry = _objects.update( object );\\n\\t\\t\\t\\t\\tvar material = object.material;\\n\\n\\t\\t\\t\\t\\tif ( Array.isArray( material ) ) {\\n\\n\\t\\t\\t\\t\\t\\tvar groups = geometry.groups;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var k = 0, kl = groups.length; k < kl; k ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar group = groups[ k ];\\n\\t\\t\\t\\t\\t\\t\\tvar groupMaterial = material[ group.materialIndex ];\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( groupMaterial && groupMaterial.visible ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tvar depthMaterial = getDepthMaterial( object, groupMaterial, isPointLight, _lightPositionWorld, shadowCamera.near, shadowCamera.far );\\n\\t\\t\\t\\t\\t\\t\\t\\t_renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, group );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else if ( material.visible ) {\\n\\n\\t\\t\\t\\t\\t\\tvar depthMaterial = getDepthMaterial( object, material, isPointLight, _lightPositionWorld, shadowCamera.near, shadowCamera.far );\\n\\t\\t\\t\\t\\t\\t_renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, null );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar children = object.children;\\n\\n\\t\\t\\tfor ( var i = 0, l = children.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\trenderObject( children[ i ], camera, shadowCamera, isPointLight );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLAttributes( gl ) {\\n\\n\\t\\tvar buffers = {};\\n\\n\\t\\tfunction createBuffer( attribute, bufferType ) {\\n\\n\\t\\t\\tvar array = attribute.array;\\n\\t\\t\\tvar usage = attribute.dynamic ? gl.DYNAMIC_DRAW : gl.STATIC_DRAW;\\n\\n\\t\\t\\tvar buffer = gl.createBuffer();\\n\\n\\t\\t\\tgl.bindBuffer( bufferType, buffer );\\n\\t\\t\\tgl.bufferData( bufferType, array, usage );\\n\\n\\t\\t\\tattribute.onUploadCallback();\\n\\n\\t\\t\\tvar type = gl.FLOAT;\\n\\n\\t\\t\\tif ( array instanceof Float32Array ) {\\n\\n\\t\\t\\t\\ttype = gl.FLOAT;\\n\\n\\t\\t\\t} else if ( array instanceof Float64Array ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLAttributes: Unsupported data buffer format: Float64Array.' );\\n\\n\\t\\t\\t} else if ( array instanceof Uint16Array ) {\\n\\n\\t\\t\\t\\ttype = gl.UNSIGNED_SHORT;\\n\\n\\t\\t\\t} else if ( array instanceof Int16Array ) {\\n\\n\\t\\t\\t\\ttype = gl.SHORT;\\n\\n\\t\\t\\t} else if ( array instanceof Uint32Array ) {\\n\\n\\t\\t\\t\\ttype = gl.UNSIGNED_INT;\\n\\n\\t\\t\\t} else if ( array instanceof Int32Array ) {\\n\\n\\t\\t\\t\\ttype = gl.INT;\\n\\n\\t\\t\\t} else if ( array instanceof Int8Array ) {\\n\\n\\t\\t\\t\\ttype = gl.BYTE;\\n\\n\\t\\t\\t} else if ( array instanceof Uint8Array ) {\\n\\n\\t\\t\\t\\ttype = gl.UNSIGNED_BYTE;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn {\\n\\t\\t\\t\\tbuffer: buffer,\\n\\t\\t\\t\\ttype: type,\\n\\t\\t\\t\\tbytesPerElement: array.BYTES_PER_ELEMENT,\\n\\t\\t\\t\\tversion: attribute.version\\n\\t\\t\\t};\\n\\n\\t\\t}\\n\\n\\t\\tfunction updateBuffer( buffer, attribute, bufferType ) {\\n\\n\\t\\t\\tvar array = attribute.array;\\n\\t\\t\\tvar updateRange = attribute.updateRange;\\n\\n\\t\\t\\tgl.bindBuffer( bufferType, buffer );\\n\\n\\t\\t\\tif ( attribute.dynamic === false ) {\\n\\n\\t\\t\\t\\tgl.bufferData( bufferType, array, gl.STATIC_DRAW );\\n\\n\\t\\t\\t} else if ( updateRange.count === - 1 ) {\\n\\n\\t\\t\\t\\t// Not using update ranges\\n\\n\\t\\t\\t\\tgl.bufferSubData( bufferType, 0, array );\\n\\n\\t\\t\\t} else if ( updateRange.count === 0 ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.WebGLObjects.updateBuffer: dynamic THREE.BufferAttribute marked as needsUpdate but updateRange.count is 0, ensure you are using set methods or updating manually.' );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tgl.bufferSubData( bufferType, updateRange.offset * array.BYTES_PER_ELEMENT,\\n\\t\\t\\t\\t\\tarray.subarray( updateRange.offset, updateRange.offset + updateRange.count ) );\\n\\n\\t\\t\\t\\tupdateRange.count = - 1; // reset range\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tfunction get( attribute ) {\\n\\n\\t\\t\\tif ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;\\n\\n\\t\\t\\treturn buffers[ attribute.uuid ];\\n\\n\\t\\t}\\n\\n\\t\\tfunction remove( attribute ) {\\n\\n\\t\\t\\tif ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;\\n\\n\\t\\t\\tvar data = buffers[ attribute.uuid ];\\n\\n\\t\\t\\tif ( data ) {\\n\\n\\t\\t\\t\\tgl.deleteBuffer( data.buffer );\\n\\n\\t\\t\\t\\tdelete buffers[ attribute.uuid ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction update( attribute, bufferType ) {\\n\\n\\t\\t\\tif ( attribute.isInterleavedBufferAttribute ) attribute = attribute.data;\\n\\n\\t\\t\\tvar data = buffers[ attribute.uuid ];\\n\\n\\t\\t\\tif ( data === undefined ) {\\n\\n\\t\\t\\t\\tbuffers[ attribute.uuid ] = createBuffer( attribute, bufferType );\\n\\n\\t\\t\\t} else if ( data.version < attribute.version ) {\\n\\n\\t\\t\\t\\tupdateBuffer( data.buffer, attribute, bufferType );\\n\\n\\t\\t\\t\\tdata.version = attribute.version;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tget: get,\\n\\t\\t\\tremove: remove,\\n\\t\\t\\tupdate: update\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t * @author bhouston / http://clara.io\\n\\t */\\n\\n\\tfunction Euler( x, y, z, order ) {\\n\\n\\t\\tthis._x = x || 0;\\n\\t\\tthis._y = y || 0;\\n\\t\\tthis._z = z || 0;\\n\\t\\tthis._order = order || Euler.DefaultOrder;\\n\\n\\t}\\n\\n\\tEuler.RotationOrders = [ 'XYZ', 'YZX', 'ZXY', 'XZY', 'YXZ', 'ZYX' ];\\n\\n\\tEuler.DefaultOrder = 'XYZ';\\n\\n\\tObject.defineProperties( Euler.prototype, {\\n\\n\\t\\tx: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this._x;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis._x = value;\\n\\t\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\ty: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this._y;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis._y = value;\\n\\t\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tz: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this._z;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis._z = value;\\n\\t\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\torder: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this._order;\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tthis._order = value;\\n\\t\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Euler.prototype, {\\n\\n\\t\\tisEuler: true,\\n\\n\\t\\tset: function ( x, y, z, order ) {\\n\\n\\t\\t\\tthis._x = x;\\n\\t\\t\\tthis._y = y;\\n\\t\\t\\tthis._z = z;\\n\\t\\t\\tthis._order = order || this._order;\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this._x, this._y, this._z, this._order );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( euler ) {\\n\\n\\t\\t\\tthis._x = euler._x;\\n\\t\\t\\tthis._y = euler._y;\\n\\t\\t\\tthis._z = euler._z;\\n\\t\\t\\tthis._order = euler._order;\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromRotationMatrix: function ( m, order, update ) {\\n\\n\\t\\t\\tvar clamp = _Math.clamp;\\n\\n\\t\\t\\t// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)\\n\\n\\t\\t\\tvar te = m.elements;\\n\\t\\t\\tvar m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ];\\n\\t\\t\\tvar m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ];\\n\\t\\t\\tvar m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];\\n\\n\\t\\t\\torder = order || this._order;\\n\\n\\t\\t\\tif ( order === 'XYZ' ) {\\n\\n\\t\\t\\t\\tthis._y = Math.asin( clamp( m13, - 1, 1 ) );\\n\\n\\t\\t\\t\\tif ( Math.abs( m13 ) < 0.99999 ) {\\n\\n\\t\\t\\t\\t\\tthis._x = Math.atan2( - m23, m33 );\\n\\t\\t\\t\\t\\tthis._z = Math.atan2( - m12, m11 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthis._x = Math.atan2( m32, m22 );\\n\\t\\t\\t\\t\\tthis._z = 0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( order === 'YXZ' ) {\\n\\n\\t\\t\\t\\tthis._x = Math.asin( - clamp( m23, - 1, 1 ) );\\n\\n\\t\\t\\t\\tif ( Math.abs( m23 ) < 0.99999 ) {\\n\\n\\t\\t\\t\\t\\tthis._y = Math.atan2( m13, m33 );\\n\\t\\t\\t\\t\\tthis._z = Math.atan2( m21, m22 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthis._y = Math.atan2( - m31, m11 );\\n\\t\\t\\t\\t\\tthis._z = 0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( order === 'ZXY' ) {\\n\\n\\t\\t\\t\\tthis._x = Math.asin( clamp( m32, - 1, 1 ) );\\n\\n\\t\\t\\t\\tif ( Math.abs( m32 ) < 0.99999 ) {\\n\\n\\t\\t\\t\\t\\tthis._y = Math.atan2( - m31, m33 );\\n\\t\\t\\t\\t\\tthis._z = Math.atan2( - m12, m22 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthis._y = 0;\\n\\t\\t\\t\\t\\tthis._z = Math.atan2( m21, m11 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( order === 'ZYX' ) {\\n\\n\\t\\t\\t\\tthis._y = Math.asin( - clamp( m31, - 1, 1 ) );\\n\\n\\t\\t\\t\\tif ( Math.abs( m31 ) < 0.99999 ) {\\n\\n\\t\\t\\t\\t\\tthis._x = Math.atan2( m32, m33 );\\n\\t\\t\\t\\t\\tthis._z = Math.atan2( m21, m11 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthis._x = 0;\\n\\t\\t\\t\\t\\tthis._z = Math.atan2( - m12, m22 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( order === 'YZX' ) {\\n\\n\\t\\t\\t\\tthis._z = Math.asin( clamp( m21, - 1, 1 ) );\\n\\n\\t\\t\\t\\tif ( Math.abs( m21 ) < 0.99999 ) {\\n\\n\\t\\t\\t\\t\\tthis._x = Math.atan2( - m23, m22 );\\n\\t\\t\\t\\t\\tthis._y = Math.atan2( - m31, m11 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthis._x = 0;\\n\\t\\t\\t\\t\\tthis._y = Math.atan2( m13, m33 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( order === 'XZY' ) {\\n\\n\\t\\t\\t\\tthis._z = Math.asin( - clamp( m12, - 1, 1 ) );\\n\\n\\t\\t\\t\\tif ( Math.abs( m12 ) < 0.99999 ) {\\n\\n\\t\\t\\t\\t\\tthis._x = Math.atan2( m32, m22 );\\n\\t\\t\\t\\t\\tthis._y = Math.atan2( m13, m11 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthis._x = Math.atan2( - m23, m33 );\\n\\t\\t\\t\\t\\tthis._y = 0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Euler: .setFromRotationMatrix() given unsupported order: ' + order );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis._order = order;\\n\\n\\t\\t\\tif ( update !== false ) this.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromQuaternion: function () {\\n\\n\\t\\t\\tvar matrix = new Matrix4();\\n\\n\\t\\t\\treturn function setFromQuaternion( q, order, update ) {\\n\\n\\t\\t\\t\\tmatrix.makeRotationFromQuaternion( q );\\n\\n\\t\\t\\t\\treturn this.setFromRotationMatrix( matrix, order, update );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tsetFromVector3: function ( v, order ) {\\n\\n\\t\\t\\treturn this.set( v.x, v.y, v.z, order || this._order );\\n\\n\\t\\t},\\n\\n\\t\\treorder: function () {\\n\\n\\t\\t\\t// WARNING: this discards revolution information -bhouston\\n\\n\\t\\t\\tvar q = new Quaternion();\\n\\n\\t\\t\\treturn function reorder( newOrder ) {\\n\\n\\t\\t\\t\\tq.setFromEuler( this );\\n\\n\\t\\t\\t\\treturn this.setFromQuaternion( q, newOrder );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tequals: function ( euler ) {\\n\\n\\t\\t\\treturn ( euler._x === this._x ) && ( euler._y === this._y ) && ( euler._z === this._z ) && ( euler._order === this._order );\\n\\n\\t\\t},\\n\\n\\t\\tfromArray: function ( array ) {\\n\\n\\t\\t\\tthis._x = array[ 0 ];\\n\\t\\t\\tthis._y = array[ 1 ];\\n\\t\\t\\tthis._z = array[ 2 ];\\n\\t\\t\\tif ( array[ 3 ] !== undefined ) this._order = array[ 3 ];\\n\\n\\t\\t\\tthis.onChangeCallback();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoArray: function ( array, offset ) {\\n\\n\\t\\t\\tif ( array === undefined ) array = [];\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tarray[ offset ] = this._x;\\n\\t\\t\\tarray[ offset + 1 ] = this._y;\\n\\t\\t\\tarray[ offset + 2 ] = this._z;\\n\\t\\t\\tarray[ offset + 3 ] = this._order;\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t},\\n\\n\\t\\ttoVector3: function ( optionalResult ) {\\n\\n\\t\\t\\tif ( optionalResult ) {\\n\\n\\t\\t\\t\\treturn optionalResult.set( this._x, this._y, this._z );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\treturn new Vector3( this._x, this._y, this._z );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tonChange: function ( callback ) {\\n\\n\\t\\t\\tthis.onChangeCallback = callback;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tonChangeCallback: function () {}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Layers() {\\n\\n\\t\\tthis.mask = 1 | 0;\\n\\n\\t}\\n\\n\\tObject.assign( Layers.prototype, {\\n\\n\\t\\tset: function ( channel ) {\\n\\n\\t\\t\\tthis.mask = 1 << channel | 0;\\n\\n\\t\\t},\\n\\n\\t\\tenable: function ( channel ) {\\n\\n\\t\\t\\tthis.mask |= 1 << channel | 0;\\n\\n\\t\\t},\\n\\n\\t\\ttoggle: function ( channel ) {\\n\\n\\t\\t\\tthis.mask ^= 1 << channel | 0;\\n\\n\\t\\t},\\n\\n\\t\\tdisable: function ( channel ) {\\n\\n\\t\\t\\tthis.mask &= ~ ( 1 << channel | 0 );\\n\\n\\t\\t},\\n\\n\\t\\ttest: function ( layers ) {\\n\\n\\t\\t\\treturn ( this.mask & layers.mask ) !== 0;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t * @author elephantatwork / www.elephantatwork.ch\\n\\t */\\n\\n\\tvar object3DId = 0;\\n\\n\\tfunction Object3D() {\\n\\n\\t\\tObject.defineProperty( this, 'id', { value: object3DId ++ } );\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.name = '';\\n\\t\\tthis.type = 'Object3D';\\n\\n\\t\\tthis.parent = null;\\n\\t\\tthis.children = [];\\n\\n\\t\\tthis.up = Object3D.DefaultUp.clone();\\n\\n\\t\\tvar position = new Vector3();\\n\\t\\tvar rotation = new Euler();\\n\\t\\tvar quaternion = new Quaternion();\\n\\t\\tvar scale = new Vector3( 1, 1, 1 );\\n\\n\\t\\tfunction onRotationChange() {\\n\\n\\t\\t\\tquaternion.setFromEuler( rotation, false );\\n\\n\\t\\t}\\n\\n\\t\\tfunction onQuaternionChange() {\\n\\n\\t\\t\\trotation.setFromQuaternion( quaternion, undefined, false );\\n\\n\\t\\t}\\n\\n\\t\\trotation.onChange( onRotationChange );\\n\\t\\tquaternion.onChange( onQuaternionChange );\\n\\n\\t\\tObject.defineProperties( this, {\\n\\t\\t\\tposition: {\\n\\t\\t\\t\\tenumerable: true,\\n\\t\\t\\t\\tvalue: position\\n\\t\\t\\t},\\n\\t\\t\\trotation: {\\n\\t\\t\\t\\tenumerable: true,\\n\\t\\t\\t\\tvalue: rotation\\n\\t\\t\\t},\\n\\t\\t\\tquaternion: {\\n\\t\\t\\t\\tenumerable: true,\\n\\t\\t\\t\\tvalue: quaternion\\n\\t\\t\\t},\\n\\t\\t\\tscale: {\\n\\t\\t\\t\\tenumerable: true,\\n\\t\\t\\t\\tvalue: scale\\n\\t\\t\\t},\\n\\t\\t\\tmodelViewMatrix: {\\n\\t\\t\\t\\tvalue: new Matrix4()\\n\\t\\t\\t},\\n\\t\\t\\tnormalMatrix: {\\n\\t\\t\\t\\tvalue: new Matrix3()\\n\\t\\t\\t}\\n\\t\\t} );\\n\\n\\t\\tthis.matrix = new Matrix4();\\n\\t\\tthis.matrixWorld = new Matrix4();\\n\\n\\t\\tthis.matrixAutoUpdate = Object3D.DefaultMatrixAutoUpdate;\\n\\t\\tthis.matrixWorldNeedsUpdate = false;\\n\\n\\t\\tthis.layers = new Layers();\\n\\t\\tthis.visible = true;\\n\\n\\t\\tthis.castShadow = false;\\n\\t\\tthis.receiveShadow = false;\\n\\n\\t\\tthis.frustumCulled = true;\\n\\t\\tthis.renderOrder = 0;\\n\\n\\t\\tthis.userData = {};\\n\\n\\t}\\n\\n\\tObject3D.DefaultUp = new Vector3( 0, 1, 0 );\\n\\tObject3D.DefaultMatrixAutoUpdate = true;\\n\\n\\tObject3D.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {\\n\\n\\t\\tconstructor: Object3D,\\n\\n\\t\\tisObject3D: true,\\n\\n\\t\\tonBeforeRender: function () {},\\n\\t\\tonAfterRender: function () {},\\n\\n\\t\\tapplyMatrix: function ( matrix ) {\\n\\n\\t\\t\\tthis.matrix.multiplyMatrices( matrix, this.matrix );\\n\\n\\t\\t\\tthis.matrix.decompose( this.position, this.quaternion, this.scale );\\n\\n\\t\\t},\\n\\n\\t\\tapplyQuaternion: function ( q ) {\\n\\n\\t\\t\\tthis.quaternion.premultiply( q );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetRotationFromAxisAngle: function ( axis, angle ) {\\n\\n\\t\\t\\t// assumes axis is normalized\\n\\n\\t\\t\\tthis.quaternion.setFromAxisAngle( axis, angle );\\n\\n\\t\\t},\\n\\n\\t\\tsetRotationFromEuler: function ( euler ) {\\n\\n\\t\\t\\tthis.quaternion.setFromEuler( euler, true );\\n\\n\\t\\t},\\n\\n\\t\\tsetRotationFromMatrix: function ( m ) {\\n\\n\\t\\t\\t// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)\\n\\n\\t\\t\\tthis.quaternion.setFromRotationMatrix( m );\\n\\n\\t\\t},\\n\\n\\t\\tsetRotationFromQuaternion: function ( q ) {\\n\\n\\t\\t\\t// assumes q is normalized\\n\\n\\t\\t\\tthis.quaternion.copy( q );\\n\\n\\t\\t},\\n\\n\\t\\trotateOnAxis: function () {\\n\\n\\t\\t\\t// rotate object on axis in object space\\n\\t\\t\\t// axis is assumed to be normalized\\n\\n\\t\\t\\tvar q1 = new Quaternion();\\n\\n\\t\\t\\treturn function rotateOnAxis( axis, angle ) {\\n\\n\\t\\t\\t\\tq1.setFromAxisAngle( axis, angle );\\n\\n\\t\\t\\t\\tthis.quaternion.multiply( q1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\trotateOnWorldAxis: function () {\\n\\n\\t\\t\\t// rotate object on axis in world space\\n\\t\\t\\t// axis is assumed to be normalized\\n\\t\\t\\t// method assumes no rotated parent\\n\\n\\t\\t\\tvar q1 = new Quaternion();\\n\\n\\t\\t\\treturn function rotateOnWorldAxis( axis, angle ) {\\n\\n\\t\\t\\t\\tq1.setFromAxisAngle( axis, angle );\\n\\n\\t\\t\\t\\tthis.quaternion.premultiply( q1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\trotateX: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3( 1, 0, 0 );\\n\\n\\t\\t\\treturn function rotateX( angle ) {\\n\\n\\t\\t\\t\\treturn this.rotateOnAxis( v1, angle );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\trotateY: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3( 0, 1, 0 );\\n\\n\\t\\t\\treturn function rotateY( angle ) {\\n\\n\\t\\t\\t\\treturn this.rotateOnAxis( v1, angle );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\trotateZ: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3( 0, 0, 1 );\\n\\n\\t\\t\\treturn function rotateZ( angle ) {\\n\\n\\t\\t\\t\\treturn this.rotateOnAxis( v1, angle );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttranslateOnAxis: function () {\\n\\n\\t\\t\\t// translate object by distance along axis in object space\\n\\t\\t\\t// axis is assumed to be normalized\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function translateOnAxis( axis, distance ) {\\n\\n\\t\\t\\t\\tv1.copy( axis ).applyQuaternion( this.quaternion );\\n\\n\\t\\t\\t\\tthis.position.add( v1.multiplyScalar( distance ) );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttranslateX: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3( 1, 0, 0 );\\n\\n\\t\\t\\treturn function translateX( distance ) {\\n\\n\\t\\t\\t\\treturn this.translateOnAxis( v1, distance );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttranslateY: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3( 0, 1, 0 );\\n\\n\\t\\t\\treturn function translateY( distance ) {\\n\\n\\t\\t\\t\\treturn this.translateOnAxis( v1, distance );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttranslateZ: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3( 0, 0, 1 );\\n\\n\\t\\t\\treturn function translateZ( distance ) {\\n\\n\\t\\t\\t\\treturn this.translateOnAxis( v1, distance );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tlocalToWorld: function ( vector ) {\\n\\n\\t\\t\\treturn vector.applyMatrix4( this.matrixWorld );\\n\\n\\t\\t},\\n\\n\\t\\tworldToLocal: function () {\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function worldToLocal( vector ) {\\n\\n\\t\\t\\t\\treturn vector.applyMatrix4( m1.getInverse( this.matrixWorld ) );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tlookAt: function () {\\n\\n\\t\\t\\t// This method does not support objects with rotated and/or translated parent(s)\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\t\\t\\tvar vector = new Vector3();\\n\\n\\t\\t\\treturn function lookAt( x, y, z ) {\\n\\n\\t\\t\\t\\tif ( x.isVector3 ) {\\n\\n\\t\\t\\t\\t\\tvector.copy( x );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tvector.set( x, y, z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( this.isCamera ) {\\n\\n\\t\\t\\t\\t\\tm1.lookAt( this.position, vector, this.up );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tm1.lookAt( vector, this.position, this.up );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.quaternion.setFromRotationMatrix( m1 );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tadd: function ( object ) {\\n\\n\\t\\t\\tif ( arguments.length > 1 ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < arguments.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tthis.add( arguments[ i ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( object === this ) {\\n\\n\\t\\t\\t\\tconsole.error( \\\"THREE.Object3D.add: object can't be added as a child of itself.\\\", object );\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( ( object && object.isObject3D ) ) {\\n\\n\\t\\t\\t\\tif ( object.parent !== null ) {\\n\\n\\t\\t\\t\\t\\tobject.parent.remove( object );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tobject.parent = this;\\n\\t\\t\\t\\tobject.dispatchEvent( { type: 'added' } );\\n\\n\\t\\t\\t\\tthis.children.push( object );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tconsole.error( \\\"THREE.Object3D.add: object not an instance of THREE.Object3D.\\\", object );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tremove: function ( object ) {\\n\\n\\t\\t\\tif ( arguments.length > 1 ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < arguments.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tthis.remove( arguments[ i ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar index = this.children.indexOf( object );\\n\\n\\t\\t\\tif ( index !== - 1 ) {\\n\\n\\t\\t\\t\\tobject.parent = null;\\n\\n\\t\\t\\t\\tobject.dispatchEvent( { type: 'removed' } );\\n\\n\\t\\t\\t\\tthis.children.splice( index, 1 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetObjectById: function ( id ) {\\n\\n\\t\\t\\treturn this.getObjectByProperty( 'id', id );\\n\\n\\t\\t},\\n\\n\\t\\tgetObjectByName: function ( name ) {\\n\\n\\t\\t\\treturn this.getObjectByProperty( 'name', name );\\n\\n\\t\\t},\\n\\n\\t\\tgetObjectByProperty: function ( name, value ) {\\n\\n\\t\\t\\tif ( this[ name ] === value ) return this;\\n\\n\\t\\t\\tfor ( var i = 0, l = this.children.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar child = this.children[ i ];\\n\\t\\t\\t\\tvar object = child.getObjectByProperty( name, value );\\n\\n\\t\\t\\t\\tif ( object !== undefined ) {\\n\\n\\t\\t\\t\\t\\treturn object;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn undefined;\\n\\n\\t\\t},\\n\\n\\t\\tgetWorldPosition: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\tthis.updateMatrixWorld( true );\\n\\n\\t\\t\\treturn result.setFromMatrixPosition( this.matrixWorld );\\n\\n\\t\\t},\\n\\n\\t\\tgetWorldQuaternion: function () {\\n\\n\\t\\t\\tvar position = new Vector3();\\n\\t\\t\\tvar scale = new Vector3();\\n\\n\\t\\t\\treturn function getWorldQuaternion( optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Quaternion();\\n\\n\\t\\t\\t\\tthis.updateMatrixWorld( true );\\n\\n\\t\\t\\t\\tthis.matrixWorld.decompose( position, result, scale );\\n\\n\\t\\t\\t\\treturn result;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tgetWorldRotation: function () {\\n\\n\\t\\t\\tvar quaternion = new Quaternion();\\n\\n\\t\\t\\treturn function getWorldRotation( optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Euler();\\n\\n\\t\\t\\t\\tthis.getWorldQuaternion( quaternion );\\n\\n\\t\\t\\t\\treturn result.setFromQuaternion( quaternion, this.rotation.order, false );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tgetWorldScale: function () {\\n\\n\\t\\t\\tvar position = new Vector3();\\n\\t\\t\\tvar quaternion = new Quaternion();\\n\\n\\t\\t\\treturn function getWorldScale( optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\t\\tthis.updateMatrixWorld( true );\\n\\n\\t\\t\\t\\tthis.matrixWorld.decompose( position, quaternion, result );\\n\\n\\t\\t\\t\\treturn result;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tgetWorldDirection: function () {\\n\\n\\t\\t\\tvar quaternion = new Quaternion();\\n\\n\\t\\t\\treturn function getWorldDirection( optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\t\\tthis.getWorldQuaternion( quaternion );\\n\\n\\t\\t\\t\\treturn result.set( 0, 0, 1 ).applyQuaternion( quaternion );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\traycast: function () {},\\n\\n\\t\\ttraverse: function ( callback ) {\\n\\n\\t\\t\\tcallback( this );\\n\\n\\t\\t\\tvar children = this.children;\\n\\n\\t\\t\\tfor ( var i = 0, l = children.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tchildren[ i ].traverse( callback );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\ttraverseVisible: function ( callback ) {\\n\\n\\t\\t\\tif ( this.visible === false ) return;\\n\\n\\t\\t\\tcallback( this );\\n\\n\\t\\t\\tvar children = this.children;\\n\\n\\t\\t\\tfor ( var i = 0, l = children.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tchildren[ i ].traverseVisible( callback );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\ttraverseAncestors: function ( callback ) {\\n\\n\\t\\t\\tvar parent = this.parent;\\n\\n\\t\\t\\tif ( parent !== null ) {\\n\\n\\t\\t\\t\\tcallback( parent );\\n\\n\\t\\t\\t\\tparent.traverseAncestors( callback );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tupdateMatrix: function () {\\n\\n\\t\\t\\tthis.matrix.compose( this.position, this.quaternion, this.scale );\\n\\n\\t\\t\\tthis.matrixWorldNeedsUpdate = true;\\n\\n\\t\\t},\\n\\n\\t\\tupdateMatrixWorld: function ( force ) {\\n\\n\\t\\t\\tif ( this.matrixAutoUpdate ) this.updateMatrix();\\n\\n\\t\\t\\tif ( this.matrixWorldNeedsUpdate || force ) {\\n\\n\\t\\t\\t\\tif ( this.parent === null ) {\\n\\n\\t\\t\\t\\t\\tthis.matrixWorld.copy( this.matrix );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthis.matrixWorld.multiplyMatrices( this.parent.matrixWorld, this.matrix );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.matrixWorldNeedsUpdate = false;\\n\\n\\t\\t\\t\\tforce = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// update children\\n\\n\\t\\t\\tvar children = this.children;\\n\\n\\t\\t\\tfor ( var i = 0, l = children.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tchildren[ i ].updateMatrixWorld( force );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\t// meta is a string when called from JSON.stringify\\n\\t\\t\\tvar isRootObject = ( meta === undefined || typeof meta === 'string' );\\n\\n\\t\\t\\tvar output = {};\\n\\n\\t\\t\\t// meta is a hash used to collect geometries, materials.\\n\\t\\t\\t// not providing it implies that this is the root object\\n\\t\\t\\t// being serialized.\\n\\t\\t\\tif ( isRootObject ) {\\n\\n\\t\\t\\t\\t// initialize meta obj\\n\\t\\t\\t\\tmeta = {\\n\\t\\t\\t\\t\\tgeometries: {},\\n\\t\\t\\t\\t\\tmaterials: {},\\n\\t\\t\\t\\t\\ttextures: {},\\n\\t\\t\\t\\t\\timages: {},\\n\\t\\t\\t\\t\\tshapes: {}\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\toutput.metadata = {\\n\\t\\t\\t\\t\\tversion: 4.5,\\n\\t\\t\\t\\t\\ttype: 'Object',\\n\\t\\t\\t\\t\\tgenerator: 'Object3D.toJSON'\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// standard Object3D serialization\\n\\n\\t\\t\\tvar object = {};\\n\\n\\t\\t\\tobject.uuid = this.uuid;\\n\\t\\t\\tobject.type = this.type;\\n\\n\\t\\t\\tif ( this.name !== '' ) object.name = this.name;\\n\\t\\t\\tif ( this.castShadow === true ) object.castShadow = true;\\n\\t\\t\\tif ( this.receiveShadow === true ) object.receiveShadow = true;\\n\\t\\t\\tif ( this.visible === false ) object.visible = false;\\n\\t\\t\\tif ( JSON.stringify( this.userData ) !== '{}' ) object.userData = this.userData;\\n\\n\\t\\t\\tobject.matrix = this.matrix.toArray();\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tfunction serialize( library, element ) {\\n\\n\\t\\t\\t\\tif ( library[ element.uuid ] === undefined ) {\\n\\n\\t\\t\\t\\t\\tlibrary[ element.uuid ] = element.toJSON( meta );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn element.uuid;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.geometry !== undefined ) {\\n\\n\\t\\t\\t\\tobject.geometry = serialize( meta.geometries, this.geometry );\\n\\n\\t\\t\\t\\tvar parameters = this.geometry.parameters;\\n\\n\\t\\t\\t\\tif ( parameters !== undefined && parameters.shapes !== undefined ) {\\n\\n\\t\\t\\t\\t\\tvar shapes = parameters.shapes;\\n\\n\\t\\t\\t\\t\\tif ( Array.isArray( shapes ) ) {\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, l = shapes.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar shape = shapes[ i ];\\n\\n\\t\\t\\t\\t\\t\\t\\tserialize( meta.shapes, shape );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tserialize( meta.shapes, shapes );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.material !== undefined ) {\\n\\n\\t\\t\\t\\tif ( Array.isArray( this.material ) ) {\\n\\n\\t\\t\\t\\t\\tvar uuids = [];\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, l = this.material.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tuuids.push( serialize( meta.materials, this.material[ i ] ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tobject.material = uuids;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tobject.material = serialize( meta.materials, this.material );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tif ( this.children.length > 0 ) {\\n\\n\\t\\t\\t\\tobject.children = [];\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < this.children.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tobject.children.push( this.children[ i ].toJSON( meta ).object );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( isRootObject ) {\\n\\n\\t\\t\\t\\tvar geometries = extractFromCache( meta.geometries );\\n\\t\\t\\t\\tvar materials = extractFromCache( meta.materials );\\n\\t\\t\\t\\tvar textures = extractFromCache( meta.textures );\\n\\t\\t\\t\\tvar images = extractFromCache( meta.images );\\n\\t\\t\\t\\tvar shapes = extractFromCache( meta.shapes );\\n\\n\\t\\t\\t\\tif ( geometries.length > 0 ) output.geometries = geometries;\\n\\t\\t\\t\\tif ( materials.length > 0 ) output.materials = materials;\\n\\t\\t\\t\\tif ( textures.length > 0 ) output.textures = textures;\\n\\t\\t\\t\\tif ( images.length > 0 ) output.images = images;\\n\\t\\t\\t\\tif ( shapes.length > 0 ) output.shapes = shapes;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\toutput.object = object;\\n\\n\\t\\t\\treturn output;\\n\\n\\t\\t\\t// extract data from the cache hash\\n\\t\\t\\t// remove metadata on each item\\n\\t\\t\\t// and return as array\\n\\t\\t\\tfunction extractFromCache( cache ) {\\n\\n\\t\\t\\t\\tvar values = [];\\n\\t\\t\\t\\tfor ( var key in cache ) {\\n\\n\\t\\t\\t\\t\\tvar data = cache[ key ];\\n\\t\\t\\t\\t\\tdelete data.metadata;\\n\\t\\t\\t\\t\\tvalues.push( data );\\n\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\treturn values;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tclone: function ( recursive ) {\\n\\n\\t\\t\\treturn new this.constructor().copy( this, recursive );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source, recursive ) {\\n\\n\\t\\t\\tif ( recursive === undefined ) recursive = true;\\n\\n\\t\\t\\tthis.name = source.name;\\n\\n\\t\\t\\tthis.up.copy( source.up );\\n\\n\\t\\t\\tthis.position.copy( source.position );\\n\\t\\t\\tthis.quaternion.copy( source.quaternion );\\n\\t\\t\\tthis.scale.copy( source.scale );\\n\\n\\t\\t\\tthis.matrix.copy( source.matrix );\\n\\t\\t\\tthis.matrixWorld.copy( source.matrixWorld );\\n\\n\\t\\t\\tthis.matrixAutoUpdate = source.matrixAutoUpdate;\\n\\t\\t\\tthis.matrixWorldNeedsUpdate = source.matrixWorldNeedsUpdate;\\n\\n\\t\\t\\tthis.layers.mask = source.layers.mask;\\n\\t\\t\\tthis.visible = source.visible;\\n\\n\\t\\t\\tthis.castShadow = source.castShadow;\\n\\t\\t\\tthis.receiveShadow = source.receiveShadow;\\n\\n\\t\\t\\tthis.frustumCulled = source.frustumCulled;\\n\\t\\t\\tthis.renderOrder = source.renderOrder;\\n\\n\\t\\t\\tthis.userData = JSON.parse( JSON.stringify( source.userData ) );\\n\\n\\t\\t\\tif ( recursive === true ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < source.children.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar child = source.children[ i ];\\n\\t\\t\\t\\t\\tthis.add( child.clone() );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t*/\\n\\n\\tfunction Camera() {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Camera';\\n\\n\\t\\tthis.matrixWorldInverse = new Matrix4();\\n\\t\\tthis.projectionMatrix = new Matrix4();\\n\\n\\t}\\n\\n\\tCamera.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Camera,\\n\\n\\t\\tisCamera: true,\\n\\n\\t\\tcopy: function ( source, recursive ) {\\n\\n\\t\\t\\tObject3D.prototype.copy.call( this, source, recursive );\\n\\n\\t\\t\\tthis.matrixWorldInverse.copy( source.matrixWorldInverse );\\n\\t\\t\\tthis.projectionMatrix.copy( source.projectionMatrix );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetWorldDirection: function () {\\n\\n\\t\\t\\tvar quaternion = new Quaternion();\\n\\n\\t\\t\\treturn function getWorldDirection( optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\t\\tthis.getWorldQuaternion( quaternion );\\n\\n\\t\\t\\t\\treturn result.set( 0, 0, - 1 ).applyQuaternion( quaternion );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tupdateMatrixWorld: function ( force ) {\\n\\n\\t\\t\\tObject3D.prototype.updateMatrixWorld.call( this, force );\\n\\n\\t\\t\\tthis.matrixWorldInverse.getInverse( this.matrixWorld );\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author arose / http://github.com/arose\\n\\t */\\n\\n\\tfunction OrthographicCamera( left, right, top, bottom, near, far ) {\\n\\n\\t\\tCamera.call( this );\\n\\n\\t\\tthis.type = 'OrthographicCamera';\\n\\n\\t\\tthis.zoom = 1;\\n\\t\\tthis.view = null;\\n\\n\\t\\tthis.left = left;\\n\\t\\tthis.right = right;\\n\\t\\tthis.top = top;\\n\\t\\tthis.bottom = bottom;\\n\\n\\t\\tthis.near = ( near !== undefined ) ? near : 0.1;\\n\\t\\tthis.far = ( far !== undefined ) ? far : 2000;\\n\\n\\t\\tthis.updateProjectionMatrix();\\n\\n\\t}\\n\\n\\tOrthographicCamera.prototype = Object.assign( Object.create( Camera.prototype ), {\\n\\n\\t\\tconstructor: OrthographicCamera,\\n\\n\\t\\tisOrthographicCamera: true,\\n\\n\\t\\tcopy: function ( source, recursive ) {\\n\\n\\t\\t\\tCamera.prototype.copy.call( this, source, recursive );\\n\\n\\t\\t\\tthis.left = source.left;\\n\\t\\t\\tthis.right = source.right;\\n\\t\\t\\tthis.top = source.top;\\n\\t\\t\\tthis.bottom = source.bottom;\\n\\t\\t\\tthis.near = source.near;\\n\\t\\t\\tthis.far = source.far;\\n\\n\\t\\t\\tthis.zoom = source.zoom;\\n\\t\\t\\tthis.view = source.view === null ? null : Object.assign( {}, source.view );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetViewOffset: function ( fullWidth, fullHeight, x, y, width, height ) {\\n\\n\\t\\t\\tif ( this.view === null ) {\\n\\n\\t\\t\\t\\tthis.view = {\\n\\t\\t\\t\\t\\tenabled: true,\\n\\t\\t\\t\\t\\tfullWidth: 1,\\n\\t\\t\\t\\t\\tfullHeight: 1,\\n\\t\\t\\t\\t\\toffsetX: 0,\\n\\t\\t\\t\\t\\toffsetY: 0,\\n\\t\\t\\t\\t\\twidth: 1,\\n\\t\\t\\t\\t\\theight: 1\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.view.enabled = true;\\n\\t\\t\\tthis.view.fullWidth = fullWidth;\\n\\t\\t\\tthis.view.fullHeight = fullHeight;\\n\\t\\t\\tthis.view.offsetX = x;\\n\\t\\t\\tthis.view.offsetY = y;\\n\\t\\t\\tthis.view.width = width;\\n\\t\\t\\tthis.view.height = height;\\n\\n\\t\\t\\tthis.updateProjectionMatrix();\\n\\n\\t\\t},\\n\\n\\t\\tclearViewOffset: function () {\\n\\n\\t\\t\\tif ( this.view !== null ) {\\n\\n\\t\\t\\t\\tthis.view.enabled = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.updateProjectionMatrix();\\n\\n\\t\\t},\\n\\n\\t\\tupdateProjectionMatrix: function () {\\n\\n\\t\\t\\tvar dx = ( this.right - this.left ) / ( 2 * this.zoom );\\n\\t\\t\\tvar dy = ( this.top - this.bottom ) / ( 2 * this.zoom );\\n\\t\\t\\tvar cx = ( this.right + this.left ) / 2;\\n\\t\\t\\tvar cy = ( this.top + this.bottom ) / 2;\\n\\n\\t\\t\\tvar left = cx - dx;\\n\\t\\t\\tvar right = cx + dx;\\n\\t\\t\\tvar top = cy + dy;\\n\\t\\t\\tvar bottom = cy - dy;\\n\\n\\t\\t\\tif ( this.view !== null && this.view.enabled ) {\\n\\n\\t\\t\\t\\tvar zoomW = this.zoom / ( this.view.width / this.view.fullWidth );\\n\\t\\t\\t\\tvar zoomH = this.zoom / ( this.view.height / this.view.fullHeight );\\n\\t\\t\\t\\tvar scaleW = ( this.right - this.left ) / this.view.width;\\n\\t\\t\\t\\tvar scaleH = ( this.top - this.bottom ) / this.view.height;\\n\\n\\t\\t\\t\\tleft += scaleW * ( this.view.offsetX / zoomW );\\n\\t\\t\\t\\tright = left + scaleW * ( this.view.width / zoomW );\\n\\t\\t\\t\\ttop -= scaleH * ( this.view.offsetY / zoomH );\\n\\t\\t\\t\\tbottom = top - scaleH * ( this.view.height / zoomH );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.projectionMatrix.makeOrthographic( left, right, top, bottom, this.near, this.far );\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\tvar data = Object3D.prototype.toJSON.call( this, meta );\\n\\n\\t\\t\\tdata.object.zoom = this.zoom;\\n\\t\\t\\tdata.object.left = this.left;\\n\\t\\t\\tdata.object.right = this.right;\\n\\t\\t\\tdata.object.top = this.top;\\n\\t\\t\\tdata.object.bottom = this.bottom;\\n\\t\\t\\tdata.object.near = this.near;\\n\\t\\t\\tdata.object.far = this.far;\\n\\n\\t\\t\\tif ( this.view !== null ) data.object.view = Object.assign( {}, this.view );\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction Face3( a, b, c, normal, color, materialIndex ) {\\n\\n\\t\\tthis.a = a;\\n\\t\\tthis.b = b;\\n\\t\\tthis.c = c;\\n\\n\\t\\tthis.normal = ( normal && normal.isVector3 ) ? normal : new Vector3();\\n\\t\\tthis.vertexNormals = Array.isArray( normal ) ? normal : [];\\n\\n\\t\\tthis.color = ( color && color.isColor ) ? color : new Color();\\n\\t\\tthis.vertexColors = Array.isArray( color ) ? color : [];\\n\\n\\t\\tthis.materialIndex = materialIndex !== undefined ? materialIndex : 0;\\n\\n\\t}\\n\\n\\tObject.assign( Face3.prototype, {\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tthis.a = source.a;\\n\\t\\t\\tthis.b = source.b;\\n\\t\\t\\tthis.c = source.c;\\n\\n\\t\\t\\tthis.normal.copy( source.normal );\\n\\t\\t\\tthis.color.copy( source.color );\\n\\n\\t\\t\\tthis.materialIndex = source.materialIndex;\\n\\n\\t\\t\\tfor ( var i = 0, il = source.vertexNormals.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.vertexNormals[ i ] = source.vertexNormals[ i ].clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = 0, il = source.vertexColors.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.vertexColors[ i ] = source.vertexColors[ i ].clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author kile / http://kile.stravaganza.org/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t * @author bhouston / http://clara.io\\n\\t */\\n\\n\\tvar geometryId = 0; // Geometry uses even numbers as Id\\n\\n\\tfunction Geometry() {\\n\\n\\t\\tObject.defineProperty( this, 'id', { value: geometryId += 2 } );\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.name = '';\\n\\t\\tthis.type = 'Geometry';\\n\\n\\t\\tthis.vertices = [];\\n\\t\\tthis.colors = [];\\n\\t\\tthis.faces = [];\\n\\t\\tthis.faceVertexUvs = [[]];\\n\\n\\t\\tthis.morphTargets = [];\\n\\t\\tthis.morphNormals = [];\\n\\n\\t\\tthis.skinWeights = [];\\n\\t\\tthis.skinIndices = [];\\n\\n\\t\\tthis.lineDistances = [];\\n\\n\\t\\tthis.boundingBox = null;\\n\\t\\tthis.boundingSphere = null;\\n\\n\\t\\t// update flags\\n\\n\\t\\tthis.elementsNeedUpdate = false;\\n\\t\\tthis.verticesNeedUpdate = false;\\n\\t\\tthis.uvsNeedUpdate = false;\\n\\t\\tthis.normalsNeedUpdate = false;\\n\\t\\tthis.colorsNeedUpdate = false;\\n\\t\\tthis.lineDistancesNeedUpdate = false;\\n\\t\\tthis.groupsNeedUpdate = false;\\n\\n\\t}\\n\\n\\tGeometry.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {\\n\\n\\t\\tconstructor: Geometry,\\n\\n\\t\\tisGeometry: true,\\n\\n\\t\\tapplyMatrix: function ( matrix ) {\\n\\n\\t\\t\\tvar normalMatrix = new Matrix3().getNormalMatrix( matrix );\\n\\n\\t\\t\\tfor ( var i = 0, il = this.vertices.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar vertex = this.vertices[ i ];\\n\\t\\t\\t\\tvertex.applyMatrix4( matrix );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = 0, il = this.faces.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar face = this.faces[ i ];\\n\\t\\t\\t\\tface.normal.applyMatrix3( normalMatrix ).normalize();\\n\\n\\t\\t\\t\\tfor ( var j = 0, jl = face.vertexNormals.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\tface.vertexNormals[ j ].applyMatrix3( normalMatrix ).normalize();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.boundingBox !== null ) {\\n\\n\\t\\t\\t\\tthis.computeBoundingBox();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.boundingSphere !== null ) {\\n\\n\\t\\t\\t\\tthis.computeBoundingSphere();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.verticesNeedUpdate = true;\\n\\t\\t\\tthis.normalsNeedUpdate = true;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\trotateX: function () {\\n\\n\\t\\t\\t// rotate geometry around world x-axis\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function rotateX( angle ) {\\n\\n\\t\\t\\t\\tm1.makeRotationX( angle );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\trotateY: function () {\\n\\n\\t\\t\\t// rotate geometry around world y-axis\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function rotateY( angle ) {\\n\\n\\t\\t\\t\\tm1.makeRotationY( angle );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\trotateZ: function () {\\n\\n\\t\\t\\t// rotate geometry around world z-axis\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function rotateZ( angle ) {\\n\\n\\t\\t\\t\\tm1.makeRotationZ( angle );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttranslate: function () {\\n\\n\\t\\t\\t// translate geometry\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function translate( x, y, z ) {\\n\\n\\t\\t\\t\\tm1.makeTranslation( x, y, z );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tscale: function () {\\n\\n\\t\\t\\t// scale geometry\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function scale( x, y, z ) {\\n\\n\\t\\t\\t\\tm1.makeScale( x, y, z );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tlookAt: function () {\\n\\n\\t\\t\\tvar obj = new Object3D();\\n\\n\\t\\t\\treturn function lookAt( vector ) {\\n\\n\\t\\t\\t\\tobj.lookAt( vector );\\n\\n\\t\\t\\t\\tobj.updateMatrix();\\n\\n\\t\\t\\t\\tthis.applyMatrix( obj.matrix );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tfromBufferGeometry: function ( geometry ) {\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar indices = geometry.index !== null ? geometry.index.array : undefined;\\n\\t\\t\\tvar attributes = geometry.attributes;\\n\\n\\t\\t\\tvar positions = attributes.position.array;\\n\\t\\t\\tvar normals = attributes.normal !== undefined ? attributes.normal.array : undefined;\\n\\t\\t\\tvar colors = attributes.color !== undefined ? attributes.color.array : undefined;\\n\\t\\t\\tvar uvs = attributes.uv !== undefined ? attributes.uv.array : undefined;\\n\\t\\t\\tvar uvs2 = attributes.uv2 !== undefined ? attributes.uv2.array : undefined;\\n\\n\\t\\t\\tif ( uvs2 !== undefined ) this.faceVertexUvs[ 1 ] = [];\\n\\n\\t\\t\\tvar tempNormals = [];\\n\\t\\t\\tvar tempUVs = [];\\n\\t\\t\\tvar tempUVs2 = [];\\n\\n\\t\\t\\tfor ( var i = 0, j = 0; i < positions.length; i += 3, j += 2 ) {\\n\\n\\t\\t\\t\\tscope.vertices.push( new Vector3( positions[ i ], positions[ i + 1 ], positions[ i + 2 ] ) );\\n\\n\\t\\t\\t\\tif ( normals !== undefined ) {\\n\\n\\t\\t\\t\\t\\ttempNormals.push( new Vector3( normals[ i ], normals[ i + 1 ], normals[ i + 2 ] ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( colors !== undefined ) {\\n\\n\\t\\t\\t\\t\\tscope.colors.push( new Color( colors[ i ], colors[ i + 1 ], colors[ i + 2 ] ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( uvs !== undefined ) {\\n\\n\\t\\t\\t\\t\\ttempUVs.push( new Vector2( uvs[ j ], uvs[ j + 1 ] ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( uvs2 !== undefined ) {\\n\\n\\t\\t\\t\\t\\ttempUVs2.push( new Vector2( uvs2[ j ], uvs2[ j + 1 ] ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction addFace( a, b, c, materialIndex ) {\\n\\n\\t\\t\\t\\tvar vertexNormals = normals !== undefined ? [ tempNormals[ a ].clone(), tempNormals[ b ].clone(), tempNormals[ c ].clone() ] : [];\\n\\t\\t\\t\\tvar vertexColors = colors !== undefined ? [ scope.colors[ a ].clone(), scope.colors[ b ].clone(), scope.colors[ c ].clone() ] : [];\\n\\n\\t\\t\\t\\tvar face = new Face3( a, b, c, vertexNormals, vertexColors, materialIndex );\\n\\n\\t\\t\\t\\tscope.faces.push( face );\\n\\n\\t\\t\\t\\tif ( uvs !== undefined ) {\\n\\n\\t\\t\\t\\t\\tscope.faceVertexUvs[ 0 ].push( [ tempUVs[ a ].clone(), tempUVs[ b ].clone(), tempUVs[ c ].clone() ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( uvs2 !== undefined ) {\\n\\n\\t\\t\\t\\t\\tscope.faceVertexUvs[ 1 ].push( [ tempUVs2[ a ].clone(), tempUVs2[ b ].clone(), tempUVs2[ c ].clone() ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar groups = geometry.groups;\\n\\n\\t\\t\\tif ( groups.length > 0 ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < groups.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar group = groups[ i ];\\n\\n\\t\\t\\t\\t\\tvar start = group.start;\\n\\t\\t\\t\\t\\tvar count = group.count;\\n\\n\\t\\t\\t\\t\\tfor ( var j = start, jl = start + count; j < jl; j += 3 ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( indices !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\taddFace( indices[ j ], indices[ j + 1 ], indices[ j + 2 ], group.materialIndex );\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\taddFace( j, j + 1, j + 2, group.materialIndex );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tif ( indices !== undefined ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < indices.length; i += 3 ) {\\n\\n\\t\\t\\t\\t\\t\\taddFace( indices[ i ], indices[ i + 1 ], indices[ i + 2 ] );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < positions.length / 3; i += 3 ) {\\n\\n\\t\\t\\t\\t\\t\\taddFace( i, i + 1, i + 2 );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.computeFaceNormals();\\n\\n\\t\\t\\tif ( geometry.boundingBox !== null ) {\\n\\n\\t\\t\\t\\tthis.boundingBox = geometry.boundingBox.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.boundingSphere !== null ) {\\n\\n\\t\\t\\t\\tthis.boundingSphere = geometry.boundingSphere.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcenter: function () {\\n\\n\\t\\t\\tthis.computeBoundingBox();\\n\\n\\t\\t\\tvar offset = this.boundingBox.getCenter().negate();\\n\\n\\t\\t\\tthis.translate( offset.x, offset.y, offset.z );\\n\\n\\t\\t\\treturn offset;\\n\\n\\t\\t},\\n\\n\\t\\tnormalize: function () {\\n\\n\\t\\t\\tthis.computeBoundingSphere();\\n\\n\\t\\t\\tvar center = this.boundingSphere.center;\\n\\t\\t\\tvar radius = this.boundingSphere.radius;\\n\\n\\t\\t\\tvar s = radius === 0 ? 1 : 1.0 / radius;\\n\\n\\t\\t\\tvar matrix = new Matrix4();\\n\\t\\t\\tmatrix.set(\\n\\t\\t\\t\\ts, 0, 0, - s * center.x,\\n\\t\\t\\t\\t0, s, 0, - s * center.y,\\n\\t\\t\\t\\t0, 0, s, - s * center.z,\\n\\t\\t\\t\\t0, 0, 0, 1\\n\\t\\t\\t);\\n\\n\\t\\t\\tthis.applyMatrix( matrix );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcomputeFaceNormals: function () {\\n\\n\\t\\t\\tvar cb = new Vector3(), ab = new Vector3();\\n\\n\\t\\t\\tfor ( var f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\tvar face = this.faces[ f ];\\n\\n\\t\\t\\t\\tvar vA = this.vertices[ face.a ];\\n\\t\\t\\t\\tvar vB = this.vertices[ face.b ];\\n\\t\\t\\t\\tvar vC = this.vertices[ face.c ];\\n\\n\\t\\t\\t\\tcb.subVectors( vC, vB );\\n\\t\\t\\t\\tab.subVectors( vA, vB );\\n\\t\\t\\t\\tcb.cross( ab );\\n\\n\\t\\t\\t\\tcb.normalize();\\n\\n\\t\\t\\t\\tface.normal.copy( cb );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tcomputeVertexNormals: function ( areaWeighted ) {\\n\\n\\t\\t\\tif ( areaWeighted === undefined ) areaWeighted = true;\\n\\n\\t\\t\\tvar v, vl, f, fl, face, vertices;\\n\\n\\t\\t\\tvertices = new Array( this.vertices.length );\\n\\n\\t\\t\\tfor ( v = 0, vl = this.vertices.length; v < vl; v ++ ) {\\n\\n\\t\\t\\t\\tvertices[ v ] = new Vector3();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( areaWeighted ) {\\n\\n\\t\\t\\t\\t// vertex normals weighted by triangle areas\\n\\t\\t\\t\\t// http://www.iquilezles.org/www/articles/normals/normals.htm\\n\\n\\t\\t\\t\\tvar vA, vB, vC;\\n\\t\\t\\t\\tvar cb = new Vector3(), ab = new Vector3();\\n\\n\\t\\t\\t\\tfor ( f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\t\\tface = this.faces[ f ];\\n\\n\\t\\t\\t\\t\\tvA = this.vertices[ face.a ];\\n\\t\\t\\t\\t\\tvB = this.vertices[ face.b ];\\n\\t\\t\\t\\t\\tvC = this.vertices[ face.c ];\\n\\n\\t\\t\\t\\t\\tcb.subVectors( vC, vB );\\n\\t\\t\\t\\t\\tab.subVectors( vA, vB );\\n\\t\\t\\t\\t\\tcb.cross( ab );\\n\\n\\t\\t\\t\\t\\tvertices[ face.a ].add( cb );\\n\\t\\t\\t\\t\\tvertices[ face.b ].add( cb );\\n\\t\\t\\t\\t\\tvertices[ face.c ].add( cb );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.computeFaceNormals();\\n\\n\\t\\t\\t\\tfor ( f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\t\\tface = this.faces[ f ];\\n\\n\\t\\t\\t\\t\\tvertices[ face.a ].add( face.normal );\\n\\t\\t\\t\\t\\tvertices[ face.b ].add( face.normal );\\n\\t\\t\\t\\t\\tvertices[ face.c ].add( face.normal );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( v = 0, vl = this.vertices.length; v < vl; v ++ ) {\\n\\n\\t\\t\\t\\tvertices[ v ].normalize();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\tface = this.faces[ f ];\\n\\n\\t\\t\\t\\tvar vertexNormals = face.vertexNormals;\\n\\n\\t\\t\\t\\tif ( vertexNormals.length === 3 ) {\\n\\n\\t\\t\\t\\t\\tvertexNormals[ 0 ].copy( vertices[ face.a ] );\\n\\t\\t\\t\\t\\tvertexNormals[ 1 ].copy( vertices[ face.b ] );\\n\\t\\t\\t\\t\\tvertexNormals[ 2 ].copy( vertices[ face.c ] );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tvertexNormals[ 0 ] = vertices[ face.a ].clone();\\n\\t\\t\\t\\t\\tvertexNormals[ 1 ] = vertices[ face.b ].clone();\\n\\t\\t\\t\\t\\tvertexNormals[ 2 ] = vertices[ face.c ].clone();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.faces.length > 0 ) {\\n\\n\\t\\t\\t\\tthis.normalsNeedUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tcomputeFlatVertexNormals: function () {\\n\\n\\t\\t\\tvar f, fl, face;\\n\\n\\t\\t\\tthis.computeFaceNormals();\\n\\n\\t\\t\\tfor ( f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\tface = this.faces[ f ];\\n\\n\\t\\t\\t\\tvar vertexNormals = face.vertexNormals;\\n\\n\\t\\t\\t\\tif ( vertexNormals.length === 3 ) {\\n\\n\\t\\t\\t\\t\\tvertexNormals[ 0 ].copy( face.normal );\\n\\t\\t\\t\\t\\tvertexNormals[ 1 ].copy( face.normal );\\n\\t\\t\\t\\t\\tvertexNormals[ 2 ].copy( face.normal );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tvertexNormals[ 0 ] = face.normal.clone();\\n\\t\\t\\t\\t\\tvertexNormals[ 1 ] = face.normal.clone();\\n\\t\\t\\t\\t\\tvertexNormals[ 2 ] = face.normal.clone();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.faces.length > 0 ) {\\n\\n\\t\\t\\t\\tthis.normalsNeedUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tcomputeMorphNormals: function () {\\n\\n\\t\\t\\tvar i, il, f, fl, face;\\n\\n\\t\\t\\t// save original normals\\n\\t\\t\\t// - create temp variables on first access\\n\\t\\t\\t//   otherwise just copy (for faster repeated calls)\\n\\n\\t\\t\\tfor ( f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\tface = this.faces[ f ];\\n\\n\\t\\t\\t\\tif ( ! face.__originalFaceNormal ) {\\n\\n\\t\\t\\t\\t\\tface.__originalFaceNormal = face.normal.clone();\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tface.__originalFaceNormal.copy( face.normal );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( ! face.__originalVertexNormals ) face.__originalVertexNormals = [];\\n\\n\\t\\t\\t\\tfor ( i = 0, il = face.vertexNormals.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tif ( ! face.__originalVertexNormals[ i ] ) {\\n\\n\\t\\t\\t\\t\\t\\tface.__originalVertexNormals[ i ] = face.vertexNormals[ i ].clone();\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tface.__originalVertexNormals[ i ].copy( face.vertexNormals[ i ] );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// use temp geometry to compute face and vertex normals for each morph\\n\\n\\t\\t\\tvar tmpGeo = new Geometry();\\n\\t\\t\\ttmpGeo.faces = this.faces;\\n\\n\\t\\t\\tfor ( i = 0, il = this.morphTargets.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t// create on first access\\n\\n\\t\\t\\t\\tif ( ! this.morphNormals[ i ] ) {\\n\\n\\t\\t\\t\\t\\tthis.morphNormals[ i ] = {};\\n\\t\\t\\t\\t\\tthis.morphNormals[ i ].faceNormals = [];\\n\\t\\t\\t\\t\\tthis.morphNormals[ i ].vertexNormals = [];\\n\\n\\t\\t\\t\\t\\tvar dstNormalsFace = this.morphNormals[ i ].faceNormals;\\n\\t\\t\\t\\t\\tvar dstNormalsVertex = this.morphNormals[ i ].vertexNormals;\\n\\n\\t\\t\\t\\t\\tvar faceNormal, vertexNormals;\\n\\n\\t\\t\\t\\t\\tfor ( f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tfaceNormal = new Vector3();\\n\\t\\t\\t\\t\\t\\tvertexNormals = { a: new Vector3(), b: new Vector3(), c: new Vector3() };\\n\\n\\t\\t\\t\\t\\t\\tdstNormalsFace.push( faceNormal );\\n\\t\\t\\t\\t\\t\\tdstNormalsVertex.push( vertexNormals );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar morphNormals = this.morphNormals[ i ];\\n\\n\\t\\t\\t\\t// set vertices to morph target\\n\\n\\t\\t\\t\\ttmpGeo.vertices = this.morphTargets[ i ].vertices;\\n\\n\\t\\t\\t\\t// compute morph normals\\n\\n\\t\\t\\t\\ttmpGeo.computeFaceNormals();\\n\\t\\t\\t\\ttmpGeo.computeVertexNormals();\\n\\n\\t\\t\\t\\t// store morph normals\\n\\n\\t\\t\\t\\tvar faceNormal, vertexNormals;\\n\\n\\t\\t\\t\\tfor ( f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\t\\tface = this.faces[ f ];\\n\\n\\t\\t\\t\\t\\tfaceNormal = morphNormals.faceNormals[ f ];\\n\\t\\t\\t\\t\\tvertexNormals = morphNormals.vertexNormals[ f ];\\n\\n\\t\\t\\t\\t\\tfaceNormal.copy( face.normal );\\n\\n\\t\\t\\t\\t\\tvertexNormals.a.copy( face.vertexNormals[ 0 ] );\\n\\t\\t\\t\\t\\tvertexNormals.b.copy( face.vertexNormals[ 1 ] );\\n\\t\\t\\t\\t\\tvertexNormals.c.copy( face.vertexNormals[ 2 ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// restore original normals\\n\\n\\t\\t\\tfor ( f = 0, fl = this.faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\tface = this.faces[ f ];\\n\\n\\t\\t\\t\\tface.normal = face.__originalFaceNormal;\\n\\t\\t\\t\\tface.vertexNormals = face.__originalVertexNormals;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tcomputeLineDistances: function () {\\n\\n\\t\\t\\tvar d = 0;\\n\\t\\t\\tvar vertices = this.vertices;\\n\\n\\t\\t\\tfor ( var i = 0, il = vertices.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tif ( i > 0 ) {\\n\\n\\t\\t\\t\\t\\td += vertices[ i ].distanceTo( vertices[ i - 1 ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.lineDistances[ i ] = d;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tcomputeBoundingBox: function () {\\n\\n\\t\\t\\tif ( this.boundingBox === null ) {\\n\\n\\t\\t\\t\\tthis.boundingBox = new Box3();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.boundingBox.setFromPoints( this.vertices );\\n\\n\\t\\t},\\n\\n\\t\\tcomputeBoundingSphere: function () {\\n\\n\\t\\t\\tif ( this.boundingSphere === null ) {\\n\\n\\t\\t\\t\\tthis.boundingSphere = new Sphere();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.boundingSphere.setFromPoints( this.vertices );\\n\\n\\t\\t},\\n\\n\\t\\tmerge: function ( geometry, matrix, materialIndexOffset ) {\\n\\n\\t\\t\\tif ( ! ( geometry && geometry.isGeometry ) ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.', geometry );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar normalMatrix,\\n\\t\\t\\t\\tvertexOffset = this.vertices.length,\\n\\t\\t\\t\\tvertices1 = this.vertices,\\n\\t\\t\\t\\tvertices2 = geometry.vertices,\\n\\t\\t\\t\\tfaces1 = this.faces,\\n\\t\\t\\t\\tfaces2 = geometry.faces,\\n\\t\\t\\t\\tuvs1 = this.faceVertexUvs[ 0 ],\\n\\t\\t\\t\\tuvs2 = geometry.faceVertexUvs[ 0 ],\\n\\t\\t\\t\\tcolors1 = this.colors,\\n\\t\\t\\t\\tcolors2 = geometry.colors;\\n\\n\\t\\t\\tif ( materialIndexOffset === undefined ) materialIndexOffset = 0;\\n\\n\\t\\t\\tif ( matrix !== undefined ) {\\n\\n\\t\\t\\t\\tnormalMatrix = new Matrix3().getNormalMatrix( matrix );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// vertices\\n\\n\\t\\t\\tfor ( var i = 0, il = vertices2.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar vertex = vertices2[ i ];\\n\\n\\t\\t\\t\\tvar vertexCopy = vertex.clone();\\n\\n\\t\\t\\t\\tif ( matrix !== undefined ) vertexCopy.applyMatrix4( matrix );\\n\\n\\t\\t\\t\\tvertices1.push( vertexCopy );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// colors\\n\\n\\t\\t\\tfor ( var i = 0, il = colors2.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tcolors1.push( colors2[ i ].clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// faces\\n\\n\\t\\t\\tfor ( i = 0, il = faces2.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar face = faces2[ i ], faceCopy, normal, color,\\n\\t\\t\\t\\t\\tfaceVertexNormals = face.vertexNormals,\\n\\t\\t\\t\\t\\tfaceVertexColors = face.vertexColors;\\n\\n\\t\\t\\t\\tfaceCopy = new Face3( face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset );\\n\\t\\t\\t\\tfaceCopy.normal.copy( face.normal );\\n\\n\\t\\t\\t\\tif ( normalMatrix !== undefined ) {\\n\\n\\t\\t\\t\\t\\tfaceCopy.normal.applyMatrix3( normalMatrix ).normalize();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfor ( var j = 0, jl = faceVertexNormals.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\tnormal = faceVertexNormals[ j ].clone();\\n\\n\\t\\t\\t\\t\\tif ( normalMatrix !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tnormal.applyMatrix3( normalMatrix ).normalize();\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tfaceCopy.vertexNormals.push( normal );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfaceCopy.color.copy( face.color );\\n\\n\\t\\t\\t\\tfor ( var j = 0, jl = faceVertexColors.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\tcolor = faceVertexColors[ j ];\\n\\t\\t\\t\\t\\tfaceCopy.vertexColors.push( color.clone() );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfaceCopy.materialIndex = face.materialIndex + materialIndexOffset;\\n\\n\\t\\t\\t\\tfaces1.push( faceCopy );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// uvs\\n\\n\\t\\t\\tfor ( i = 0, il = uvs2.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar uv = uvs2[ i ], uvCopy = [];\\n\\n\\t\\t\\t\\tif ( uv === undefined ) {\\n\\n\\t\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfor ( var j = 0, jl = uv.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\tuvCopy.push( uv[ j ].clone() );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tuvs1.push( uvCopy );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tmergeMesh: function ( mesh ) {\\n\\n\\t\\t\\tif ( ! ( mesh && mesh.isMesh ) ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.', mesh );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tmesh.matrixAutoUpdate && mesh.updateMatrix();\\n\\n\\t\\t\\tthis.merge( mesh.geometry, mesh.matrix );\\n\\n\\t\\t},\\n\\n\\t\\t/*\\n\\t\\t * Checks for duplicate vertices with hashmap.\\n\\t\\t * Duplicated vertices are removed\\n\\t\\t * and faces' vertices are updated.\\n\\t\\t */\\n\\n\\t\\tmergeVertices: function () {\\n\\n\\t\\t\\tvar verticesMap = {}; // Hashmap for looking up vertices by position coordinates (and making sure they are unique)\\n\\t\\t\\tvar unique = [], changes = [];\\n\\n\\t\\t\\tvar v, key;\\n\\t\\t\\tvar precisionPoints = 4; // number of decimal points, e.g. 4 for epsilon of 0.0001\\n\\t\\t\\tvar precision = Math.pow( 10, precisionPoints );\\n\\t\\t\\tvar i, il, face;\\n\\t\\t\\tvar indices, j, jl;\\n\\n\\t\\t\\tfor ( i = 0, il = this.vertices.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tv = this.vertices[ i ];\\n\\t\\t\\t\\tkey = Math.round( v.x * precision ) + '_' + Math.round( v.y * precision ) + '_' + Math.round( v.z * precision );\\n\\n\\t\\t\\t\\tif ( verticesMap[ key ] === undefined ) {\\n\\n\\t\\t\\t\\t\\tverticesMap[ key ] = i;\\n\\t\\t\\t\\t\\tunique.push( this.vertices[ i ] );\\n\\t\\t\\t\\t\\tchanges[ i ] = unique.length - 1;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t//console.log('Duplicate vertex found. ', i, ' could be using ', verticesMap[key]);\\n\\t\\t\\t\\t\\tchanges[ i ] = changes[ verticesMap[ key ] ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\n\\t\\t\\t// if faces are completely degenerate after merging vertices, we\\n\\t\\t\\t// have to remove them from the geometry.\\n\\t\\t\\tvar faceIndicesToRemove = [];\\n\\n\\t\\t\\tfor ( i = 0, il = this.faces.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tface = this.faces[ i ];\\n\\n\\t\\t\\t\\tface.a = changes[ face.a ];\\n\\t\\t\\t\\tface.b = changes[ face.b ];\\n\\t\\t\\t\\tface.c = changes[ face.c ];\\n\\n\\t\\t\\t\\tindices = [ face.a, face.b, face.c ];\\n\\n\\t\\t\\t\\t// if any duplicate vertices are found in a Face3\\n\\t\\t\\t\\t// we have to remove the face as nothing can be saved\\n\\t\\t\\t\\tfor ( var n = 0; n < 3; n ++ ) {\\n\\n\\t\\t\\t\\t\\tif ( indices[ n ] === indices[ ( n + 1 ) % 3 ] ) {\\n\\n\\t\\t\\t\\t\\t\\tfaceIndicesToRemove.push( i );\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( i = faceIndicesToRemove.length - 1; i >= 0; i -- ) {\\n\\n\\t\\t\\t\\tvar idx = faceIndicesToRemove[ i ];\\n\\n\\t\\t\\t\\tthis.faces.splice( idx, 1 );\\n\\n\\t\\t\\t\\tfor ( j = 0, jl = this.faceVertexUvs.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\tthis.faceVertexUvs[ j ].splice( idx, 1 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Use unique set of vertices\\n\\n\\t\\t\\tvar diff = this.vertices.length - unique.length;\\n\\t\\t\\tthis.vertices = unique;\\n\\t\\t\\treturn diff;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromPoints: function ( points ) {\\n\\n\\t\\t\\tthis.vertices = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = points.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar point = points[ i ];\\n\\t\\t\\t\\tthis.vertices.push( new Vector3( point.x, point.y, point.z || 0 ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsortFacesByMaterialIndex: function () {\\n\\n\\t\\t\\tvar faces = this.faces;\\n\\t\\t\\tvar length = faces.length;\\n\\n\\t\\t\\t// tag faces\\n\\n\\t\\t\\tfor ( var i = 0; i < length; i ++ ) {\\n\\n\\t\\t\\t\\tfaces[ i ]._id = i;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// sort faces\\n\\n\\t\\t\\tfunction materialIndexSort( a, b ) {\\n\\n\\t\\t\\t\\treturn a.materialIndex - b.materialIndex;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfaces.sort( materialIndexSort );\\n\\n\\t\\t\\t// sort uvs\\n\\n\\t\\t\\tvar uvs1 = this.faceVertexUvs[ 0 ];\\n\\t\\t\\tvar uvs2 = this.faceVertexUvs[ 1 ];\\n\\n\\t\\t\\tvar newUvs1, newUvs2;\\n\\n\\t\\t\\tif ( uvs1 && uvs1.length === length ) newUvs1 = [];\\n\\t\\t\\tif ( uvs2 && uvs2.length === length ) newUvs2 = [];\\n\\n\\t\\t\\tfor ( var i = 0; i < length; i ++ ) {\\n\\n\\t\\t\\t\\tvar id = faces[ i ]._id;\\n\\n\\t\\t\\t\\tif ( newUvs1 ) newUvs1.push( uvs1[ id ] );\\n\\t\\t\\t\\tif ( newUvs2 ) newUvs2.push( uvs2[ id ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( newUvs1 ) this.faceVertexUvs[ 0 ] = newUvs1;\\n\\t\\t\\tif ( newUvs2 ) this.faceVertexUvs[ 1 ] = newUvs2;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function () {\\n\\n\\t\\t\\tvar data = {\\n\\t\\t\\t\\tmetadata: {\\n\\t\\t\\t\\t\\tversion: 4.5,\\n\\t\\t\\t\\t\\ttype: 'Geometry',\\n\\t\\t\\t\\t\\tgenerator: 'Geometry.toJSON'\\n\\t\\t\\t\\t}\\n\\t\\t\\t};\\n\\n\\t\\t\\t// standard Geometry serialization\\n\\n\\t\\t\\tdata.uuid = this.uuid;\\n\\t\\t\\tdata.type = this.type;\\n\\t\\t\\tif ( this.name !== '' ) data.name = this.name;\\n\\n\\t\\t\\tif ( this.parameters !== undefined ) {\\n\\n\\t\\t\\t\\tvar parameters = this.parameters;\\n\\n\\t\\t\\t\\tfor ( var key in parameters ) {\\n\\n\\t\\t\\t\\t\\tif ( parameters[ key ] !== undefined ) data[ key ] = parameters[ key ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn data;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar vertices = [];\\n\\n\\t\\t\\tfor ( var i = 0; i < this.vertices.length; i ++ ) {\\n\\n\\t\\t\\t\\tvar vertex = this.vertices[ i ];\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar faces = [];\\n\\t\\t\\tvar normals = [];\\n\\t\\t\\tvar normalsHash = {};\\n\\t\\t\\tvar colors = [];\\n\\t\\t\\tvar colorsHash = {};\\n\\t\\t\\tvar uvs = [];\\n\\t\\t\\tvar uvsHash = {};\\n\\n\\t\\t\\tfor ( var i = 0; i < this.faces.length; i ++ ) {\\n\\n\\t\\t\\t\\tvar face = this.faces[ i ];\\n\\n\\t\\t\\t\\tvar hasMaterial = true;\\n\\t\\t\\t\\tvar hasFaceUv = false; // deprecated\\n\\t\\t\\t\\tvar hasFaceVertexUv = this.faceVertexUvs[ 0 ][ i ] !== undefined;\\n\\t\\t\\t\\tvar hasFaceNormal = face.normal.length() > 0;\\n\\t\\t\\t\\tvar hasFaceVertexNormal = face.vertexNormals.length > 0;\\n\\t\\t\\t\\tvar hasFaceColor = face.color.r !== 1 || face.color.g !== 1 || face.color.b !== 1;\\n\\t\\t\\t\\tvar hasFaceVertexColor = face.vertexColors.length > 0;\\n\\n\\t\\t\\t\\tvar faceType = 0;\\n\\n\\t\\t\\t\\tfaceType = setBit( faceType, 0, 0 ); // isQuad\\n\\t\\t\\t\\tfaceType = setBit( faceType, 1, hasMaterial );\\n\\t\\t\\t\\tfaceType = setBit( faceType, 2, hasFaceUv );\\n\\t\\t\\t\\tfaceType = setBit( faceType, 3, hasFaceVertexUv );\\n\\t\\t\\t\\tfaceType = setBit( faceType, 4, hasFaceNormal );\\n\\t\\t\\t\\tfaceType = setBit( faceType, 5, hasFaceVertexNormal );\\n\\t\\t\\t\\tfaceType = setBit( faceType, 6, hasFaceColor );\\n\\t\\t\\t\\tfaceType = setBit( faceType, 7, hasFaceVertexColor );\\n\\n\\t\\t\\t\\tfaces.push( faceType );\\n\\t\\t\\t\\tfaces.push( face.a, face.b, face.c );\\n\\t\\t\\t\\tfaces.push( face.materialIndex );\\n\\n\\t\\t\\t\\tif ( hasFaceVertexUv ) {\\n\\n\\t\\t\\t\\t\\tvar faceVertexUvs = this.faceVertexUvs[ 0 ][ i ];\\n\\n\\t\\t\\t\\t\\tfaces.push(\\n\\t\\t\\t\\t\\t\\tgetUvIndex( faceVertexUvs[ 0 ] ),\\n\\t\\t\\t\\t\\t\\tgetUvIndex( faceVertexUvs[ 1 ] ),\\n\\t\\t\\t\\t\\t\\tgetUvIndex( faceVertexUvs[ 2 ] )\\n\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( hasFaceNormal ) {\\n\\n\\t\\t\\t\\t\\tfaces.push( getNormalIndex( face.normal ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( hasFaceVertexNormal ) {\\n\\n\\t\\t\\t\\t\\tvar vertexNormals = face.vertexNormals;\\n\\n\\t\\t\\t\\t\\tfaces.push(\\n\\t\\t\\t\\t\\t\\tgetNormalIndex( vertexNormals[ 0 ] ),\\n\\t\\t\\t\\t\\t\\tgetNormalIndex( vertexNormals[ 1 ] ),\\n\\t\\t\\t\\t\\t\\tgetNormalIndex( vertexNormals[ 2 ] )\\n\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( hasFaceColor ) {\\n\\n\\t\\t\\t\\t\\tfaces.push( getColorIndex( face.color ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( hasFaceVertexColor ) {\\n\\n\\t\\t\\t\\t\\tvar vertexColors = face.vertexColors;\\n\\n\\t\\t\\t\\t\\tfaces.push(\\n\\t\\t\\t\\t\\t\\tgetColorIndex( vertexColors[ 0 ] ),\\n\\t\\t\\t\\t\\t\\tgetColorIndex( vertexColors[ 1 ] ),\\n\\t\\t\\t\\t\\t\\tgetColorIndex( vertexColors[ 2 ] )\\n\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction setBit( value, position, enabled ) {\\n\\n\\t\\t\\t\\treturn enabled ? value | ( 1 << position ) : value & ( ~ ( 1 << position ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction getNormalIndex( normal ) {\\n\\n\\t\\t\\t\\tvar hash = normal.x.toString() + normal.y.toString() + normal.z.toString();\\n\\n\\t\\t\\t\\tif ( normalsHash[ hash ] !== undefined ) {\\n\\n\\t\\t\\t\\t\\treturn normalsHash[ hash ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tnormalsHash[ hash ] = normals.length / 3;\\n\\t\\t\\t\\tnormals.push( normal.x, normal.y, normal.z );\\n\\n\\t\\t\\t\\treturn normalsHash[ hash ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction getColorIndex( color ) {\\n\\n\\t\\t\\t\\tvar hash = color.r.toString() + color.g.toString() + color.b.toString();\\n\\n\\t\\t\\t\\tif ( colorsHash[ hash ] !== undefined ) {\\n\\n\\t\\t\\t\\t\\treturn colorsHash[ hash ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tcolorsHash[ hash ] = colors.length;\\n\\t\\t\\t\\tcolors.push( color.getHex() );\\n\\n\\t\\t\\t\\treturn colorsHash[ hash ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction getUvIndex( uv ) {\\n\\n\\t\\t\\t\\tvar hash = uv.x.toString() + uv.y.toString();\\n\\n\\t\\t\\t\\tif ( uvsHash[ hash ] !== undefined ) {\\n\\n\\t\\t\\t\\t\\treturn uvsHash[ hash ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tuvsHash[ hash ] = uvs.length / 2;\\n\\t\\t\\t\\tuvs.push( uv.x, uv.y );\\n\\n\\t\\t\\t\\treturn uvsHash[ hash ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tdata.data = {};\\n\\n\\t\\t\\tdata.data.vertices = vertices;\\n\\t\\t\\tdata.data.normals = normals;\\n\\t\\t\\tif ( colors.length > 0 ) data.data.colors = colors;\\n\\t\\t\\tif ( uvs.length > 0 ) data.data.uvs = [ uvs ]; // temporal backward compatibility\\n\\t\\t\\tdata.data.faces = faces;\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\t/*\\n\\t\\t\\t // Handle primitives\\n\\n\\t\\t\\t var parameters = this.parameters;\\n\\n\\t\\t\\t if ( parameters !== undefined ) {\\n\\n\\t\\t\\t var values = [];\\n\\n\\t\\t\\t for ( var key in parameters ) {\\n\\n\\t\\t\\t values.push( parameters[ key ] );\\n\\n\\t\\t\\t }\\n\\n\\t\\t\\t var geometry = Object.create( this.constructor.prototype );\\n\\t\\t\\t this.constructor.apply( geometry, values );\\n\\t\\t\\t return geometry;\\n\\n\\t\\t\\t }\\n\\n\\t\\t\\t return new this.constructor().copy( this );\\n\\t\\t\\t */\\n\\n\\t\\t\\treturn new Geometry().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tvar i, il, j, jl, k, kl;\\n\\n\\t\\t\\t// reset\\n\\n\\t\\t\\tthis.vertices = [];\\n\\t\\t\\tthis.colors = [];\\n\\t\\t\\tthis.faces = [];\\n\\t\\t\\tthis.faceVertexUvs = [[]];\\n\\t\\t\\tthis.morphTargets = [];\\n\\t\\t\\tthis.morphNormals = [];\\n\\t\\t\\tthis.skinWeights = [];\\n\\t\\t\\tthis.skinIndices = [];\\n\\t\\t\\tthis.lineDistances = [];\\n\\t\\t\\tthis.boundingBox = null;\\n\\t\\t\\tthis.boundingSphere = null;\\n\\n\\t\\t\\t// name\\n\\n\\t\\t\\tthis.name = source.name;\\n\\n\\t\\t\\t// vertices\\n\\n\\t\\t\\tvar vertices = source.vertices;\\n\\n\\t\\t\\tfor ( i = 0, il = vertices.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.vertices.push( vertices[ i ].clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// colors\\n\\n\\t\\t\\tvar colors = source.colors;\\n\\n\\t\\t\\tfor ( i = 0, il = colors.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.colors.push( colors[ i ].clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// faces\\n\\n\\t\\t\\tvar faces = source.faces;\\n\\n\\t\\t\\tfor ( i = 0, il = faces.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.faces.push( faces[ i ].clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// face vertex uvs\\n\\n\\t\\t\\tfor ( i = 0, il = source.faceVertexUvs.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar faceVertexUvs = source.faceVertexUvs[ i ];\\n\\n\\t\\t\\t\\tif ( this.faceVertexUvs[ i ] === undefined ) {\\n\\n\\t\\t\\t\\t\\tthis.faceVertexUvs[ i ] = [];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfor ( j = 0, jl = faceVertexUvs.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\tvar uvs = faceVertexUvs[ j ], uvsCopy = [];\\n\\n\\t\\t\\t\\t\\tfor ( k = 0, kl = uvs.length; k < kl; k ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar uv = uvs[ k ];\\n\\n\\t\\t\\t\\t\\t\\tuvsCopy.push( uv.clone() );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tthis.faceVertexUvs[ i ].push( uvsCopy );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// morph targets\\n\\n\\t\\t\\tvar morphTargets = source.morphTargets;\\n\\n\\t\\t\\tfor ( i = 0, il = morphTargets.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar morphTarget = {};\\n\\t\\t\\t\\tmorphTarget.name = morphTargets[ i ].name;\\n\\n\\t\\t\\t\\t// vertices\\n\\n\\t\\t\\t\\tif ( morphTargets[ i ].vertices !== undefined ) {\\n\\n\\t\\t\\t\\t\\tmorphTarget.vertices = [];\\n\\n\\t\\t\\t\\t\\tfor ( j = 0, jl = morphTargets[ i ].vertices.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tmorphTarget.vertices.push( morphTargets[ i ].vertices[ j ].clone() );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// normals\\n\\n\\t\\t\\t\\tif ( morphTargets[ i ].normals !== undefined ) {\\n\\n\\t\\t\\t\\t\\tmorphTarget.normals = [];\\n\\n\\t\\t\\t\\t\\tfor ( j = 0, jl = morphTargets[ i ].normals.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tmorphTarget.normals.push( morphTargets[ i ].normals[ j ].clone() );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.morphTargets.push( morphTarget );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// morph normals\\n\\n\\t\\t\\tvar morphNormals = source.morphNormals;\\n\\n\\t\\t\\tfor ( i = 0, il = morphNormals.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar morphNormal = {};\\n\\n\\t\\t\\t\\t// vertex normals\\n\\n\\t\\t\\t\\tif ( morphNormals[ i ].vertexNormals !== undefined ) {\\n\\n\\t\\t\\t\\t\\tmorphNormal.vertexNormals = [];\\n\\n\\t\\t\\t\\t\\tfor ( j = 0, jl = morphNormals[ i ].vertexNormals.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar srcVertexNormal = morphNormals[ i ].vertexNormals[ j ];\\n\\t\\t\\t\\t\\t\\tvar destVertexNormal = {};\\n\\n\\t\\t\\t\\t\\t\\tdestVertexNormal.a = srcVertexNormal.a.clone();\\n\\t\\t\\t\\t\\t\\tdestVertexNormal.b = srcVertexNormal.b.clone();\\n\\t\\t\\t\\t\\t\\tdestVertexNormal.c = srcVertexNormal.c.clone();\\n\\n\\t\\t\\t\\t\\t\\tmorphNormal.vertexNormals.push( destVertexNormal );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// face normals\\n\\n\\t\\t\\t\\tif ( morphNormals[ i ].faceNormals !== undefined ) {\\n\\n\\t\\t\\t\\t\\tmorphNormal.faceNormals = [];\\n\\n\\t\\t\\t\\t\\tfor ( j = 0, jl = morphNormals[ i ].faceNormals.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tmorphNormal.faceNormals.push( morphNormals[ i ].faceNormals[ j ].clone() );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.morphNormals.push( morphNormal );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// skin weights\\n\\n\\t\\t\\tvar skinWeights = source.skinWeights;\\n\\n\\t\\t\\tfor ( i = 0, il = skinWeights.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.skinWeights.push( skinWeights[ i ].clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// skin indices\\n\\n\\t\\t\\tvar skinIndices = source.skinIndices;\\n\\n\\t\\t\\tfor ( i = 0, il = skinIndices.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.skinIndices.push( skinIndices[ i ].clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// line distances\\n\\n\\t\\t\\tvar lineDistances = source.lineDistances;\\n\\n\\t\\t\\tfor ( i = 0, il = lineDistances.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tthis.lineDistances.push( lineDistances[ i ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// bounding box\\n\\n\\t\\t\\tvar boundingBox = source.boundingBox;\\n\\n\\t\\t\\tif ( boundingBox !== null ) {\\n\\n\\t\\t\\t\\tthis.boundingBox = boundingBox.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// bounding sphere\\n\\n\\t\\t\\tvar boundingSphere = source.boundingSphere;\\n\\n\\t\\t\\tif ( boundingSphere !== null ) {\\n\\n\\t\\t\\t\\tthis.boundingSphere = boundingSphere.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// update flags\\n\\n\\t\\t\\tthis.elementsNeedUpdate = source.elementsNeedUpdate;\\n\\t\\t\\tthis.verticesNeedUpdate = source.verticesNeedUpdate;\\n\\t\\t\\tthis.uvsNeedUpdate = source.uvsNeedUpdate;\\n\\t\\t\\tthis.normalsNeedUpdate = source.normalsNeedUpdate;\\n\\t\\t\\tthis.colorsNeedUpdate = source.colorsNeedUpdate;\\n\\t\\t\\tthis.lineDistancesNeedUpdate = source.lineDistancesNeedUpdate;\\n\\t\\t\\tthis.groupsNeedUpdate = source.groupsNeedUpdate;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdispose: function () {\\n\\n\\t\\t\\tthis.dispatchEvent( { type: 'dispose' } );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tif ( Array.isArray( array ) ) {\\n\\n\\t\\t\\tthrow new TypeError( 'THREE.BufferAttribute: array should be a Typed Array.' );\\n\\n\\t\\t}\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\t\\tthis.name = '';\\n\\n\\t\\tthis.array = array;\\n\\t\\tthis.itemSize = itemSize;\\n\\t\\tthis.count = array !== undefined ? array.length / itemSize : 0;\\n\\t\\tthis.normalized = normalized === true;\\n\\n\\t\\tthis.dynamic = false;\\n\\t\\tthis.updateRange = { offset: 0, count: - 1 };\\n\\n\\t\\tthis.onUploadCallback = function () {};\\n\\n\\t\\tthis.version = 0;\\n\\n\\t}\\n\\n\\tObject.defineProperty( BufferAttribute.prototype, 'needsUpdate', {\\n\\n\\t\\tset: function ( value ) {\\n\\n\\t\\t\\tif ( value === true ) this.version ++;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( BufferAttribute.prototype, {\\n\\n\\t\\tisBufferAttribute: true,\\n\\n\\t\\tsetArray: function ( array ) {\\n\\n\\t\\t\\tif ( Array.isArray( array ) ) {\\n\\n\\t\\t\\t\\tthrow new TypeError( 'THREE.BufferAttribute: array should be a Typed Array.' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.count = array !== undefined ? array.length / this.itemSize : 0;\\n\\t\\t\\tthis.array = array;\\n\\n\\t\\t},\\n\\n\\t\\tsetDynamic: function ( value ) {\\n\\n\\t\\t\\tthis.dynamic = value;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tthis.array = new source.array.constructor( source.array );\\n\\t\\t\\tthis.itemSize = source.itemSize;\\n\\t\\t\\tthis.count = source.count;\\n\\t\\t\\tthis.normalized = source.normalized;\\n\\n\\t\\t\\tthis.dynamic = source.dynamic;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyAt: function ( index1, attribute, index2 ) {\\n\\n\\t\\t\\tindex1 *= this.itemSize;\\n\\t\\t\\tindex2 *= attribute.itemSize;\\n\\n\\t\\t\\tfor ( var i = 0, l = this.itemSize; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tthis.array[ index1 + i ] = attribute.array[ index2 + i ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyArray: function ( array ) {\\n\\n\\t\\t\\tthis.array.set( array );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyColorsArray: function ( colors ) {\\n\\n\\t\\t\\tvar array = this.array, offset = 0;\\n\\n\\t\\t\\tfor ( var i = 0, l = colors.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar color = colors[ i ];\\n\\n\\t\\t\\t\\tif ( color === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.BufferAttribute.copyColorsArray(): color is undefined', i );\\n\\t\\t\\t\\t\\tcolor = new Color();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tarray[ offset ++ ] = color.r;\\n\\t\\t\\t\\tarray[ offset ++ ] = color.g;\\n\\t\\t\\t\\tarray[ offset ++ ] = color.b;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyIndicesArray: function ( indices ) {\\n\\n\\t\\t\\tvar array = this.array, offset = 0;\\n\\n\\t\\t\\tfor ( var i = 0, l = indices.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar index = indices[ i ];\\n\\n\\t\\t\\t\\tarray[ offset ++ ] = index.a;\\n\\t\\t\\t\\tarray[ offset ++ ] = index.b;\\n\\t\\t\\t\\tarray[ offset ++ ] = index.c;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyVector2sArray: function ( vectors ) {\\n\\n\\t\\t\\tvar array = this.array, offset = 0;\\n\\n\\t\\t\\tfor ( var i = 0, l = vectors.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar vector = vectors[ i ];\\n\\n\\t\\t\\t\\tif ( vector === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.BufferAttribute.copyVector2sArray(): vector is undefined', i );\\n\\t\\t\\t\\t\\tvector = new Vector2();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.x;\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.y;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyVector3sArray: function ( vectors ) {\\n\\n\\t\\t\\tvar array = this.array, offset = 0;\\n\\n\\t\\t\\tfor ( var i = 0, l = vectors.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar vector = vectors[ i ];\\n\\n\\t\\t\\t\\tif ( vector === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.BufferAttribute.copyVector3sArray(): vector is undefined', i );\\n\\t\\t\\t\\t\\tvector = new Vector3();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.x;\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.y;\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.z;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyVector4sArray: function ( vectors ) {\\n\\n\\t\\t\\tvar array = this.array, offset = 0;\\n\\n\\t\\t\\tfor ( var i = 0, l = vectors.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar vector = vectors[ i ];\\n\\n\\t\\t\\t\\tif ( vector === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.BufferAttribute.copyVector4sArray(): vector is undefined', i );\\n\\t\\t\\t\\t\\tvector = new Vector4();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.x;\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.y;\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.z;\\n\\t\\t\\t\\tarray[ offset ++ ] = vector.w;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tset: function ( value, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tthis.array.set( value, offset );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetX: function ( index ) {\\n\\n\\t\\t\\treturn this.array[ index * this.itemSize ];\\n\\n\\t\\t},\\n\\n\\t\\tsetX: function ( index, x ) {\\n\\n\\t\\t\\tthis.array[ index * this.itemSize ] = x;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetY: function ( index ) {\\n\\n\\t\\t\\treturn this.array[ index * this.itemSize + 1 ];\\n\\n\\t\\t},\\n\\n\\t\\tsetY: function ( index, y ) {\\n\\n\\t\\t\\tthis.array[ index * this.itemSize + 1 ] = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetZ: function ( index ) {\\n\\n\\t\\t\\treturn this.array[ index * this.itemSize + 2 ];\\n\\n\\t\\t},\\n\\n\\t\\tsetZ: function ( index, z ) {\\n\\n\\t\\t\\tthis.array[ index * this.itemSize + 2 ] = z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetW: function ( index ) {\\n\\n\\t\\t\\treturn this.array[ index * this.itemSize + 3 ];\\n\\n\\t\\t},\\n\\n\\t\\tsetW: function ( index, w ) {\\n\\n\\t\\t\\tthis.array[ index * this.itemSize + 3 ] = w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetXY: function ( index, x, y ) {\\n\\n\\t\\t\\tindex *= this.itemSize;\\n\\n\\t\\t\\tthis.array[ index + 0 ] = x;\\n\\t\\t\\tthis.array[ index + 1 ] = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetXYZ: function ( index, x, y, z ) {\\n\\n\\t\\t\\tindex *= this.itemSize;\\n\\n\\t\\t\\tthis.array[ index + 0 ] = x;\\n\\t\\t\\tthis.array[ index + 1 ] = y;\\n\\t\\t\\tthis.array[ index + 2 ] = z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetXYZW: function ( index, x, y, z, w ) {\\n\\n\\t\\t\\tindex *= this.itemSize;\\n\\n\\t\\t\\tthis.array[ index + 0 ] = x;\\n\\t\\t\\tthis.array[ index + 1 ] = y;\\n\\t\\t\\tthis.array[ index + 2 ] = z;\\n\\t\\t\\tthis.array[ index + 3 ] = w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tonUpload: function ( callback ) {\\n\\n\\t\\t\\tthis.onUploadCallback = callback;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.array, this.itemSize ).copy( this );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tfunction Int8BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Int8Array( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tInt8BufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tInt8BufferAttribute.prototype.constructor = Int8BufferAttribute;\\n\\n\\n\\tfunction Uint8BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Uint8Array( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tUint8BufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tUint8BufferAttribute.prototype.constructor = Uint8BufferAttribute;\\n\\n\\n\\tfunction Uint8ClampedBufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Uint8ClampedArray( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tUint8ClampedBufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tUint8ClampedBufferAttribute.prototype.constructor = Uint8ClampedBufferAttribute;\\n\\n\\n\\tfunction Int16BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Int16Array( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tInt16BufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tInt16BufferAttribute.prototype.constructor = Int16BufferAttribute;\\n\\n\\n\\tfunction Uint16BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Uint16Array( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tUint16BufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tUint16BufferAttribute.prototype.constructor = Uint16BufferAttribute;\\n\\n\\n\\tfunction Int32BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Int32Array( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tInt32BufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tInt32BufferAttribute.prototype.constructor = Int32BufferAttribute;\\n\\n\\n\\tfunction Uint32BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Uint32Array( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tUint32BufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tUint32BufferAttribute.prototype.constructor = Uint32BufferAttribute;\\n\\n\\n\\tfunction Float32BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Float32Array( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tFloat32BufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tFloat32BufferAttribute.prototype.constructor = Float32BufferAttribute;\\n\\n\\n\\tfunction Float64BufferAttribute( array, itemSize, normalized ) {\\n\\n\\t\\tBufferAttribute.call( this, new Float64Array( array ), itemSize, normalized );\\n\\n\\t}\\n\\n\\tFloat64BufferAttribute.prototype = Object.create( BufferAttribute.prototype );\\n\\tFloat64BufferAttribute.prototype.constructor = Float64BufferAttribute;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction DirectGeometry() {\\n\\n\\t\\tthis.indices = [];\\n\\t\\tthis.vertices = [];\\n\\t\\tthis.normals = [];\\n\\t\\tthis.colors = [];\\n\\t\\tthis.uvs = [];\\n\\t\\tthis.uvs2 = [];\\n\\n\\t\\tthis.groups = [];\\n\\n\\t\\tthis.morphTargets = {};\\n\\n\\t\\tthis.skinWeights = [];\\n\\t\\tthis.skinIndices = [];\\n\\n\\t\\t// this.lineDistances = [];\\n\\n\\t\\tthis.boundingBox = null;\\n\\t\\tthis.boundingSphere = null;\\n\\n\\t\\t// update flags\\n\\n\\t\\tthis.verticesNeedUpdate = false;\\n\\t\\tthis.normalsNeedUpdate = false;\\n\\t\\tthis.colorsNeedUpdate = false;\\n\\t\\tthis.uvsNeedUpdate = false;\\n\\t\\tthis.groupsNeedUpdate = false;\\n\\n\\t}\\n\\n\\tObject.assign( DirectGeometry.prototype, {\\n\\n\\t\\tcomputeGroups: function ( geometry ) {\\n\\n\\t\\t\\tvar group;\\n\\t\\t\\tvar groups = [];\\n\\t\\t\\tvar materialIndex = undefined;\\n\\n\\t\\t\\tvar faces = geometry.faces;\\n\\n\\t\\t\\tfor ( var i = 0; i < faces.length; i ++ ) {\\n\\n\\t\\t\\t\\tvar face = faces[ i ];\\n\\n\\t\\t\\t\\t// materials\\n\\n\\t\\t\\t\\tif ( face.materialIndex !== materialIndex ) {\\n\\n\\t\\t\\t\\t\\tmaterialIndex = face.materialIndex;\\n\\n\\t\\t\\t\\t\\tif ( group !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tgroup.count = ( i * 3 ) - group.start;\\n\\t\\t\\t\\t\\t\\tgroups.push( group );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tgroup = {\\n\\t\\t\\t\\t\\t\\tstart: i * 3,\\n\\t\\t\\t\\t\\t\\tmaterialIndex: materialIndex\\n\\t\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( group !== undefined ) {\\n\\n\\t\\t\\t\\tgroup.count = ( i * 3 ) - group.start;\\n\\t\\t\\t\\tgroups.push( group );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.groups = groups;\\n\\n\\t\\t},\\n\\n\\t\\tfromGeometry: function ( geometry ) {\\n\\n\\t\\t\\tvar faces = geometry.faces;\\n\\t\\t\\tvar vertices = geometry.vertices;\\n\\t\\t\\tvar faceVertexUvs = geometry.faceVertexUvs;\\n\\n\\t\\t\\tvar hasFaceVertexUv = faceVertexUvs[ 0 ] && faceVertexUvs[ 0 ].length > 0;\\n\\t\\t\\tvar hasFaceVertexUv2 = faceVertexUvs[ 1 ] && faceVertexUvs[ 1 ].length > 0;\\n\\n\\t\\t\\t// morphs\\n\\n\\t\\t\\tvar morphTargets = geometry.morphTargets;\\n\\t\\t\\tvar morphTargetsLength = morphTargets.length;\\n\\n\\t\\t\\tvar morphTargetsPosition;\\n\\n\\t\\t\\tif ( morphTargetsLength > 0 ) {\\n\\n\\t\\t\\t\\tmorphTargetsPosition = [];\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < morphTargetsLength; i ++ ) {\\n\\n\\t\\t\\t\\t\\tmorphTargetsPosition[ i ] = [];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.morphTargets.position = morphTargetsPosition;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar morphNormals = geometry.morphNormals;\\n\\t\\t\\tvar morphNormalsLength = morphNormals.length;\\n\\n\\t\\t\\tvar morphTargetsNormal;\\n\\n\\t\\t\\tif ( morphNormalsLength > 0 ) {\\n\\n\\t\\t\\t\\tmorphTargetsNormal = [];\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < morphNormalsLength; i ++ ) {\\n\\n\\t\\t\\t\\t\\tmorphTargetsNormal[ i ] = [];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.morphTargets.normal = morphTargetsNormal;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// skins\\n\\n\\t\\t\\tvar skinIndices = geometry.skinIndices;\\n\\t\\t\\tvar skinWeights = geometry.skinWeights;\\n\\n\\t\\t\\tvar hasSkinIndices = skinIndices.length === vertices.length;\\n\\t\\t\\tvar hasSkinWeights = skinWeights.length === vertices.length;\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tfor ( var i = 0; i < faces.length; i ++ ) {\\n\\n\\t\\t\\t\\tvar face = faces[ i ];\\n\\n\\t\\t\\t\\tthis.vertices.push( vertices[ face.a ], vertices[ face.b ], vertices[ face.c ] );\\n\\n\\t\\t\\t\\tvar vertexNormals = face.vertexNormals;\\n\\n\\t\\t\\t\\tif ( vertexNormals.length === 3 ) {\\n\\n\\t\\t\\t\\t\\tthis.normals.push( vertexNormals[ 0 ], vertexNormals[ 1 ], vertexNormals[ 2 ] );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tvar normal = face.normal;\\n\\n\\t\\t\\t\\t\\tthis.normals.push( normal, normal, normal );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar vertexColors = face.vertexColors;\\n\\n\\t\\t\\t\\tif ( vertexColors.length === 3 ) {\\n\\n\\t\\t\\t\\t\\tthis.colors.push( vertexColors[ 0 ], vertexColors[ 1 ], vertexColors[ 2 ] );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tvar color = face.color;\\n\\n\\t\\t\\t\\t\\tthis.colors.push( color, color, color );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( hasFaceVertexUv === true ) {\\n\\n\\t\\t\\t\\t\\tvar vertexUvs = faceVertexUvs[ 0 ][ i ];\\n\\n\\t\\t\\t\\t\\tif ( vertexUvs !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tthis.uvs.push( vertexUvs[ 0 ], vertexUvs[ 1 ], vertexUvs[ 2 ] );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.DirectGeometry.fromGeometry(): Undefined vertexUv ', i );\\n\\n\\t\\t\\t\\t\\t\\tthis.uvs.push( new Vector2(), new Vector2(), new Vector2() );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( hasFaceVertexUv2 === true ) {\\n\\n\\t\\t\\t\\t\\tvar vertexUvs = faceVertexUvs[ 1 ][ i ];\\n\\n\\t\\t\\t\\t\\tif ( vertexUvs !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tthis.uvs2.push( vertexUvs[ 0 ], vertexUvs[ 1 ], vertexUvs[ 2 ] );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.DirectGeometry.fromGeometry(): Undefined vertexUv2 ', i );\\n\\n\\t\\t\\t\\t\\t\\tthis.uvs2.push( new Vector2(), new Vector2(), new Vector2() );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// morphs\\n\\n\\t\\t\\t\\tfor ( var j = 0; j < morphTargetsLength; j ++ ) {\\n\\n\\t\\t\\t\\t\\tvar morphTarget = morphTargets[ j ].vertices;\\n\\n\\t\\t\\t\\t\\tmorphTargetsPosition[ j ].push( morphTarget[ face.a ], morphTarget[ face.b ], morphTarget[ face.c ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfor ( var j = 0; j < morphNormalsLength; j ++ ) {\\n\\n\\t\\t\\t\\t\\tvar morphNormal = morphNormals[ j ].vertexNormals[ i ];\\n\\n\\t\\t\\t\\t\\tmorphTargetsNormal[ j ].push( morphNormal.a, morphNormal.b, morphNormal.c );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// skins\\n\\n\\t\\t\\t\\tif ( hasSkinIndices ) {\\n\\n\\t\\t\\t\\t\\tthis.skinIndices.push( skinIndices[ face.a ], skinIndices[ face.b ], skinIndices[ face.c ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( hasSkinWeights ) {\\n\\n\\t\\t\\t\\t\\tthis.skinWeights.push( skinWeights[ face.a ], skinWeights[ face.b ], skinWeights[ face.c ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.computeGroups( geometry );\\n\\n\\t\\t\\tthis.verticesNeedUpdate = geometry.verticesNeedUpdate;\\n\\t\\t\\tthis.normalsNeedUpdate = geometry.normalsNeedUpdate;\\n\\t\\t\\tthis.colorsNeedUpdate = geometry.colorsNeedUpdate;\\n\\t\\t\\tthis.uvsNeedUpdate = geometry.uvsNeedUpdate;\\n\\t\\t\\tthis.groupsNeedUpdate = geometry.groupsNeedUpdate;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction arrayMax( array ) {\\n\\n\\t\\tif ( array.length === 0 ) return - Infinity;\\n\\n\\t\\tvar max = array[ 0 ];\\n\\n\\t\\tfor ( var i = 1, l = array.length; i < l; ++ i ) {\\n\\n\\t\\t\\tif ( array[ i ] > max ) max = array[ i ];\\n\\n\\t\\t}\\n\\n\\t\\treturn max;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tvar bufferGeometryId = 1; // BufferGeometry uses odd numbers as Id\\n\\n\\tfunction BufferGeometry() {\\n\\n\\t\\tObject.defineProperty( this, 'id', { value: bufferGeometryId += 2 } );\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.name = '';\\n\\t\\tthis.type = 'BufferGeometry';\\n\\n\\t\\tthis.index = null;\\n\\t\\tthis.attributes = {};\\n\\n\\t\\tthis.morphAttributes = {};\\n\\n\\t\\tthis.groups = [];\\n\\n\\t\\tthis.boundingBox = null;\\n\\t\\tthis.boundingSphere = null;\\n\\n\\t\\tthis.drawRange = { start: 0, count: Infinity };\\n\\n\\t}\\n\\n\\tBufferGeometry.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {\\n\\n\\t\\tconstructor: BufferGeometry,\\n\\n\\t\\tisBufferGeometry: true,\\n\\n\\t\\tgetIndex: function () {\\n\\n\\t\\t\\treturn this.index;\\n\\n\\t\\t},\\n\\n\\t\\tsetIndex: function ( index ) {\\n\\n\\t\\t\\tif ( Array.isArray( index ) ) {\\n\\n\\t\\t\\t\\tthis.index = new ( arrayMax( index ) > 65535 ? Uint32BufferAttribute : Uint16BufferAttribute )( index, 1 );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.index = index;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\taddAttribute: function ( name, attribute ) {\\n\\n\\t\\t\\tif ( ! ( attribute && attribute.isBufferAttribute ) && ! ( attribute && attribute.isInterleavedBufferAttribute ) ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.BufferGeometry: .addAttribute() now expects ( name, attribute ).' );\\n\\n\\t\\t\\t\\tthis.addAttribute( name, new BufferAttribute( arguments[ 1 ], arguments[ 2 ] ) );\\n\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( name === 'index' ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute.' );\\n\\t\\t\\t\\tthis.setIndex( attribute );\\n\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.attributes[ name ] = attribute;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetAttribute: function ( name ) {\\n\\n\\t\\t\\treturn this.attributes[ name ];\\n\\n\\t\\t},\\n\\n\\t\\tremoveAttribute: function ( name ) {\\n\\n\\t\\t\\tdelete this.attributes[ name ];\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddGroup: function ( start, count, materialIndex ) {\\n\\n\\t\\t\\tthis.groups.push( {\\n\\n\\t\\t\\t\\tstart: start,\\n\\t\\t\\t\\tcount: count,\\n\\t\\t\\t\\tmaterialIndex: materialIndex !== undefined ? materialIndex : 0\\n\\n\\t\\t\\t} );\\n\\n\\t\\t},\\n\\n\\t\\tclearGroups: function () {\\n\\n\\t\\t\\tthis.groups = [];\\n\\n\\t\\t},\\n\\n\\t\\tsetDrawRange: function ( start, count ) {\\n\\n\\t\\t\\tthis.drawRange.start = start;\\n\\t\\t\\tthis.drawRange.count = count;\\n\\n\\t\\t},\\n\\n\\t\\tapplyMatrix: function ( matrix ) {\\n\\n\\t\\t\\tvar position = this.attributes.position;\\n\\n\\t\\t\\tif ( position !== undefined ) {\\n\\n\\t\\t\\t\\tmatrix.applyToBufferAttribute( position );\\n\\t\\t\\t\\tposition.needsUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar normal = this.attributes.normal;\\n\\n\\t\\t\\tif ( normal !== undefined ) {\\n\\n\\t\\t\\t\\tvar normalMatrix = new Matrix3().getNormalMatrix( matrix );\\n\\n\\t\\t\\t\\tnormalMatrix.applyToBufferAttribute( normal );\\n\\t\\t\\t\\tnormal.needsUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.boundingBox !== null ) {\\n\\n\\t\\t\\t\\tthis.computeBoundingBox();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.boundingSphere !== null ) {\\n\\n\\t\\t\\t\\tthis.computeBoundingSphere();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\trotateX: function () {\\n\\n\\t\\t\\t// rotate geometry around world x-axis\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function rotateX( angle ) {\\n\\n\\t\\t\\t\\tm1.makeRotationX( angle );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\trotateY: function () {\\n\\n\\t\\t\\t// rotate geometry around world y-axis\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function rotateY( angle ) {\\n\\n\\t\\t\\t\\tm1.makeRotationY( angle );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\trotateZ: function () {\\n\\n\\t\\t\\t// rotate geometry around world z-axis\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function rotateZ( angle ) {\\n\\n\\t\\t\\t\\tm1.makeRotationZ( angle );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttranslate: function () {\\n\\n\\t\\t\\t// translate geometry\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function translate( x, y, z ) {\\n\\n\\t\\t\\t\\tm1.makeTranslation( x, y, z );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tscale: function () {\\n\\n\\t\\t\\t// scale geometry\\n\\n\\t\\t\\tvar m1 = new Matrix4();\\n\\n\\t\\t\\treturn function scale( x, y, z ) {\\n\\n\\t\\t\\t\\tm1.makeScale( x, y, z );\\n\\n\\t\\t\\t\\tthis.applyMatrix( m1 );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tlookAt: function () {\\n\\n\\t\\t\\tvar obj = new Object3D();\\n\\n\\t\\t\\treturn function lookAt( vector ) {\\n\\n\\t\\t\\t\\tobj.lookAt( vector );\\n\\n\\t\\t\\t\\tobj.updateMatrix();\\n\\n\\t\\t\\t\\tthis.applyMatrix( obj.matrix );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tcenter: function () {\\n\\n\\t\\t\\tthis.computeBoundingBox();\\n\\n\\t\\t\\tvar offset = this.boundingBox.getCenter().negate();\\n\\n\\t\\t\\tthis.translate( offset.x, offset.y, offset.z );\\n\\n\\t\\t\\treturn offset;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromObject: function ( object ) {\\n\\n\\t\\t\\t// console.log( 'THREE.BufferGeometry.setFromObject(). Converting', object, this );\\n\\n\\t\\t\\tvar geometry = object.geometry;\\n\\n\\t\\t\\tif ( object.isPoints || object.isLine ) {\\n\\n\\t\\t\\t\\tvar positions = new Float32BufferAttribute( geometry.vertices.length * 3, 3 );\\n\\t\\t\\t\\tvar colors = new Float32BufferAttribute( geometry.colors.length * 3, 3 );\\n\\n\\t\\t\\t\\tthis.addAttribute( 'position', positions.copyVector3sArray( geometry.vertices ) );\\n\\t\\t\\t\\tthis.addAttribute( 'color', colors.copyColorsArray( geometry.colors ) );\\n\\n\\t\\t\\t\\tif ( geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length ) {\\n\\n\\t\\t\\t\\t\\tvar lineDistances = new Float32BufferAttribute( geometry.lineDistances.length, 1 );\\n\\n\\t\\t\\t\\t\\tthis.addAttribute( 'lineDistance', lineDistances.copyArray( geometry.lineDistances ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( geometry.boundingSphere !== null ) {\\n\\n\\t\\t\\t\\t\\tthis.boundingSphere = geometry.boundingSphere.clone();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( geometry.boundingBox !== null ) {\\n\\n\\t\\t\\t\\t\\tthis.boundingBox = geometry.boundingBox.clone();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( object.isMesh ) {\\n\\n\\t\\t\\t\\tif ( geometry && geometry.isGeometry ) {\\n\\n\\t\\t\\t\\t\\tthis.fromGeometry( geometry );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromPoints: function ( points ) {\\n\\n\\t\\t\\tvar position = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = points.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar point = points[ i ];\\n\\t\\t\\t\\tposition.push( point.x, point.y, point.z || 0 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( position, 3 ) );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tupdateFromObject: function ( object ) {\\n\\n\\t\\t\\tvar geometry = object.geometry;\\n\\n\\t\\t\\tif ( object.isMesh ) {\\n\\n\\t\\t\\t\\tvar direct = geometry.__directGeometry;\\n\\n\\t\\t\\t\\tif ( geometry.elementsNeedUpdate === true ) {\\n\\n\\t\\t\\t\\t\\tdirect = undefined;\\n\\t\\t\\t\\t\\tgeometry.elementsNeedUpdate = false;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( direct === undefined ) {\\n\\n\\t\\t\\t\\t\\treturn this.fromGeometry( geometry );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tdirect.verticesNeedUpdate = geometry.verticesNeedUpdate;\\n\\t\\t\\t\\tdirect.normalsNeedUpdate = geometry.normalsNeedUpdate;\\n\\t\\t\\t\\tdirect.colorsNeedUpdate = geometry.colorsNeedUpdate;\\n\\t\\t\\t\\tdirect.uvsNeedUpdate = geometry.uvsNeedUpdate;\\n\\t\\t\\t\\tdirect.groupsNeedUpdate = geometry.groupsNeedUpdate;\\n\\n\\t\\t\\t\\tgeometry.verticesNeedUpdate = false;\\n\\t\\t\\t\\tgeometry.normalsNeedUpdate = false;\\n\\t\\t\\t\\tgeometry.colorsNeedUpdate = false;\\n\\t\\t\\t\\tgeometry.uvsNeedUpdate = false;\\n\\t\\t\\t\\tgeometry.groupsNeedUpdate = false;\\n\\n\\t\\t\\t\\tgeometry = direct;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar attribute;\\n\\n\\t\\t\\tif ( geometry.verticesNeedUpdate === true ) {\\n\\n\\t\\t\\t\\tattribute = this.attributes.position;\\n\\n\\t\\t\\t\\tif ( attribute !== undefined ) {\\n\\n\\t\\t\\t\\t\\tattribute.copyVector3sArray( geometry.vertices );\\n\\t\\t\\t\\t\\tattribute.needsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometry.verticesNeedUpdate = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.normalsNeedUpdate === true ) {\\n\\n\\t\\t\\t\\tattribute = this.attributes.normal;\\n\\n\\t\\t\\t\\tif ( attribute !== undefined ) {\\n\\n\\t\\t\\t\\t\\tattribute.copyVector3sArray( geometry.normals );\\n\\t\\t\\t\\t\\tattribute.needsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometry.normalsNeedUpdate = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.colorsNeedUpdate === true ) {\\n\\n\\t\\t\\t\\tattribute = this.attributes.color;\\n\\n\\t\\t\\t\\tif ( attribute !== undefined ) {\\n\\n\\t\\t\\t\\t\\tattribute.copyColorsArray( geometry.colors );\\n\\t\\t\\t\\t\\tattribute.needsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometry.colorsNeedUpdate = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.uvsNeedUpdate ) {\\n\\n\\t\\t\\t\\tattribute = this.attributes.uv;\\n\\n\\t\\t\\t\\tif ( attribute !== undefined ) {\\n\\n\\t\\t\\t\\t\\tattribute.copyVector2sArray( geometry.uvs );\\n\\t\\t\\t\\t\\tattribute.needsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometry.uvsNeedUpdate = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.lineDistancesNeedUpdate ) {\\n\\n\\t\\t\\t\\tattribute = this.attributes.lineDistance;\\n\\n\\t\\t\\t\\tif ( attribute !== undefined ) {\\n\\n\\t\\t\\t\\t\\tattribute.copyArray( geometry.lineDistances );\\n\\t\\t\\t\\t\\tattribute.needsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometry.lineDistancesNeedUpdate = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.groupsNeedUpdate ) {\\n\\n\\t\\t\\t\\tgeometry.computeGroups( object.geometry );\\n\\t\\t\\t\\tthis.groups = geometry.groups;\\n\\n\\t\\t\\t\\tgeometry.groupsNeedUpdate = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tfromGeometry: function ( geometry ) {\\n\\n\\t\\t\\tgeometry.__directGeometry = new DirectGeometry().fromGeometry( geometry );\\n\\n\\t\\t\\treturn this.fromDirectGeometry( geometry.__directGeometry );\\n\\n\\t\\t},\\n\\n\\t\\tfromDirectGeometry: function ( geometry ) {\\n\\n\\t\\t\\tvar positions = new Float32Array( geometry.vertices.length * 3 );\\n\\t\\t\\tthis.addAttribute( 'position', new BufferAttribute( positions, 3 ).copyVector3sArray( geometry.vertices ) );\\n\\n\\t\\t\\tif ( geometry.normals.length > 0 ) {\\n\\n\\t\\t\\t\\tvar normals = new Float32Array( geometry.normals.length * 3 );\\n\\t\\t\\t\\tthis.addAttribute( 'normal', new BufferAttribute( normals, 3 ).copyVector3sArray( geometry.normals ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.colors.length > 0 ) {\\n\\n\\t\\t\\t\\tvar colors = new Float32Array( geometry.colors.length * 3 );\\n\\t\\t\\t\\tthis.addAttribute( 'color', new BufferAttribute( colors, 3 ).copyColorsArray( geometry.colors ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.uvs.length > 0 ) {\\n\\n\\t\\t\\t\\tvar uvs = new Float32Array( geometry.uvs.length * 2 );\\n\\t\\t\\t\\tthis.addAttribute( 'uv', new BufferAttribute( uvs, 2 ).copyVector2sArray( geometry.uvs ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.uvs2.length > 0 ) {\\n\\n\\t\\t\\t\\tvar uvs2 = new Float32Array( geometry.uvs2.length * 2 );\\n\\t\\t\\t\\tthis.addAttribute( 'uv2', new BufferAttribute( uvs2, 2 ).copyVector2sArray( geometry.uvs2 ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.indices.length > 0 ) {\\n\\n\\t\\t\\t\\tvar TypeArray = arrayMax( geometry.indices ) > 65535 ? Uint32Array : Uint16Array;\\n\\t\\t\\t\\tvar indices = new TypeArray( geometry.indices.length * 3 );\\n\\t\\t\\t\\tthis.setIndex( new BufferAttribute( indices, 1 ).copyIndicesArray( geometry.indices ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// groups\\n\\n\\t\\t\\tthis.groups = geometry.groups;\\n\\n\\t\\t\\t// morphs\\n\\n\\t\\t\\tfor ( var name in geometry.morphTargets ) {\\n\\n\\t\\t\\t\\tvar array = [];\\n\\t\\t\\t\\tvar morphTargets = geometry.morphTargets[ name ];\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = morphTargets.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar morphTarget = morphTargets[ i ];\\n\\n\\t\\t\\t\\t\\tvar attribute = new Float32BufferAttribute( morphTarget.length * 3, 3 );\\n\\n\\t\\t\\t\\t\\tarray.push( attribute.copyVector3sArray( morphTarget ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.morphAttributes[ name ] = array;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// skinning\\n\\n\\t\\t\\tif ( geometry.skinIndices.length > 0 ) {\\n\\n\\t\\t\\t\\tvar skinIndices = new Float32BufferAttribute( geometry.skinIndices.length * 4, 4 );\\n\\t\\t\\t\\tthis.addAttribute( 'skinIndex', skinIndices.copyVector4sArray( geometry.skinIndices ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.skinWeights.length > 0 ) {\\n\\n\\t\\t\\t\\tvar skinWeights = new Float32BufferAttribute( geometry.skinWeights.length * 4, 4 );\\n\\t\\t\\t\\tthis.addAttribute( 'skinWeight', skinWeights.copyVector4sArray( geometry.skinWeights ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tif ( geometry.boundingSphere !== null ) {\\n\\n\\t\\t\\t\\tthis.boundingSphere = geometry.boundingSphere.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry.boundingBox !== null ) {\\n\\n\\t\\t\\t\\tthis.boundingBox = geometry.boundingBox.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcomputeBoundingBox: function () {\\n\\n\\t\\t\\tif ( this.boundingBox === null ) {\\n\\n\\t\\t\\t\\tthis.boundingBox = new Box3();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar position = this.attributes.position;\\n\\n\\t\\t\\tif ( position !== undefined ) {\\n\\n\\t\\t\\t\\tthis.boundingBox.setFromBufferAttribute( position );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.boundingBox.makeEmpty();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( isNaN( this.boundingBox.min.x ) || isNaN( this.boundingBox.min.y ) || isNaN( this.boundingBox.min.z ) ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.BufferGeometry.computeBoundingBox: Computed min/max have NaN values. The \\\"position\\\" attribute is likely to have NaN values.', this );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tcomputeBoundingSphere: function () {\\n\\n\\t\\t\\tvar box = new Box3();\\n\\t\\t\\tvar vector = new Vector3();\\n\\n\\t\\t\\treturn function computeBoundingSphere() {\\n\\n\\t\\t\\t\\tif ( this.boundingSphere === null ) {\\n\\n\\t\\t\\t\\t\\tthis.boundingSphere = new Sphere();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar position = this.attributes.position;\\n\\n\\t\\t\\t\\tif ( position ) {\\n\\n\\t\\t\\t\\t\\tvar center = this.boundingSphere.center;\\n\\n\\t\\t\\t\\t\\tbox.setFromBufferAttribute( position );\\n\\t\\t\\t\\t\\tbox.getCenter( center );\\n\\n\\t\\t\\t\\t\\t// hoping to find a boundingSphere with a radius smaller than the\\n\\t\\t\\t\\t\\t// boundingSphere of the boundingBox: sqrt(3) smaller in the best case\\n\\n\\t\\t\\t\\t\\tvar maxRadiusSq = 0;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, il = position.count; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvector.x = position.getX( i );\\n\\t\\t\\t\\t\\t\\tvector.y = position.getY( i );\\n\\t\\t\\t\\t\\t\\tvector.z = position.getZ( i );\\n\\t\\t\\t\\t\\t\\tmaxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( vector ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tthis.boundingSphere.radius = Math.sqrt( maxRadiusSq );\\n\\n\\t\\t\\t\\t\\tif ( isNaN( this.boundingSphere.radius ) ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The \\\"position\\\" attribute is likely to have NaN values.', this );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tcomputeFaceNormals: function () {\\n\\n\\t\\t\\t// backwards compatibility\\n\\n\\t\\t},\\n\\n\\t\\tcomputeVertexNormals: function () {\\n\\n\\t\\t\\tvar index = this.index;\\n\\t\\t\\tvar attributes = this.attributes;\\n\\t\\t\\tvar groups = this.groups;\\n\\n\\t\\t\\tif ( attributes.position ) {\\n\\n\\t\\t\\t\\tvar positions = attributes.position.array;\\n\\n\\t\\t\\t\\tif ( attributes.normal === undefined ) {\\n\\n\\t\\t\\t\\t\\tthis.addAttribute( 'normal', new BufferAttribute( new Float32Array( positions.length ), 3 ) );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// reset existing normals to zero\\n\\n\\t\\t\\t\\t\\tvar array = attributes.normal.array;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, il = array.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tarray[ i ] = 0;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar normals = attributes.normal.array;\\n\\n\\t\\t\\t\\tvar vA, vB, vC;\\n\\t\\t\\t\\tvar pA = new Vector3(), pB = new Vector3(), pC = new Vector3();\\n\\t\\t\\t\\tvar cb = new Vector3(), ab = new Vector3();\\n\\n\\t\\t\\t\\t// indexed elements\\n\\n\\t\\t\\t\\tif ( index ) {\\n\\n\\t\\t\\t\\t\\tvar indices = index.array;\\n\\n\\t\\t\\t\\t\\tif ( groups.length === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tthis.addGroup( 0, indices.length );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tfor ( var j = 0, jl = groups.length; j < jl; ++ j ) {\\n\\n\\t\\t\\t\\t\\t\\tvar group = groups[ j ];\\n\\n\\t\\t\\t\\t\\t\\tvar start = group.start;\\n\\t\\t\\t\\t\\t\\tvar count = group.count;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = start, il = start + count; i < il; i += 3 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvA = indices[ i + 0 ] * 3;\\n\\t\\t\\t\\t\\t\\t\\tvB = indices[ i + 1 ] * 3;\\n\\t\\t\\t\\t\\t\\t\\tvC = indices[ i + 2 ] * 3;\\n\\n\\t\\t\\t\\t\\t\\t\\tpA.fromArray( positions, vA );\\n\\t\\t\\t\\t\\t\\t\\tpB.fromArray( positions, vB );\\n\\t\\t\\t\\t\\t\\t\\tpC.fromArray( positions, vC );\\n\\n\\t\\t\\t\\t\\t\\t\\tcb.subVectors( pC, pB );\\n\\t\\t\\t\\t\\t\\t\\tab.subVectors( pA, pB );\\n\\t\\t\\t\\t\\t\\t\\tcb.cross( ab );\\n\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vA ] += cb.x;\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vA + 1 ] += cb.y;\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vA + 2 ] += cb.z;\\n\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vB ] += cb.x;\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vB + 1 ] += cb.y;\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vB + 2 ] += cb.z;\\n\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vC ] += cb.x;\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vC + 1 ] += cb.y;\\n\\t\\t\\t\\t\\t\\t\\tnormals[ vC + 2 ] += cb.z;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// non-indexed elements (unconnected triangle soup)\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, il = positions.length; i < il; i += 9 ) {\\n\\n\\t\\t\\t\\t\\t\\tpA.fromArray( positions, i );\\n\\t\\t\\t\\t\\t\\tpB.fromArray( positions, i + 3 );\\n\\t\\t\\t\\t\\t\\tpC.fromArray( positions, i + 6 );\\n\\n\\t\\t\\t\\t\\t\\tcb.subVectors( pC, pB );\\n\\t\\t\\t\\t\\t\\tab.subVectors( pA, pB );\\n\\t\\t\\t\\t\\t\\tcb.cross( ab );\\n\\n\\t\\t\\t\\t\\t\\tnormals[ i ] = cb.x;\\n\\t\\t\\t\\t\\t\\tnormals[ i + 1 ] = cb.y;\\n\\t\\t\\t\\t\\t\\tnormals[ i + 2 ] = cb.z;\\n\\n\\t\\t\\t\\t\\t\\tnormals[ i + 3 ] = cb.x;\\n\\t\\t\\t\\t\\t\\tnormals[ i + 4 ] = cb.y;\\n\\t\\t\\t\\t\\t\\tnormals[ i + 5 ] = cb.z;\\n\\n\\t\\t\\t\\t\\t\\tnormals[ i + 6 ] = cb.x;\\n\\t\\t\\t\\t\\t\\tnormals[ i + 7 ] = cb.y;\\n\\t\\t\\t\\t\\t\\tnormals[ i + 8 ] = cb.z;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.normalizeNormals();\\n\\n\\t\\t\\t\\tattributes.normal.needsUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tmerge: function ( geometry, offset ) {\\n\\n\\t\\t\\tif ( ! ( geometry && geometry.isBufferGeometry ) ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.', geometry );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tvar attributes = this.attributes;\\n\\n\\t\\t\\tfor ( var key in attributes ) {\\n\\n\\t\\t\\t\\tif ( geometry.attributes[ key ] === undefined ) continue;\\n\\n\\t\\t\\t\\tvar attribute1 = attributes[ key ];\\n\\t\\t\\t\\tvar attributeArray1 = attribute1.array;\\n\\n\\t\\t\\t\\tvar attribute2 = geometry.attributes[ key ];\\n\\t\\t\\t\\tvar attributeArray2 = attribute2.array;\\n\\n\\t\\t\\t\\tvar attributeSize = attribute2.itemSize;\\n\\n\\t\\t\\t\\tfor ( var i = 0, j = attributeSize * offset; i < attributeArray2.length; i ++, j ++ ) {\\n\\n\\t\\t\\t\\t\\tattributeArray1[ j ] = attributeArray2[ i ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tnormalizeNormals: function () {\\n\\n\\t\\t\\tvar vector = new Vector3();\\n\\n\\t\\t\\treturn function normalizeNormals() {\\n\\n\\t\\t\\t\\tvar normals = this.attributes.normal;\\n\\n\\t\\t\\t\\tfor ( var i = 0, il = normals.count; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvector.x = normals.getX( i );\\n\\t\\t\\t\\t\\tvector.y = normals.getY( i );\\n\\t\\t\\t\\t\\tvector.z = normals.getZ( i );\\n\\n\\t\\t\\t\\t\\tvector.normalize();\\n\\n\\t\\t\\t\\t\\tnormals.setXYZ( i, vector.x, vector.y, vector.z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttoNonIndexed: function () {\\n\\n\\t\\t\\tif ( this.index === null ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.BufferGeometry.toNonIndexed(): Geometry is already non-indexed.' );\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar geometry2 = new BufferGeometry();\\n\\n\\t\\t\\tvar indices = this.index.array;\\n\\t\\t\\tvar attributes = this.attributes;\\n\\n\\t\\t\\tfor ( var name in attributes ) {\\n\\n\\t\\t\\t\\tvar attribute = attributes[ name ];\\n\\n\\t\\t\\t\\tvar array = attribute.array;\\n\\t\\t\\t\\tvar itemSize = attribute.itemSize;\\n\\n\\t\\t\\t\\tvar array2 = new array.constructor( indices.length * itemSize );\\n\\n\\t\\t\\t\\tvar index = 0, index2 = 0;\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = indices.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tindex = indices[ i ] * itemSize;\\n\\n\\t\\t\\t\\t\\tfor ( var j = 0; j < itemSize; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tarray2[ index2 ++ ] = array[ index ++ ];\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometry2.addAttribute( name, new BufferAttribute( array2, itemSize ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn geometry2;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function () {\\n\\n\\t\\t\\tvar data = {\\n\\t\\t\\t\\tmetadata: {\\n\\t\\t\\t\\t\\tversion: 4.5,\\n\\t\\t\\t\\t\\ttype: 'BufferGeometry',\\n\\t\\t\\t\\t\\tgenerator: 'BufferGeometry.toJSON'\\n\\t\\t\\t\\t}\\n\\t\\t\\t};\\n\\n\\t\\t\\t// standard BufferGeometry serialization\\n\\n\\t\\t\\tdata.uuid = this.uuid;\\n\\t\\t\\tdata.type = this.type;\\n\\t\\t\\tif ( this.name !== '' ) data.name = this.name;\\n\\n\\t\\t\\tif ( this.parameters !== undefined ) {\\n\\n\\t\\t\\t\\tvar parameters = this.parameters;\\n\\n\\t\\t\\t\\tfor ( var key in parameters ) {\\n\\n\\t\\t\\t\\t\\tif ( parameters[ key ] !== undefined ) data[ key ] = parameters[ key ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn data;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tdata.data = { attributes: {} };\\n\\n\\t\\t\\tvar index = this.index;\\n\\n\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\tvar array = Array.prototype.slice.call( index.array );\\n\\n\\t\\t\\t\\tdata.data.index = {\\n\\t\\t\\t\\t\\ttype: index.array.constructor.name,\\n\\t\\t\\t\\t\\tarray: array\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar attributes = this.attributes;\\n\\n\\t\\t\\tfor ( var key in attributes ) {\\n\\n\\t\\t\\t\\tvar attribute = attributes[ key ];\\n\\n\\t\\t\\t\\tvar array = Array.prototype.slice.call( attribute.array );\\n\\n\\t\\t\\t\\tdata.data.attributes[ key ] = {\\n\\t\\t\\t\\t\\titemSize: attribute.itemSize,\\n\\t\\t\\t\\t\\ttype: attribute.array.constructor.name,\\n\\t\\t\\t\\t\\tarray: array,\\n\\t\\t\\t\\t\\tnormalized: attribute.normalized\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar groups = this.groups;\\n\\n\\t\\t\\tif ( groups.length > 0 ) {\\n\\n\\t\\t\\t\\tdata.data.groups = JSON.parse( JSON.stringify( groups ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar boundingSphere = this.boundingSphere;\\n\\n\\t\\t\\tif ( boundingSphere !== null ) {\\n\\n\\t\\t\\t\\tdata.data.boundingSphere = {\\n\\t\\t\\t\\t\\tcenter: boundingSphere.center.toArray(),\\n\\t\\t\\t\\t\\tradius: boundingSphere.radius\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\t/*\\n\\t\\t\\t // Handle primitives\\n\\n\\t\\t\\t var parameters = this.parameters;\\n\\n\\t\\t\\t if ( parameters !== undefined ) {\\n\\n\\t\\t\\t var values = [];\\n\\n\\t\\t\\t for ( var key in parameters ) {\\n\\n\\t\\t\\t values.push( parameters[ key ] );\\n\\n\\t\\t\\t }\\n\\n\\t\\t\\t var geometry = Object.create( this.constructor.prototype );\\n\\t\\t\\t this.constructor.apply( geometry, values );\\n\\t\\t\\t return geometry;\\n\\n\\t\\t\\t }\\n\\n\\t\\t\\t return new this.constructor().copy( this );\\n\\t\\t\\t */\\n\\n\\t\\t\\treturn new BufferGeometry().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tvar name, i, l;\\n\\n\\t\\t\\t// reset\\n\\n\\t\\t\\tthis.index = null;\\n\\t\\t\\tthis.attributes = {};\\n\\t\\t\\tthis.morphAttributes = {};\\n\\t\\t\\tthis.groups = [];\\n\\t\\t\\tthis.boundingBox = null;\\n\\t\\t\\tthis.boundingSphere = null;\\n\\n\\t\\t\\t// name\\n\\n\\t\\t\\tthis.name = source.name;\\n\\n\\t\\t\\t// index\\n\\n\\t\\t\\tvar index = source.index;\\n\\n\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\tthis.setIndex( index.clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// attributes\\n\\n\\t\\t\\tvar attributes = source.attributes;\\n\\n\\t\\t\\tfor ( name in attributes ) {\\n\\n\\t\\t\\t\\tvar attribute = attributes[ name ];\\n\\t\\t\\t\\tthis.addAttribute( name, attribute.clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// morph attributes\\n\\n\\t\\t\\tvar morphAttributes = source.morphAttributes;\\n\\n\\t\\t\\tfor ( name in morphAttributes ) {\\n\\n\\t\\t\\t\\tvar array = [];\\n\\t\\t\\t\\tvar morphAttribute = morphAttributes[ name ]; // morphAttribute: array of Float32BufferAttributes\\n\\n\\t\\t\\t\\tfor ( i = 0, l = morphAttribute.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tarray.push( morphAttribute[ i ].clone() );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.morphAttributes[ name ] = array;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// groups\\n\\n\\t\\t\\tvar groups = source.groups;\\n\\n\\t\\t\\tfor ( i = 0, l = groups.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar group = groups[ i ];\\n\\t\\t\\t\\tthis.addGroup( group.start, group.count, group.materialIndex );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// bounding box\\n\\n\\t\\t\\tvar boundingBox = source.boundingBox;\\n\\n\\t\\t\\tif ( boundingBox !== null ) {\\n\\n\\t\\t\\t\\tthis.boundingBox = boundingBox.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// bounding sphere\\n\\n\\t\\t\\tvar boundingSphere = source.boundingSphere;\\n\\n\\t\\t\\tif ( boundingSphere !== null ) {\\n\\n\\t\\t\\t\\tthis.boundingSphere = boundingSphere.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// draw range\\n\\n\\t\\t\\tthis.drawRange.start = source.drawRange.start;\\n\\t\\t\\tthis.drawRange.count = source.drawRange.count;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdispose: function () {\\n\\n\\t\\t\\tthis.dispatchEvent( { type: 'dispose' } );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// BoxGeometry\\n\\n\\tfunction BoxGeometry( width, height, depth, widthSegments, heightSegments, depthSegments ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'BoxGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\twidth: width,\\n\\t\\t\\theight: height,\\n\\t\\t\\tdepth: depth,\\n\\t\\t\\twidthSegments: widthSegments,\\n\\t\\t\\theightSegments: heightSegments,\\n\\t\\t\\tdepthSegments: depthSegments\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new BoxBufferGeometry( width, height, depth, widthSegments, heightSegments, depthSegments ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tBoxGeometry.prototype = Object.create( Geometry.prototype );\\n\\tBoxGeometry.prototype.constructor = BoxGeometry;\\n\\n\\t// BoxBufferGeometry\\n\\n\\tfunction BoxBufferGeometry( width, height, depth, widthSegments, heightSegments, depthSegments ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'BoxBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\twidth: width,\\n\\t\\t\\theight: height,\\n\\t\\t\\tdepth: depth,\\n\\t\\t\\twidthSegments: widthSegments,\\n\\t\\t\\theightSegments: heightSegments,\\n\\t\\t\\tdepthSegments: depthSegments\\n\\t\\t};\\n\\n\\t\\tvar scope = this;\\n\\n\\t\\twidth = width || 1;\\n\\t\\theight = height || 1;\\n\\t\\tdepth = depth || 1;\\n\\n\\t\\t// segments\\n\\n\\t\\twidthSegments = Math.floor( widthSegments ) || 1;\\n\\t\\theightSegments = Math.floor( heightSegments ) || 1;\\n\\t\\tdepthSegments = Math.floor( depthSegments ) || 1;\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar numberOfVertices = 0;\\n\\t\\tvar groupStart = 0;\\n\\n\\t\\t// build each side of the box geometry\\n\\n\\t\\tbuildPlane( 'z', 'y', 'x', - 1, - 1, depth, height, width, depthSegments, heightSegments, 0 ); // px\\n\\t\\tbuildPlane( 'z', 'y', 'x', 1, - 1, depth, height, - width, depthSegments, heightSegments, 1 ); // nx\\n\\t\\tbuildPlane( 'x', 'z', 'y', 1, 1, width, depth, height, widthSegments, depthSegments, 2 ); // py\\n\\t\\tbuildPlane( 'x', 'z', 'y', 1, - 1, width, depth, - height, widthSegments, depthSegments, 3 ); // ny\\n\\t\\tbuildPlane( 'x', 'y', 'z', 1, - 1, width, height, depth, widthSegments, heightSegments, 4 ); // pz\\n\\t\\tbuildPlane( 'x', 'y', 'z', - 1, - 1, width, height, - depth, widthSegments, heightSegments, 5 ); // nz\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t\\tfunction buildPlane( u, v, w, udir, vdir, width, height, depth, gridX, gridY, materialIndex ) {\\n\\n\\t\\t\\tvar segmentWidth = width / gridX;\\n\\t\\t\\tvar segmentHeight = height / gridY;\\n\\n\\t\\t\\tvar widthHalf = width / 2;\\n\\t\\t\\tvar heightHalf = height / 2;\\n\\t\\t\\tvar depthHalf = depth / 2;\\n\\n\\t\\t\\tvar gridX1 = gridX + 1;\\n\\t\\t\\tvar gridY1 = gridY + 1;\\n\\n\\t\\t\\tvar vertexCounter = 0;\\n\\t\\t\\tvar groupCount = 0;\\n\\n\\t\\t\\tvar ix, iy;\\n\\n\\t\\t\\tvar vector = new Vector3();\\n\\n\\t\\t\\t// generate vertices, normals and uvs\\n\\n\\t\\t\\tfor ( iy = 0; iy < gridY1; iy ++ ) {\\n\\n\\t\\t\\t\\tvar y = iy * segmentHeight - heightHalf;\\n\\n\\t\\t\\t\\tfor ( ix = 0; ix < gridX1; ix ++ ) {\\n\\n\\t\\t\\t\\t\\tvar x = ix * segmentWidth - widthHalf;\\n\\n\\t\\t\\t\\t\\t// set values to correct vector component\\n\\n\\t\\t\\t\\t\\tvector[ u ] = x * udir;\\n\\t\\t\\t\\t\\tvector[ v ] = y * vdir;\\n\\t\\t\\t\\t\\tvector[ w ] = depthHalf;\\n\\n\\t\\t\\t\\t\\t// now apply vector to vertex buffer\\n\\n\\t\\t\\t\\t\\tvertices.push( vector.x, vector.y, vector.z );\\n\\n\\t\\t\\t\\t\\t// set values to correct vector component\\n\\n\\t\\t\\t\\t\\tvector[ u ] = 0;\\n\\t\\t\\t\\t\\tvector[ v ] = 0;\\n\\t\\t\\t\\t\\tvector[ w ] = depth > 0 ? 1 : - 1;\\n\\n\\t\\t\\t\\t\\t// now apply vector to normal buffer\\n\\n\\t\\t\\t\\t\\tnormals.push( vector.x, vector.y, vector.z );\\n\\n\\t\\t\\t\\t\\t// uvs\\n\\n\\t\\t\\t\\t\\tuvs.push( ix / gridX );\\n\\t\\t\\t\\t\\tuvs.push( 1 - ( iy / gridY ) );\\n\\n\\t\\t\\t\\t\\t// counters\\n\\n\\t\\t\\t\\t\\tvertexCounter += 1;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// indices\\n\\n\\t\\t\\t// 1. you need three indices to draw a single face\\n\\t\\t\\t// 2. a single segment consists of two faces\\n\\t\\t\\t// 3. so we need to generate six (2*3) indices per segment\\n\\n\\t\\t\\tfor ( iy = 0; iy < gridY; iy ++ ) {\\n\\n\\t\\t\\t\\tfor ( ix = 0; ix < gridX; ix ++ ) {\\n\\n\\t\\t\\t\\t\\tvar a = numberOfVertices + ix + gridX1 * iy;\\n\\t\\t\\t\\t\\tvar b = numberOfVertices + ix + gridX1 * ( iy + 1 );\\n\\t\\t\\t\\t\\tvar c = numberOfVertices + ( ix + 1 ) + gridX1 * ( iy + 1 );\\n\\t\\t\\t\\t\\tvar d = numberOfVertices + ( ix + 1 ) + gridX1 * iy;\\n\\n\\t\\t\\t\\t\\t// faces\\n\\n\\t\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t\\t\\t// increase counter\\n\\n\\t\\t\\t\\t\\tgroupCount += 6;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// add a group to the geometry. this will ensure multi material support\\n\\n\\t\\t\\tscope.addGroup( groupStart, groupCount, materialIndex );\\n\\n\\t\\t\\t// calculate new start value for groups\\n\\n\\t\\t\\tgroupStart += groupCount;\\n\\n\\t\\t\\t// update total number of vertices\\n\\n\\t\\t\\tnumberOfVertices += vertexCounter;\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tBoxBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tBoxBufferGeometry.prototype.constructor = BoxBufferGeometry;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// PlaneGeometry\\n\\n\\tfunction PlaneGeometry( width, height, widthSegments, heightSegments ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'PlaneGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\twidth: width,\\n\\t\\t\\theight: height,\\n\\t\\t\\twidthSegments: widthSegments,\\n\\t\\t\\theightSegments: heightSegments\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new PlaneBufferGeometry( width, height, widthSegments, heightSegments ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tPlaneGeometry.prototype = Object.create( Geometry.prototype );\\n\\tPlaneGeometry.prototype.constructor = PlaneGeometry;\\n\\n\\t// PlaneBufferGeometry\\n\\n\\tfunction PlaneBufferGeometry( width, height, widthSegments, heightSegments ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'PlaneBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\twidth: width,\\n\\t\\t\\theight: height,\\n\\t\\t\\twidthSegments: widthSegments,\\n\\t\\t\\theightSegments: heightSegments\\n\\t\\t};\\n\\n\\t\\twidth = width || 1;\\n\\t\\theight = height || 1;\\n\\n\\t\\tvar width_half = width / 2;\\n\\t\\tvar height_half = height / 2;\\n\\n\\t\\tvar gridX = Math.floor( widthSegments ) || 1;\\n\\t\\tvar gridY = Math.floor( heightSegments ) || 1;\\n\\n\\t\\tvar gridX1 = gridX + 1;\\n\\t\\tvar gridY1 = gridY + 1;\\n\\n\\t\\tvar segment_width = width / gridX;\\n\\t\\tvar segment_height = height / gridY;\\n\\n\\t\\tvar ix, iy;\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// generate vertices, normals and uvs\\n\\n\\t\\tfor ( iy = 0; iy < gridY1; iy ++ ) {\\n\\n\\t\\t\\tvar y = iy * segment_height - height_half;\\n\\n\\t\\t\\tfor ( ix = 0; ix < gridX1; ix ++ ) {\\n\\n\\t\\t\\t\\tvar x = ix * segment_width - width_half;\\n\\n\\t\\t\\t\\tvertices.push( x, - y, 0 );\\n\\n\\t\\t\\t\\tnormals.push( 0, 0, 1 );\\n\\n\\t\\t\\t\\tuvs.push( ix / gridX );\\n\\t\\t\\t\\tuvs.push( 1 - ( iy / gridY ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// indices\\n\\n\\t\\tfor ( iy = 0; iy < gridY; iy ++ ) {\\n\\n\\t\\t\\tfor ( ix = 0; ix < gridX; ix ++ ) {\\n\\n\\t\\t\\t\\tvar a = ix + gridX1 * iy;\\n\\t\\t\\t\\tvar b = ix + gridX1 * ( iy + 1 );\\n\\t\\t\\t\\tvar c = ( ix + 1 ) + gridX1 * ( iy + 1 );\\n\\t\\t\\t\\tvar d = ( ix + 1 ) + gridX1 * iy;\\n\\n\\t\\t\\t\\t// faces\\n\\n\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t}\\n\\n\\tPlaneBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tPlaneBufferGeometry.prototype.constructor = PlaneBufferGeometry;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * parameters = {\\n\\t *  color: <hex>,\\n\\t *  opacity: <float>,\\n\\t *  map: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  lightMap: new THREE.Texture( <Image> ),\\n\\t *  lightMapIntensity: <float>\\n\\t *\\n\\t *  aoMap: new THREE.Texture( <Image> ),\\n\\t *  aoMapIntensity: <float>\\n\\t *\\n\\t *  specularMap: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  alphaMap: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ),\\n\\t *  combine: THREE.Multiply,\\n\\t *  reflectivity: <float>,\\n\\t *  refractionRatio: <float>,\\n\\t *\\n\\t *  depthTest: <bool>,\\n\\t *  depthWrite: <bool>,\\n\\t *\\n\\t *  wireframe: <boolean>,\\n\\t *  wireframeLinewidth: <float>,\\n\\t *\\n\\t *  skinning: <bool>,\\n\\t *  morphTargets: <bool>\\n\\t * }\\n\\t */\\n\\n\\tfunction MeshBasicMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'MeshBasicMaterial';\\n\\n\\t\\tthis.color = new Color( 0xffffff ); // emissive\\n\\n\\t\\tthis.map = null;\\n\\n\\t\\tthis.lightMap = null;\\n\\t\\tthis.lightMapIntensity = 1.0;\\n\\n\\t\\tthis.aoMap = null;\\n\\t\\tthis.aoMapIntensity = 1.0;\\n\\n\\t\\tthis.specularMap = null;\\n\\n\\t\\tthis.alphaMap = null;\\n\\n\\t\\tthis.envMap = null;\\n\\t\\tthis.combine = MultiplyOperation;\\n\\t\\tthis.reflectivity = 1;\\n\\t\\tthis.refractionRatio = 0.98;\\n\\n\\t\\tthis.wireframe = false;\\n\\t\\tthis.wireframeLinewidth = 1;\\n\\t\\tthis.wireframeLinecap = 'round';\\n\\t\\tthis.wireframeLinejoin = 'round';\\n\\n\\t\\tthis.skinning = false;\\n\\t\\tthis.morphTargets = false;\\n\\n\\t\\tthis.lights = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshBasicMaterial.prototype = Object.create( Material.prototype );\\n\\tMeshBasicMaterial.prototype.constructor = MeshBasicMaterial;\\n\\n\\tMeshBasicMaterial.prototype.isMeshBasicMaterial = true;\\n\\n\\tMeshBasicMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.color.copy( source.color );\\n\\n\\t\\tthis.map = source.map;\\n\\n\\t\\tthis.lightMap = source.lightMap;\\n\\t\\tthis.lightMapIntensity = source.lightMapIntensity;\\n\\n\\t\\tthis.aoMap = source.aoMap;\\n\\t\\tthis.aoMapIntensity = source.aoMapIntensity;\\n\\n\\t\\tthis.specularMap = source.specularMap;\\n\\n\\t\\tthis.alphaMap = source.alphaMap;\\n\\n\\t\\tthis.envMap = source.envMap;\\n\\t\\tthis.combine = source.combine;\\n\\t\\tthis.reflectivity = source.reflectivity;\\n\\t\\tthis.refractionRatio = source.refractionRatio;\\n\\n\\t\\tthis.wireframe = source.wireframe;\\n\\t\\tthis.wireframeLinewidth = source.wireframeLinewidth;\\n\\t\\tthis.wireframeLinecap = source.wireframeLinecap;\\n\\t\\tthis.wireframeLinejoin = source.wireframeLinejoin;\\n\\n\\t\\tthis.skinning = source.skinning;\\n\\t\\tthis.morphTargets = source.morphTargets;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * parameters = {\\n\\t *  defines: { \\\"label\\\" : \\\"value\\\" },\\n\\t *  uniforms: { \\\"parameter1\\\": { value: 1.0 }, \\\"parameter2\\\": { value2: 2 } },\\n\\t *\\n\\t *  fragmentShader: <string>,\\n\\t *  vertexShader: <string>,\\n\\t *\\n\\t *  wireframe: <boolean>,\\n\\t *  wireframeLinewidth: <float>,\\n\\t *\\n\\t *  lights: <bool>,\\n\\t *\\n\\t *  skinning: <bool>,\\n\\t *  morphTargets: <bool>,\\n\\t *  morphNormals: <bool>\\n\\t * }\\n\\t */\\n\\n\\tfunction ShaderMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'ShaderMaterial';\\n\\n\\t\\tthis.defines = {};\\n\\t\\tthis.uniforms = {};\\n\\n\\t\\tthis.vertexShader = 'void main() {\\\\n\\\\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\\\\n}';\\n\\t\\tthis.fragmentShader = 'void main() {\\\\n\\\\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\\\\n}';\\n\\n\\t\\tthis.linewidth = 1;\\n\\n\\t\\tthis.wireframe = false;\\n\\t\\tthis.wireframeLinewidth = 1;\\n\\n\\t\\tthis.fog = false; // set to use scene fog\\n\\t\\tthis.lights = false; // set to use scene lights\\n\\t\\tthis.clipping = false; // set to use user-defined clipping planes\\n\\n\\t\\tthis.skinning = false; // set to use skinning attribute streams\\n\\t\\tthis.morphTargets = false; // set to use morph targets\\n\\t\\tthis.morphNormals = false; // set to use morph normals\\n\\n\\t\\tthis.extensions = {\\n\\t\\t\\tderivatives: false, // set to use derivatives\\n\\t\\t\\tfragDepth: false, // set to use fragment depth values\\n\\t\\t\\tdrawBuffers: false, // set to use draw buffers\\n\\t\\t\\tshaderTextureLOD: false // set to use shader texture LOD\\n\\t\\t};\\n\\n\\t\\t// When rendered geometry doesn't include these attributes but the material does,\\n\\t\\t// use these default values in WebGL. This avoids errors when buffer data is missing.\\n\\t\\tthis.defaultAttributeValues = {\\n\\t\\t\\t'color': [ 1, 1, 1 ],\\n\\t\\t\\t'uv': [ 0, 0 ],\\n\\t\\t\\t'uv2': [ 0, 0 ]\\n\\t\\t};\\n\\n\\t\\tthis.index0AttributeName = undefined;\\n\\n\\t\\tif ( parameters !== undefined ) {\\n\\n\\t\\t\\tif ( parameters.attributes !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead.' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.setValues( parameters );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tShaderMaterial.prototype = Object.create( Material.prototype );\\n\\tShaderMaterial.prototype.constructor = ShaderMaterial;\\n\\n\\tShaderMaterial.prototype.isShaderMaterial = true;\\n\\n\\tShaderMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.fragmentShader = source.fragmentShader;\\n\\t\\tthis.vertexShader = source.vertexShader;\\n\\n\\t\\tthis.uniforms = UniformsUtils.clone( source.uniforms );\\n\\n\\t\\tthis.defines = source.defines;\\n\\n\\t\\tthis.wireframe = source.wireframe;\\n\\t\\tthis.wireframeLinewidth = source.wireframeLinewidth;\\n\\n\\t\\tthis.lights = source.lights;\\n\\t\\tthis.clipping = source.clipping;\\n\\n\\t\\tthis.skinning = source.skinning;\\n\\n\\t\\tthis.morphTargets = source.morphTargets;\\n\\t\\tthis.morphNormals = source.morphNormals;\\n\\n\\t\\tthis.extensions = source.extensions;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tShaderMaterial.prototype.toJSON = function ( meta ) {\\n\\n\\t\\tvar data = Material.prototype.toJSON.call( this, meta );\\n\\n\\t\\tdata.uniforms = this.uniforms;\\n\\t\\tdata.vertexShader = this.vertexShader;\\n\\t\\tdata.fragmentShader = this.fragmentShader;\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author bhouston / http://clara.io\\n\\t */\\n\\n\\tfunction Ray( origin, direction ) {\\n\\n\\t\\tthis.origin = ( origin !== undefined ) ? origin : new Vector3();\\n\\t\\tthis.direction = ( direction !== undefined ) ? direction : new Vector3();\\n\\n\\t}\\n\\n\\tObject.assign( Ray.prototype, {\\n\\n\\t\\tset: function ( origin, direction ) {\\n\\n\\t\\t\\tthis.origin.copy( origin );\\n\\t\\t\\tthis.direction.copy( direction );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( ray ) {\\n\\n\\t\\t\\tthis.origin.copy( ray.origin );\\n\\t\\t\\tthis.direction.copy( ray.direction );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tat: function ( t, optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\treturn result.copy( this.direction ).multiplyScalar( t ).add( this.origin );\\n\\n\\t\\t},\\n\\n\\t\\tlookAt: function ( v ) {\\n\\n\\t\\t\\tthis.direction.copy( v ).sub( this.origin ).normalize();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\trecast: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function recast( t ) {\\n\\n\\t\\t\\t\\tthis.origin.copy( this.at( t, v1 ) );\\n\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tclosestPointToPoint: function ( point, optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\t\\t\\tresult.subVectors( point, this.origin );\\n\\t\\t\\tvar directionDistance = result.dot( this.direction );\\n\\n\\t\\t\\tif ( directionDistance < 0 ) {\\n\\n\\t\\t\\t\\treturn result.copy( this.origin );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn result.copy( this.direction ).multiplyScalar( directionDistance ).add( this.origin );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToPoint: function ( point ) {\\n\\n\\t\\t\\treturn Math.sqrt( this.distanceSqToPoint( point ) );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceSqToPoint: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function distanceSqToPoint( point ) {\\n\\n\\t\\t\\t\\tvar directionDistance = v1.subVectors( point, this.origin ).dot( this.direction );\\n\\n\\t\\t\\t\\t// point behind the ray\\n\\n\\t\\t\\t\\tif ( directionDistance < 0 ) {\\n\\n\\t\\t\\t\\t\\treturn this.origin.distanceToSquared( point );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tv1.copy( this.direction ).multiplyScalar( directionDistance ).add( this.origin );\\n\\n\\t\\t\\t\\treturn v1.distanceToSquared( point );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tdistanceSqToSegment: function () {\\n\\n\\t\\t\\tvar segCenter = new Vector3();\\n\\t\\t\\tvar segDir = new Vector3();\\n\\t\\t\\tvar diff = new Vector3();\\n\\n\\t\\t\\treturn function distanceSqToSegment( v0, v1, optionalPointOnRay, optionalPointOnSegment ) {\\n\\n\\t\\t\\t\\t// from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteDistRaySegment.h\\n\\t\\t\\t\\t// It returns the min distance between the ray and the segment\\n\\t\\t\\t\\t// defined by v0 and v1\\n\\t\\t\\t\\t// It can also set two optional targets :\\n\\t\\t\\t\\t// - The closest point on the ray\\n\\t\\t\\t\\t// - The closest point on the segment\\n\\n\\t\\t\\t\\tsegCenter.copy( v0 ).add( v1 ).multiplyScalar( 0.5 );\\n\\t\\t\\t\\tsegDir.copy( v1 ).sub( v0 ).normalize();\\n\\t\\t\\t\\tdiff.copy( this.origin ).sub( segCenter );\\n\\n\\t\\t\\t\\tvar segExtent = v0.distanceTo( v1 ) * 0.5;\\n\\t\\t\\t\\tvar a01 = - this.direction.dot( segDir );\\n\\t\\t\\t\\tvar b0 = diff.dot( this.direction );\\n\\t\\t\\t\\tvar b1 = - diff.dot( segDir );\\n\\t\\t\\t\\tvar c = diff.lengthSq();\\n\\t\\t\\t\\tvar det = Math.abs( 1 - a01 * a01 );\\n\\t\\t\\t\\tvar s0, s1, sqrDist, extDet;\\n\\n\\t\\t\\t\\tif ( det > 0 ) {\\n\\n\\t\\t\\t\\t\\t// The ray and segment are not parallel.\\n\\n\\t\\t\\t\\t\\ts0 = a01 * b1 - b0;\\n\\t\\t\\t\\t\\ts1 = a01 * b0 - b1;\\n\\t\\t\\t\\t\\textDet = segExtent * det;\\n\\n\\t\\t\\t\\t\\tif ( s0 >= 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( s1 >= - extDet ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( s1 <= extDet ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t// region 0\\n\\t\\t\\t\\t\\t\\t\\t\\t// Minimum at interior points of ray and segment.\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tvar invDet = 1 / det;\\n\\t\\t\\t\\t\\t\\t\\t\\ts0 *= invDet;\\n\\t\\t\\t\\t\\t\\t\\t\\ts1 *= invDet;\\n\\t\\t\\t\\t\\t\\t\\t\\tsqrDist = s0 * ( s0 + a01 * s1 + 2 * b0 ) + s1 * ( a01 * s0 + s1 + 2 * b1 ) + c;\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t// region 1\\n\\n\\t\\t\\t\\t\\t\\t\\t\\ts1 = segExtent;\\n\\t\\t\\t\\t\\t\\t\\t\\ts0 = Math.max( 0, - ( a01 * s1 + b0 ) );\\n\\t\\t\\t\\t\\t\\t\\t\\tsqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t// region 5\\n\\n\\t\\t\\t\\t\\t\\t\\ts1 = - segExtent;\\n\\t\\t\\t\\t\\t\\t\\ts0 = Math.max( 0, - ( a01 * s1 + b0 ) );\\n\\t\\t\\t\\t\\t\\t\\tsqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tif ( s1 <= - extDet ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// region 4\\n\\n\\t\\t\\t\\t\\t\\t\\ts0 = Math.max( 0, - ( - a01 * segExtent + b0 ) );\\n\\t\\t\\t\\t\\t\\t\\ts1 = ( s0 > 0 ) ? - segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent );\\n\\t\\t\\t\\t\\t\\t\\tsqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;\\n\\n\\t\\t\\t\\t\\t\\t} else if ( s1 <= extDet ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// region 3\\n\\n\\t\\t\\t\\t\\t\\t\\ts0 = 0;\\n\\t\\t\\t\\t\\t\\t\\ts1 = Math.min( Math.max( - segExtent, - b1 ), segExtent );\\n\\t\\t\\t\\t\\t\\t\\tsqrDist = s1 * ( s1 + 2 * b1 ) + c;\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t// region 2\\n\\n\\t\\t\\t\\t\\t\\t\\ts0 = Math.max( 0, - ( a01 * segExtent + b0 ) );\\n\\t\\t\\t\\t\\t\\t\\ts1 = ( s0 > 0 ) ? segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent );\\n\\t\\t\\t\\t\\t\\t\\tsqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// Ray and segment are parallel.\\n\\n\\t\\t\\t\\t\\ts1 = ( a01 > 0 ) ? - segExtent : segExtent;\\n\\t\\t\\t\\t\\ts0 = Math.max( 0, - ( a01 * s1 + b0 ) );\\n\\t\\t\\t\\t\\tsqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( optionalPointOnRay ) {\\n\\n\\t\\t\\t\\t\\toptionalPointOnRay.copy( this.direction ).multiplyScalar( s0 ).add( this.origin );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( optionalPointOnSegment ) {\\n\\n\\t\\t\\t\\t\\toptionalPointOnSegment.copy( segDir ).multiplyScalar( s1 ).add( segCenter );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn sqrDist;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tintersectSphere: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function intersectSphere( sphere, optionalTarget ) {\\n\\n\\t\\t\\t\\tv1.subVectors( sphere.center, this.origin );\\n\\t\\t\\t\\tvar tca = v1.dot( this.direction );\\n\\t\\t\\t\\tvar d2 = v1.dot( v1 ) - tca * tca;\\n\\t\\t\\t\\tvar radius2 = sphere.radius * sphere.radius;\\n\\n\\t\\t\\t\\tif ( d2 > radius2 ) return null;\\n\\n\\t\\t\\t\\tvar thc = Math.sqrt( radius2 - d2 );\\n\\n\\t\\t\\t\\t// t0 = first intersect point - entrance on front of sphere\\n\\t\\t\\t\\tvar t0 = tca - thc;\\n\\n\\t\\t\\t\\t// t1 = second intersect point - exit point on back of sphere\\n\\t\\t\\t\\tvar t1 = tca + thc;\\n\\n\\t\\t\\t\\t// test to see if both t0 and t1 are behind the ray - if so, return null\\n\\t\\t\\t\\tif ( t0 < 0 && t1 < 0 ) return null;\\n\\n\\t\\t\\t\\t// test to see if t0 is behind the ray:\\n\\t\\t\\t\\t// if it is, the ray is inside the sphere, so return the second exit point scaled by t1,\\n\\t\\t\\t\\t// in order to always return an intersect point that is in front of the ray.\\n\\t\\t\\t\\tif ( t0 < 0 ) return this.at( t1, optionalTarget );\\n\\n\\t\\t\\t\\t// else t0 is in front of the ray, so return the first collision point scaled by t0\\n\\t\\t\\t\\treturn this.at( t0, optionalTarget );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tintersectsSphere: function ( sphere ) {\\n\\n\\t\\t\\treturn this.distanceToPoint( sphere.center ) <= sphere.radius;\\n\\n\\t\\t},\\n\\n\\t\\tdistanceToPlane: function ( plane ) {\\n\\n\\t\\t\\tvar denominator = plane.normal.dot( this.direction );\\n\\n\\t\\t\\tif ( denominator === 0 ) {\\n\\n\\t\\t\\t\\t// line is coplanar, return origin\\n\\t\\t\\t\\tif ( plane.distanceToPoint( this.origin ) === 0 ) {\\n\\n\\t\\t\\t\\t\\treturn 0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// Null is preferable to undefined since undefined means.... it is undefined\\n\\n\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar t = - ( this.origin.dot( plane.normal ) + plane.constant ) / denominator;\\n\\n\\t\\t\\t// Return if the ray never intersects the plane\\n\\n\\t\\t\\treturn t >= 0 ? t : null;\\n\\n\\t\\t},\\n\\n\\t\\tintersectPlane: function ( plane, optionalTarget ) {\\n\\n\\t\\t\\tvar t = this.distanceToPlane( plane );\\n\\n\\t\\t\\tif ( t === null ) {\\n\\n\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this.at( t, optionalTarget );\\n\\n\\t\\t},\\n\\n\\t\\tintersectsPlane: function ( plane ) {\\n\\n\\t\\t\\t// check if the ray lies on the plane first\\n\\n\\t\\t\\tvar distToPoint = plane.distanceToPoint( this.origin );\\n\\n\\t\\t\\tif ( distToPoint === 0 ) {\\n\\n\\t\\t\\t\\treturn true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar denominator = plane.normal.dot( this.direction );\\n\\n\\t\\t\\tif ( denominator * distToPoint < 0 ) {\\n\\n\\t\\t\\t\\treturn true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// ray origin is behind the plane (and is pointing behind it)\\n\\n\\t\\t\\treturn false;\\n\\n\\t\\t},\\n\\n\\t\\tintersectBox: function ( box, optionalTarget ) {\\n\\n\\t\\t\\tvar tmin, tmax, tymin, tymax, tzmin, tzmax;\\n\\n\\t\\t\\tvar invdirx = 1 / this.direction.x,\\n\\t\\t\\t\\tinvdiry = 1 / this.direction.y,\\n\\t\\t\\t\\tinvdirz = 1 / this.direction.z;\\n\\n\\t\\t\\tvar origin = this.origin;\\n\\n\\t\\t\\tif ( invdirx >= 0 ) {\\n\\n\\t\\t\\t\\ttmin = ( box.min.x - origin.x ) * invdirx;\\n\\t\\t\\t\\ttmax = ( box.max.x - origin.x ) * invdirx;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\ttmin = ( box.max.x - origin.x ) * invdirx;\\n\\t\\t\\t\\ttmax = ( box.min.x - origin.x ) * invdirx;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( invdiry >= 0 ) {\\n\\n\\t\\t\\t\\ttymin = ( box.min.y - origin.y ) * invdiry;\\n\\t\\t\\t\\ttymax = ( box.max.y - origin.y ) * invdiry;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\ttymin = ( box.max.y - origin.y ) * invdiry;\\n\\t\\t\\t\\ttymax = ( box.min.y - origin.y ) * invdiry;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( ( tmin > tymax ) || ( tymin > tmax ) ) return null;\\n\\n\\t\\t\\t// These lines also handle the case where tmin or tmax is NaN\\n\\t\\t\\t// (result of 0 * Infinity). x !== x returns true if x is NaN\\n\\n\\t\\t\\tif ( tymin > tmin || tmin !== tmin ) tmin = tymin;\\n\\n\\t\\t\\tif ( tymax < tmax || tmax !== tmax ) tmax = tymax;\\n\\n\\t\\t\\tif ( invdirz >= 0 ) {\\n\\n\\t\\t\\t\\ttzmin = ( box.min.z - origin.z ) * invdirz;\\n\\t\\t\\t\\ttzmax = ( box.max.z - origin.z ) * invdirz;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\ttzmin = ( box.max.z - origin.z ) * invdirz;\\n\\t\\t\\t\\ttzmax = ( box.min.z - origin.z ) * invdirz;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( ( tmin > tzmax ) || ( tzmin > tmax ) ) return null;\\n\\n\\t\\t\\tif ( tzmin > tmin || tmin !== tmin ) tmin = tzmin;\\n\\n\\t\\t\\tif ( tzmax < tmax || tmax !== tmax ) tmax = tzmax;\\n\\n\\t\\t\\t//return point closest to the ray (positive side)\\n\\n\\t\\t\\tif ( tmax < 0 ) return null;\\n\\n\\t\\t\\treturn this.at( tmin >= 0 ? tmin : tmax, optionalTarget );\\n\\n\\t\\t},\\n\\n\\t\\tintersectsBox: ( function () {\\n\\n\\t\\t\\tvar v = new Vector3();\\n\\n\\t\\t\\treturn function intersectsBox( box ) {\\n\\n\\t\\t\\t\\treturn this.intersectBox( box, v ) !== null;\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )(),\\n\\n\\t\\tintersectTriangle: function () {\\n\\n\\t\\t\\t// Compute the offset origin, edges, and normal.\\n\\t\\t\\tvar diff = new Vector3();\\n\\t\\t\\tvar edge1 = new Vector3();\\n\\t\\t\\tvar edge2 = new Vector3();\\n\\t\\t\\tvar normal = new Vector3();\\n\\n\\t\\t\\treturn function intersectTriangle( a, b, c, backfaceCulling, optionalTarget ) {\\n\\n\\t\\t\\t\\t// from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h\\n\\n\\t\\t\\t\\tedge1.subVectors( b, a );\\n\\t\\t\\t\\tedge2.subVectors( c, a );\\n\\t\\t\\t\\tnormal.crossVectors( edge1, edge2 );\\n\\n\\t\\t\\t\\t// Solve Q + t*D = b1*E1 + b2*E2 (Q = kDiff, D = ray direction,\\n\\t\\t\\t\\t// E1 = kEdge1, E2 = kEdge2, N = Cross(E1,E2)) by\\n\\t\\t\\t\\t//   |Dot(D,N)|*b1 = sign(Dot(D,N))*Dot(D,Cross(Q,E2))\\n\\t\\t\\t\\t//   |Dot(D,N)|*b2 = sign(Dot(D,N))*Dot(D,Cross(E1,Q))\\n\\t\\t\\t\\t//   |Dot(D,N)|*t = -sign(Dot(D,N))*Dot(Q,N)\\n\\t\\t\\t\\tvar DdN = this.direction.dot( normal );\\n\\t\\t\\t\\tvar sign;\\n\\n\\t\\t\\t\\tif ( DdN > 0 ) {\\n\\n\\t\\t\\t\\t\\tif ( backfaceCulling ) return null;\\n\\t\\t\\t\\t\\tsign = 1;\\n\\n\\t\\t\\t\\t} else if ( DdN < 0 ) {\\n\\n\\t\\t\\t\\t\\tsign = - 1;\\n\\t\\t\\t\\t\\tDdN = - DdN;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tdiff.subVectors( this.origin, a );\\n\\t\\t\\t\\tvar DdQxE2 = sign * this.direction.dot( edge2.crossVectors( diff, edge2 ) );\\n\\n\\t\\t\\t\\t// b1 < 0, no intersection\\n\\t\\t\\t\\tif ( DdQxE2 < 0 ) {\\n\\n\\t\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar DdE1xQ = sign * this.direction.dot( edge1.cross( diff ) );\\n\\n\\t\\t\\t\\t// b2 < 0, no intersection\\n\\t\\t\\t\\tif ( DdE1xQ < 0 ) {\\n\\n\\t\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// b1+b2 > 1, no intersection\\n\\t\\t\\t\\tif ( DdQxE2 + DdE1xQ > DdN ) {\\n\\n\\t\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// Line intersects triangle, check if ray does.\\n\\t\\t\\t\\tvar QdN = - sign * diff.dot( normal );\\n\\n\\t\\t\\t\\t// t < 0, no intersection\\n\\t\\t\\t\\tif ( QdN < 0 ) {\\n\\n\\t\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// Ray intersects triangle.\\n\\t\\t\\t\\treturn this.at( QdN / DdN, optionalTarget );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tapplyMatrix4: function ( matrix4 ) {\\n\\n\\t\\t\\tthis.origin.applyMatrix4( matrix4 );\\n\\t\\t\\tthis.direction.transformDirection( matrix4 );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( ray ) {\\n\\n\\t\\t\\treturn ray.origin.equals( this.origin ) && ray.direction.equals( this.direction );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author bhouston / http://clara.io\\n\\t */\\n\\n\\tfunction Line3( start, end ) {\\n\\n\\t\\tthis.start = ( start !== undefined ) ? start : new Vector3();\\n\\t\\tthis.end = ( end !== undefined ) ? end : new Vector3();\\n\\n\\t}\\n\\n\\tObject.assign( Line3.prototype, {\\n\\n\\t\\tset: function ( start, end ) {\\n\\n\\t\\t\\tthis.start.copy( start );\\n\\t\\t\\tthis.end.copy( end );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( line ) {\\n\\n\\t\\t\\tthis.start.copy( line.start );\\n\\t\\t\\tthis.end.copy( line.end );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetCenter: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\t\\t\\treturn result.addVectors( this.start, this.end ).multiplyScalar( 0.5 );\\n\\n\\t\\t},\\n\\n\\t\\tdelta: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\t\\t\\treturn result.subVectors( this.end, this.start );\\n\\n\\t\\t},\\n\\n\\t\\tdistanceSq: function () {\\n\\n\\t\\t\\treturn this.start.distanceToSquared( this.end );\\n\\n\\t\\t},\\n\\n\\t\\tdistance: function () {\\n\\n\\t\\t\\treturn this.start.distanceTo( this.end );\\n\\n\\t\\t},\\n\\n\\t\\tat: function ( t, optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\treturn this.delta( result ).multiplyScalar( t ).add( this.start );\\n\\n\\t\\t},\\n\\n\\t\\tclosestPointToPointParameter: function () {\\n\\n\\t\\t\\tvar startP = new Vector3();\\n\\t\\t\\tvar startEnd = new Vector3();\\n\\n\\t\\t\\treturn function closestPointToPointParameter( point, clampToLine ) {\\n\\n\\t\\t\\t\\tstartP.subVectors( point, this.start );\\n\\t\\t\\t\\tstartEnd.subVectors( this.end, this.start );\\n\\n\\t\\t\\t\\tvar startEnd2 = startEnd.dot( startEnd );\\n\\t\\t\\t\\tvar startEnd_startP = startEnd.dot( startP );\\n\\n\\t\\t\\t\\tvar t = startEnd_startP / startEnd2;\\n\\n\\t\\t\\t\\tif ( clampToLine ) {\\n\\n\\t\\t\\t\\t\\tt = _Math.clamp( t, 0, 1 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn t;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tclosestPointToPoint: function ( point, clampToLine, optionalTarget ) {\\n\\n\\t\\t\\tvar t = this.closestPointToPointParameter( point, clampToLine );\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\treturn this.delta( result ).multiplyScalar( t ).add( this.start );\\n\\n\\t\\t},\\n\\n\\t\\tapplyMatrix4: function ( matrix ) {\\n\\n\\t\\t\\tthis.start.applyMatrix4( matrix );\\n\\t\\t\\tthis.end.applyMatrix4( matrix );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tequals: function ( line ) {\\n\\n\\t\\t\\treturn line.start.equals( this.start ) && line.end.equals( this.end );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author bhouston / http://clara.io\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Triangle( a, b, c ) {\\n\\n\\t\\tthis.a = ( a !== undefined ) ? a : new Vector3();\\n\\t\\tthis.b = ( b !== undefined ) ? b : new Vector3();\\n\\t\\tthis.c = ( c !== undefined ) ? c : new Vector3();\\n\\n\\t}\\n\\n\\tObject.assign( Triangle, {\\n\\n\\t\\tnormal: function () {\\n\\n\\t\\t\\tvar v0 = new Vector3();\\n\\n\\t\\t\\treturn function normal( a, b, c, optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\t\\tresult.subVectors( c, b );\\n\\t\\t\\t\\tv0.subVectors( a, b );\\n\\t\\t\\t\\tresult.cross( v0 );\\n\\n\\t\\t\\t\\tvar resultLengthSq = result.lengthSq();\\n\\t\\t\\t\\tif ( resultLengthSq > 0 ) {\\n\\n\\t\\t\\t\\t\\treturn result.multiplyScalar( 1 / Math.sqrt( resultLengthSq ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn result.set( 0, 0, 0 );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\t// static/instance method to calculate barycentric coordinates\\n\\t\\t// based on: http://www.blackpawn.com/texts/pointinpoly/default.html\\n\\t\\tbarycoordFromPoint: function () {\\n\\n\\t\\t\\tvar v0 = new Vector3();\\n\\t\\t\\tvar v1 = new Vector3();\\n\\t\\t\\tvar v2 = new Vector3();\\n\\n\\t\\t\\treturn function barycoordFromPoint( point, a, b, c, optionalTarget ) {\\n\\n\\t\\t\\t\\tv0.subVectors( c, a );\\n\\t\\t\\t\\tv1.subVectors( b, a );\\n\\t\\t\\t\\tv2.subVectors( point, a );\\n\\n\\t\\t\\t\\tvar dot00 = v0.dot( v0 );\\n\\t\\t\\t\\tvar dot01 = v0.dot( v1 );\\n\\t\\t\\t\\tvar dot02 = v0.dot( v2 );\\n\\t\\t\\t\\tvar dot11 = v1.dot( v1 );\\n\\t\\t\\t\\tvar dot12 = v1.dot( v2 );\\n\\n\\t\\t\\t\\tvar denom = ( dot00 * dot11 - dot01 * dot01 );\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\n\\t\\t\\t\\t// collinear or singular triangle\\n\\t\\t\\t\\tif ( denom === 0 ) {\\n\\n\\t\\t\\t\\t\\t// arbitrary location outside of triangle?\\n\\t\\t\\t\\t\\t// not sure if this is the best idea, maybe should be returning undefined\\n\\t\\t\\t\\t\\treturn result.set( - 2, - 1, - 1 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar invDenom = 1 / denom;\\n\\t\\t\\t\\tvar u = ( dot11 * dot02 - dot01 * dot12 ) * invDenom;\\n\\t\\t\\t\\tvar v = ( dot00 * dot12 - dot01 * dot02 ) * invDenom;\\n\\n\\t\\t\\t\\t// barycentric coordinates must always sum to 1\\n\\t\\t\\t\\treturn result.set( 1 - u - v, v, u );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tcontainsPoint: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function containsPoint( point, a, b, c ) {\\n\\n\\t\\t\\t\\tvar result = Triangle.barycoordFromPoint( point, a, b, c, v1 );\\n\\n\\t\\t\\t\\treturn ( result.x >= 0 ) && ( result.y >= 0 ) && ( ( result.x + result.y ) <= 1 );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}()\\n\\n\\t} );\\n\\n\\tObject.assign( Triangle.prototype, {\\n\\n\\t\\tset: function ( a, b, c ) {\\n\\n\\t\\t\\tthis.a.copy( a );\\n\\t\\t\\tthis.b.copy( b );\\n\\t\\t\\tthis.c.copy( c );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromPointsAndIndices: function ( points, i0, i1, i2 ) {\\n\\n\\t\\t\\tthis.a.copy( points[ i0 ] );\\n\\t\\t\\tthis.b.copy( points[ i1 ] );\\n\\t\\t\\tthis.c.copy( points[ i2 ] );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( triangle ) {\\n\\n\\t\\t\\tthis.a.copy( triangle.a );\\n\\t\\t\\tthis.b.copy( triangle.b );\\n\\t\\t\\tthis.c.copy( triangle.c );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tarea: function () {\\n\\n\\t\\t\\tvar v0 = new Vector3();\\n\\t\\t\\tvar v1 = new Vector3();\\n\\n\\t\\t\\treturn function area() {\\n\\n\\t\\t\\t\\tv0.subVectors( this.c, this.b );\\n\\t\\t\\t\\tv1.subVectors( this.a, this.b );\\n\\n\\t\\t\\t\\treturn v0.cross( v1 ).length() * 0.5;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tmidpoint: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\t\\t\\treturn result.addVectors( this.a, this.b ).add( this.c ).multiplyScalar( 1 / 3 );\\n\\n\\t\\t},\\n\\n\\t\\tnormal: function ( optionalTarget ) {\\n\\n\\t\\t\\treturn Triangle.normal( this.a, this.b, this.c, optionalTarget );\\n\\n\\t\\t},\\n\\n\\t\\tplane: function ( optionalTarget ) {\\n\\n\\t\\t\\tvar result = optionalTarget || new Plane();\\n\\n\\t\\t\\treturn result.setFromCoplanarPoints( this.a, this.b, this.c );\\n\\n\\t\\t},\\n\\n\\t\\tbarycoordFromPoint: function ( point, optionalTarget ) {\\n\\n\\t\\t\\treturn Triangle.barycoordFromPoint( point, this.a, this.b, this.c, optionalTarget );\\n\\n\\t\\t},\\n\\n\\t\\tcontainsPoint: function ( point ) {\\n\\n\\t\\t\\treturn Triangle.containsPoint( point, this.a, this.b, this.c );\\n\\n\\t\\t},\\n\\n\\t\\tclosestPointToPoint: function () {\\n\\n\\t\\t\\tvar plane = new Plane();\\n\\t\\t\\tvar edgeList = [ new Line3(), new Line3(), new Line3() ];\\n\\t\\t\\tvar projectedPoint = new Vector3();\\n\\t\\t\\tvar closestPoint = new Vector3();\\n\\n\\t\\t\\treturn function closestPointToPoint( point, optionalTarget ) {\\n\\n\\t\\t\\t\\tvar result = optionalTarget || new Vector3();\\n\\t\\t\\t\\tvar minDistance = Infinity;\\n\\n\\t\\t\\t\\t// project the point onto the plane of the triangle\\n\\n\\t\\t\\t\\tplane.setFromCoplanarPoints( this.a, this.b, this.c );\\n\\t\\t\\t\\tplane.projectPoint( point, projectedPoint );\\n\\n\\t\\t\\t\\t// check if the projection lies within the triangle\\n\\n\\t\\t\\t\\tif ( this.containsPoint( projectedPoint ) === true ) {\\n\\n\\t\\t\\t\\t\\t// if so, this is the closest point\\n\\n\\t\\t\\t\\t\\tresult.copy( projectedPoint );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// if not, the point falls outside the triangle. the result is the closest point to the triangle's edges or vertices\\n\\n\\t\\t\\t\\t\\tedgeList[ 0 ].set( this.a, this.b );\\n\\t\\t\\t\\t\\tedgeList[ 1 ].set( this.b, this.c );\\n\\t\\t\\t\\t\\tedgeList[ 2 ].set( this.c, this.a );\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < edgeList.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tedgeList[ i ].closestPointToPoint( projectedPoint, true, closestPoint );\\n\\n\\t\\t\\t\\t\\t\\tvar distance = projectedPoint.distanceToSquared( closestPoint );\\n\\n\\t\\t\\t\\t\\t\\tif ( distance < minDistance ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tminDistance = distance;\\n\\n\\t\\t\\t\\t\\t\\t\\tresult.copy( closestPoint );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn result;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tequals: function ( triangle ) {\\n\\n\\t\\t\\treturn triangle.a.equals( this.a ) && triangle.b.equals( this.b ) && triangle.c.equals( this.c );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author jonobr1 / http://jonobr1.com/\\n\\t */\\n\\n\\tfunction Mesh( geometry, material ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Mesh';\\n\\n\\t\\tthis.geometry = geometry !== undefined ? geometry : new BufferGeometry();\\n\\t\\tthis.material = material !== undefined ? material : new MeshBasicMaterial( { color: Math.random() * 0xffffff } );\\n\\n\\t\\tthis.drawMode = TrianglesDrawMode;\\n\\n\\t\\tthis.updateMorphTargets();\\n\\n\\t}\\n\\n\\tMesh.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Mesh,\\n\\n\\t\\tisMesh: true,\\n\\n\\t\\tsetDrawMode: function ( value ) {\\n\\n\\t\\t\\tthis.drawMode = value;\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tObject3D.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.drawMode = source.drawMode;\\n\\n\\t\\t\\tif ( source.morphTargetInfluences !== undefined ) {\\n\\n\\t\\t\\t\\tthis.morphTargetInfluences = source.morphTargetInfluences.slice();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( source.morphTargetDictionary !== undefined ) {\\n\\n\\t\\t\\t\\tthis.morphTargetDictionary = Object.assign( {}, source.morphTargetDictionary );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tupdateMorphTargets: function () {\\n\\n\\t\\t\\tvar geometry = this.geometry;\\n\\t\\t\\tvar m, ml, name;\\n\\n\\t\\t\\tif ( geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\tvar morphAttributes = geometry.morphAttributes;\\n\\t\\t\\t\\tvar keys = Object.keys( morphAttributes );\\n\\n\\t\\t\\t\\tif ( keys.length > 0 ) {\\n\\n\\t\\t\\t\\t\\tvar morphAttribute = morphAttributes[ keys[ 0 ] ];\\n\\n\\t\\t\\t\\t\\tif ( morphAttribute !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tthis.morphTargetInfluences = [];\\n\\t\\t\\t\\t\\t\\tthis.morphTargetDictionary = {};\\n\\n\\t\\t\\t\\t\\t\\tfor ( m = 0, ml = morphAttribute.length; m < ml; m ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tname = morphAttribute[ m ].name || String( m );\\n\\n\\t\\t\\t\\t\\t\\t\\tthis.morphTargetInfluences.push( 0 );\\n\\t\\t\\t\\t\\t\\t\\tthis.morphTargetDictionary[ name ] = m;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tvar morphTargets = geometry.morphTargets;\\n\\n\\t\\t\\t\\tif ( morphTargets !== undefined && morphTargets.length > 0 ) {\\n\\n\\t\\t\\t\\t\\tthis.morphTargetInfluences = [];\\n\\t\\t\\t\\t\\tthis.morphTargetDictionary = {};\\n\\n\\t\\t\\t\\t\\tfor ( m = 0, ml = morphTargets.length; m < ml; m ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tname = morphTargets[ m ].name || String( m );\\n\\n\\t\\t\\t\\t\\t\\tthis.morphTargetInfluences.push( 0 );\\n\\t\\t\\t\\t\\t\\tthis.morphTargetDictionary[ name ] = m;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\traycast: ( function () {\\n\\n\\t\\t\\tvar inverseMatrix = new Matrix4();\\n\\t\\t\\tvar ray = new Ray();\\n\\t\\t\\tvar sphere = new Sphere();\\n\\n\\t\\t\\tvar vA = new Vector3();\\n\\t\\t\\tvar vB = new Vector3();\\n\\t\\t\\tvar vC = new Vector3();\\n\\n\\t\\t\\tvar tempA = new Vector3();\\n\\t\\t\\tvar tempB = new Vector3();\\n\\t\\t\\tvar tempC = new Vector3();\\n\\n\\t\\t\\tvar uvA = new Vector2();\\n\\t\\t\\tvar uvB = new Vector2();\\n\\t\\t\\tvar uvC = new Vector2();\\n\\n\\t\\t\\tvar barycoord = new Vector3();\\n\\n\\t\\t\\tvar intersectionPoint = new Vector3();\\n\\t\\t\\tvar intersectionPointWorld = new Vector3();\\n\\n\\t\\t\\tfunction uvIntersection( point, p1, p2, p3, uv1, uv2, uv3 ) {\\n\\n\\t\\t\\t\\tTriangle.barycoordFromPoint( point, p1, p2, p3, barycoord );\\n\\n\\t\\t\\t\\tuv1.multiplyScalar( barycoord.x );\\n\\t\\t\\t\\tuv2.multiplyScalar( barycoord.y );\\n\\t\\t\\t\\tuv3.multiplyScalar( barycoord.z );\\n\\n\\t\\t\\t\\tuv1.add( uv2 ).add( uv3 );\\n\\n\\t\\t\\t\\treturn uv1.clone();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction checkIntersection( object, material, raycaster, ray, pA, pB, pC, point ) {\\n\\n\\t\\t\\t\\tvar intersect;\\n\\n\\t\\t\\t\\tif ( material.side === BackSide ) {\\n\\n\\t\\t\\t\\t\\tintersect = ray.intersectTriangle( pC, pB, pA, true, point );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tintersect = ray.intersectTriangle( pA, pB, pC, material.side !== DoubleSide, point );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( intersect === null ) return null;\\n\\n\\t\\t\\t\\tintersectionPointWorld.copy( point );\\n\\t\\t\\t\\tintersectionPointWorld.applyMatrix4( object.matrixWorld );\\n\\n\\t\\t\\t\\tvar distance = raycaster.ray.origin.distanceTo( intersectionPointWorld );\\n\\n\\t\\t\\t\\tif ( distance < raycaster.near || distance > raycaster.far ) return null;\\n\\n\\t\\t\\t\\treturn {\\n\\t\\t\\t\\t\\tdistance: distance,\\n\\t\\t\\t\\t\\tpoint: intersectionPointWorld.clone(),\\n\\t\\t\\t\\t\\tobject: object\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction checkBufferGeometryIntersection( object, raycaster, ray, position, uv, a, b, c ) {\\n\\n\\t\\t\\t\\tvA.fromBufferAttribute( position, a );\\n\\t\\t\\t\\tvB.fromBufferAttribute( position, b );\\n\\t\\t\\t\\tvC.fromBufferAttribute( position, c );\\n\\n\\t\\t\\t\\tvar intersection = checkIntersection( object, object.material, raycaster, ray, vA, vB, vC, intersectionPoint );\\n\\n\\t\\t\\t\\tif ( intersection ) {\\n\\n\\t\\t\\t\\t\\tif ( uv ) {\\n\\n\\t\\t\\t\\t\\t\\tuvA.fromBufferAttribute( uv, a );\\n\\t\\t\\t\\t\\t\\tuvB.fromBufferAttribute( uv, b );\\n\\t\\t\\t\\t\\t\\tuvC.fromBufferAttribute( uv, c );\\n\\n\\t\\t\\t\\t\\t\\tintersection.uv = uvIntersection( intersectionPoint, vA, vB, vC, uvA, uvB, uvC );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tintersection.face = new Face3( a, b, c, Triangle.normal( vA, vB, vC ) );\\n\\t\\t\\t\\t\\tintersection.faceIndex = a;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn intersection;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn function raycast( raycaster, intersects ) {\\n\\n\\t\\t\\t\\tvar geometry = this.geometry;\\n\\t\\t\\t\\tvar material = this.material;\\n\\t\\t\\t\\tvar matrixWorld = this.matrixWorld;\\n\\n\\t\\t\\t\\tif ( material === undefined ) return;\\n\\n\\t\\t\\t\\t// Checking boundingSphere distance to ray\\n\\n\\t\\t\\t\\tif ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();\\n\\n\\t\\t\\t\\tsphere.copy( geometry.boundingSphere );\\n\\t\\t\\t\\tsphere.applyMatrix4( matrixWorld );\\n\\n\\t\\t\\t\\tif ( raycaster.ray.intersectsSphere( sphere ) === false ) return;\\n\\n\\t\\t\\t\\t//\\n\\n\\t\\t\\t\\tinverseMatrix.getInverse( matrixWorld );\\n\\t\\t\\t\\tray.copy( raycaster.ray ).applyMatrix4( inverseMatrix );\\n\\n\\t\\t\\t\\t// Check boundingBox before continuing\\n\\n\\t\\t\\t\\tif ( geometry.boundingBox !== null ) {\\n\\n\\t\\t\\t\\t\\tif ( ray.intersectsBox( geometry.boundingBox ) === false ) return;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar intersection;\\n\\n\\t\\t\\t\\tif ( geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\t\\tvar a, b, c;\\n\\t\\t\\t\\t\\tvar index = geometry.index;\\n\\t\\t\\t\\t\\tvar position = geometry.attributes.position;\\n\\t\\t\\t\\t\\tvar uv = geometry.attributes.uv;\\n\\t\\t\\t\\t\\tvar i, l;\\n\\n\\t\\t\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\t\\t\\t// indexed buffer geometry\\n\\n\\t\\t\\t\\t\\t\\tfor ( i = 0, l = index.count; i < l; i += 3 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\ta = index.getX( i );\\n\\t\\t\\t\\t\\t\\t\\tb = index.getX( i + 1 );\\n\\t\\t\\t\\t\\t\\t\\tc = index.getX( i + 2 );\\n\\n\\t\\t\\t\\t\\t\\t\\tintersection = checkBufferGeometryIntersection( this, raycaster, ray, position, uv, a, b, c );\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( intersection ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tintersection.faceIndex = Math.floor( i / 3 ); // triangle number in indices buffer semantics\\n\\t\\t\\t\\t\\t\\t\\t\\tintersects.push( intersection );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else if ( position !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t// non-indexed buffer geometry\\n\\n\\t\\t\\t\\t\\t\\tfor ( i = 0, l = position.count; i < l; i += 3 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\ta = i;\\n\\t\\t\\t\\t\\t\\t\\tb = i + 1;\\n\\t\\t\\t\\t\\t\\t\\tc = i + 2;\\n\\n\\t\\t\\t\\t\\t\\t\\tintersection = checkBufferGeometryIntersection( this, raycaster, ray, position, uv, a, b, c );\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( intersection ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tintersection.index = a; // triangle number in positions buffer semantics\\n\\t\\t\\t\\t\\t\\t\\t\\tintersects.push( intersection );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( geometry.isGeometry ) {\\n\\n\\t\\t\\t\\t\\tvar fvA, fvB, fvC;\\n\\t\\t\\t\\t\\tvar isMultiMaterial = Array.isArray( material );\\n\\n\\t\\t\\t\\t\\tvar vertices = geometry.vertices;\\n\\t\\t\\t\\t\\tvar faces = geometry.faces;\\n\\t\\t\\t\\t\\tvar uvs;\\n\\n\\t\\t\\t\\t\\tvar faceVertexUvs = geometry.faceVertexUvs[ 0 ];\\n\\t\\t\\t\\t\\tif ( faceVertexUvs.length > 0 ) uvs = faceVertexUvs;\\n\\n\\t\\t\\t\\t\\tfor ( var f = 0, fl = faces.length; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar face = faces[ f ];\\n\\t\\t\\t\\t\\t\\tvar faceMaterial = isMultiMaterial ? material[ face.materialIndex ] : material;\\n\\n\\t\\t\\t\\t\\t\\tif ( faceMaterial === undefined ) continue;\\n\\n\\t\\t\\t\\t\\t\\tfvA = vertices[ face.a ];\\n\\t\\t\\t\\t\\t\\tfvB = vertices[ face.b ];\\n\\t\\t\\t\\t\\t\\tfvC = vertices[ face.c ];\\n\\n\\t\\t\\t\\t\\t\\tif ( faceMaterial.morphTargets === true ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar morphTargets = geometry.morphTargets;\\n\\t\\t\\t\\t\\t\\t\\tvar morphInfluences = this.morphTargetInfluences;\\n\\n\\t\\t\\t\\t\\t\\t\\tvA.set( 0, 0, 0 );\\n\\t\\t\\t\\t\\t\\t\\tvB.set( 0, 0, 0 );\\n\\t\\t\\t\\t\\t\\t\\tvC.set( 0, 0, 0 );\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var t = 0, tl = morphTargets.length; t < tl; t ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tvar influence = morphInfluences[ t ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( influence === 0 ) continue;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tvar targets = morphTargets[ t ].vertices;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tvA.addScaledVector( tempA.subVectors( targets[ face.a ], fvA ), influence );\\n\\t\\t\\t\\t\\t\\t\\t\\tvB.addScaledVector( tempB.subVectors( targets[ face.b ], fvB ), influence );\\n\\t\\t\\t\\t\\t\\t\\t\\tvC.addScaledVector( tempC.subVectors( targets[ face.c ], fvC ), influence );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\tvA.add( fvA );\\n\\t\\t\\t\\t\\t\\t\\tvB.add( fvB );\\n\\t\\t\\t\\t\\t\\t\\tvC.add( fvC );\\n\\n\\t\\t\\t\\t\\t\\t\\tfvA = vA;\\n\\t\\t\\t\\t\\t\\t\\tfvB = vB;\\n\\t\\t\\t\\t\\t\\t\\tfvC = vC;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tintersection = checkIntersection( this, faceMaterial, raycaster, ray, fvA, fvB, fvC, intersectionPoint );\\n\\n\\t\\t\\t\\t\\t\\tif ( intersection ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( uvs && uvs[ f ] ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tvar uvs_f = uvs[ f ];\\n\\t\\t\\t\\t\\t\\t\\t\\tuvA.copy( uvs_f[ 0 ] );\\n\\t\\t\\t\\t\\t\\t\\t\\tuvB.copy( uvs_f[ 1 ] );\\n\\t\\t\\t\\t\\t\\t\\t\\tuvC.copy( uvs_f[ 2 ] );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tintersection.uv = uvIntersection( intersectionPoint, fvA, fvB, fvC, uvA, uvB, uvC );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\tintersection.face = face;\\n\\t\\t\\t\\t\\t\\t\\tintersection.faceIndex = f;\\n\\t\\t\\t\\t\\t\\t\\tintersects.push( intersection );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}() ),\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.geometry, this.material ).copy( this );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLBackground( renderer, state, geometries, premultipliedAlpha ) {\\n\\n\\t\\tvar clearColor = new Color( 0x000000 );\\n\\t\\tvar clearAlpha = 0;\\n\\n\\t\\tvar planeCamera, planeMesh;\\n\\t\\tvar boxMesh;\\n\\n\\t\\tfunction render( renderList, scene, camera, forceClear ) {\\n\\n\\t\\t\\tvar background = scene.background;\\n\\n\\t\\t\\tif ( background === null ) {\\n\\n\\t\\t\\t\\tsetClear( clearColor, clearAlpha );\\n\\n\\t\\t\\t} else if ( background && background.isColor ) {\\n\\n\\t\\t\\t\\tsetClear( background, 1 );\\n\\t\\t\\t\\tforceClear = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( renderer.autoClear || forceClear ) {\\n\\n\\t\\t\\t\\trenderer.clear( renderer.autoClearColor, renderer.autoClearDepth, renderer.autoClearStencil );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( background && background.isCubeTexture ) {\\n\\n\\t\\t\\t\\tif ( boxMesh === undefined ) {\\n\\n\\t\\t\\t\\t\\tboxMesh = new Mesh(\\n\\t\\t\\t\\t\\t\\tnew BoxBufferGeometry( 1, 1, 1 ),\\n\\t\\t\\t\\t\\t\\tnew ShaderMaterial( {\\n\\t\\t\\t\\t\\t\\t\\tuniforms: ShaderLib.cube.uniforms,\\n\\t\\t\\t\\t\\t\\t\\tvertexShader: ShaderLib.cube.vertexShader,\\n\\t\\t\\t\\t\\t\\t\\tfragmentShader: ShaderLib.cube.fragmentShader,\\n\\t\\t\\t\\t\\t\\t\\tside: BackSide,\\n\\t\\t\\t\\t\\t\\t\\tdepthTest: true,\\n\\t\\t\\t\\t\\t\\t\\tdepthWrite: false,\\n\\t\\t\\t\\t\\t\\t\\tfog: false\\n\\t\\t\\t\\t\\t\\t} )\\n\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\tboxMesh.geometry.removeAttribute( 'normal' );\\n\\t\\t\\t\\t\\tboxMesh.geometry.removeAttribute( 'uv' );\\n\\n\\t\\t\\t\\t\\tboxMesh.onBeforeRender = function ( renderer, scene, camera ) {\\n\\n\\t\\t\\t\\t\\t\\tthis.matrixWorld.copyPosition( camera.matrixWorld );\\n\\n\\t\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\t\\tgeometries.update( boxMesh.geometry );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tboxMesh.material.uniforms.tCube.value = background;\\n\\n\\t\\t\\t\\trenderList.push( boxMesh, boxMesh.geometry, boxMesh.material, 0, null );\\n\\n\\t\\t\\t} else if ( background && background.isTexture ) {\\n\\n\\t\\t\\t\\tif ( planeCamera === undefined ) {\\n\\n\\t\\t\\t\\t\\tplaneCamera = new OrthographicCamera( - 1, 1, 1, - 1, 0, 1 );\\n\\n\\t\\t\\t\\t\\tplaneMesh = new Mesh(\\n\\t\\t\\t\\t\\t\\tnew PlaneBufferGeometry( 2, 2 ),\\n\\t\\t\\t\\t\\t\\tnew MeshBasicMaterial( { depthTest: false, depthWrite: false, fog: false } )\\n\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\tgeometries.update( planeMesh.geometry );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tplaneMesh.material.map = background;\\n\\n\\t\\t\\t\\t// TODO Push this to renderList\\n\\n\\t\\t\\t\\trenderer.renderBufferDirect( planeCamera, null, planeMesh.geometry, planeMesh.material, planeMesh, null );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction setClear( color, alpha ) {\\n\\n\\t\\t\\tstate.buffers.color.setClear( color.r, color.g, color.b, alpha, premultipliedAlpha );\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tgetClearColor: function () {\\n\\n\\t\\t\\t\\treturn clearColor;\\n\\n\\t\\t\\t},\\n\\t\\t\\tsetClearColor: function ( color, alpha ) {\\n\\n\\t\\t\\t\\tclearColor.set( color );\\n\\t\\t\\t\\tclearAlpha = alpha !== undefined ? alpha : 1;\\n\\t\\t\\t\\tsetClear( clearColor, clearAlpha );\\n\\n\\t\\t\\t},\\n\\t\\t\\tgetClearAlpha: function () {\\n\\n\\t\\t\\t\\treturn clearAlpha;\\n\\n\\t\\t\\t},\\n\\t\\t\\tsetClearAlpha: function ( alpha ) {\\n\\n\\t\\t\\t\\tclearAlpha = alpha;\\n\\t\\t\\t\\tsetClear( clearColor, clearAlpha );\\n\\n\\t\\t\\t},\\n\\t\\t\\trender: render\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction painterSortStable( a, b ) {\\n\\n\\t\\tif ( a.renderOrder !== b.renderOrder ) {\\n\\n\\t\\t\\treturn a.renderOrder - b.renderOrder;\\n\\n\\t\\t} else if ( a.program && b.program && a.program !== b.program ) {\\n\\n\\t\\t\\treturn a.program.id - b.program.id;\\n\\n\\t\\t} else if ( a.material.id !== b.material.id ) {\\n\\n\\t\\t\\treturn a.material.id - b.material.id;\\n\\n\\t\\t} else if ( a.z !== b.z ) {\\n\\n\\t\\t\\treturn a.z - b.z;\\n\\n\\t\\t} else {\\n\\n\\t\\t\\treturn a.id - b.id;\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tfunction reversePainterSortStable( a, b ) {\\n\\n\\t\\tif ( a.renderOrder !== b.renderOrder ) {\\n\\n\\t\\t\\treturn a.renderOrder - b.renderOrder;\\n\\n\\t\\t} if ( a.z !== b.z ) {\\n\\n\\t\\t\\treturn b.z - a.z;\\n\\n\\t\\t} else {\\n\\n\\t\\t\\treturn a.id - b.id;\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tfunction WebGLRenderList() {\\n\\n\\t\\tvar renderItems = [];\\n\\t\\tvar renderItemsIndex = 0;\\n\\n\\t\\tvar opaque = [];\\n\\t\\tvar transparent = [];\\n\\n\\t\\tfunction init() {\\n\\n\\t\\t\\trenderItemsIndex = 0;\\n\\n\\t\\t\\topaque.length = 0;\\n\\t\\t\\ttransparent.length = 0;\\n\\n\\t\\t}\\n\\n\\t\\tfunction push( object, geometry, material, z, group ) {\\n\\n\\t\\t\\tvar renderItem = renderItems[ renderItemsIndex ];\\n\\n\\t\\t\\tif ( renderItem === undefined ) {\\n\\n\\t\\t\\t\\trenderItem = {\\n\\t\\t\\t\\t\\tid: object.id,\\n\\t\\t\\t\\t\\tobject: object,\\n\\t\\t\\t\\t\\tgeometry: geometry,\\n\\t\\t\\t\\t\\tmaterial: material,\\n\\t\\t\\t\\t\\tprogram: material.program,\\n\\t\\t\\t\\t\\trenderOrder: object.renderOrder,\\n\\t\\t\\t\\t\\tz: z,\\n\\t\\t\\t\\t\\tgroup: group\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\trenderItems[ renderItemsIndex ] = renderItem;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\trenderItem.id = object.id;\\n\\t\\t\\t\\trenderItem.object = object;\\n\\t\\t\\t\\trenderItem.geometry = geometry;\\n\\t\\t\\t\\trenderItem.material = material;\\n\\t\\t\\t\\trenderItem.program = material.program;\\n\\t\\t\\t\\trenderItem.renderOrder = object.renderOrder;\\n\\t\\t\\t\\trenderItem.z = z;\\n\\t\\t\\t\\trenderItem.group = group;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t( material.transparent === true ? transparent : opaque ).push( renderItem );\\n\\n\\t\\t\\trenderItemsIndex ++;\\n\\n\\t\\t}\\n\\n\\t\\tfunction sort() {\\n\\n\\t\\t\\tif ( opaque.length > 1 ) opaque.sort( painterSortStable );\\n\\t\\t\\tif ( transparent.length > 1 ) transparent.sort( reversePainterSortStable );\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\t\\t\\topaque: opaque,\\n\\t\\t\\ttransparent: transparent,\\n\\n\\t\\t\\tinit: init,\\n\\t\\t\\tpush: push,\\n\\n\\t\\t\\tsort: sort\\n\\t\\t};\\n\\n\\t}\\n\\n\\tfunction WebGLRenderLists() {\\n\\n\\t\\tvar lists = {};\\n\\n\\t\\tfunction get( scene, camera ) {\\n\\n\\t\\t\\tvar hash = scene.id + ',' + camera.id;\\n\\t\\t\\tvar list = lists[ hash ];\\n\\n\\t\\t\\tif ( list === undefined ) {\\n\\n\\t\\t\\t\\t// console.log( 'THREE.WebGLRenderLists:', hash );\\n\\n\\t\\t\\t\\tlist = new WebGLRenderList();\\n\\t\\t\\t\\tlists[ hash ] = list;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn list;\\n\\n\\t\\t}\\n\\n\\t\\tfunction dispose() {\\n\\n\\t\\t\\tlists = {};\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\t\\t\\tget: get,\\n\\t\\t\\tdispose: dispose\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction absNumericalSort( a, b ) {\\n\\n\\t\\treturn Math.abs( b[ 1 ] ) - Math.abs( a[ 1 ] );\\n\\n\\t}\\n\\n\\tfunction WebGLMorphtargets( gl ) {\\n\\n\\t\\tvar influencesList = {};\\n\\t\\tvar morphInfluences = new Float32Array( 8 );\\n\\n\\t\\tfunction update( object, geometry, material, program ) {\\n\\n\\t\\t\\tvar objectInfluences = object.morphTargetInfluences;\\n\\n\\t\\t\\tvar length = objectInfluences.length;\\n\\n\\t\\t\\tvar influences = influencesList[ geometry.id ];\\n\\n\\t\\t\\tif ( influences === undefined ) {\\n\\n\\t\\t\\t\\t// initialise list\\n\\n\\t\\t\\t\\tinfluences = [];\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tinfluences[ i ] = [ i, 0 ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tinfluencesList[ geometry.id ] = influences;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar morphTargets = material.morphTargets && geometry.morphAttributes.position;\\n\\t\\t\\tvar morphNormals = material.morphNormals && geometry.morphAttributes.normal;\\n\\n\\t\\t\\t// Remove current morphAttributes\\n\\n\\t\\t\\tfor ( var i = 0; i < length; i ++ ) {\\n\\n\\t\\t\\t\\tvar influence = influences[ i ];\\n\\n\\t\\t\\t\\tif ( influence[ 1 ] !== 0 ) {\\n\\n\\t\\t\\t\\t\\tif ( morphTargets ) geometry.removeAttribute( 'morphTarget' + i );\\n\\t\\t\\t\\t\\tif ( morphNormals ) geometry.removeAttribute( 'morphNormal' + i );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Collect influences\\n\\n\\t\\t\\tfor ( var i = 0; i < length; i ++ ) {\\n\\n\\t\\t\\t\\tvar influence = influences[ i ];\\n\\n\\t\\t\\t\\tinfluence[ 0 ] = i;\\n\\t\\t\\t\\tinfluence[ 1 ] = objectInfluences[ i ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tinfluences.sort( absNumericalSort );\\n\\n\\t\\t\\t// Add morphAttributes\\n\\n\\t\\t\\tfor ( var i = 0; i < 8; i ++ ) {\\n\\n\\t\\t\\t\\tvar influence = influences[ i ];\\n\\n\\t\\t\\t\\tif ( influence ) {\\n\\n\\t\\t\\t\\t\\tvar index = influence[ 0 ];\\n\\t\\t\\t\\t\\tvar value = influence[ 1 ];\\n\\n\\t\\t\\t\\t\\tif ( value ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( morphTargets ) geometry.addAttribute( 'morphTarget' + i, morphTargets[ index ] );\\n\\t\\t\\t\\t\\t\\tif ( morphNormals ) geometry.addAttribute( 'morphNormal' + i, morphNormals[ index ] );\\n\\n\\t\\t\\t\\t\\t\\tmorphInfluences[ i ] = value;\\n\\t\\t\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tmorphInfluences[ i ] = 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tprogram.getUniforms().setValue( gl, 'morphTargetInfluences', morphInfluences );\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tupdate: update\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLIndexedBufferRenderer( gl, extensions, infoRender ) {\\n\\n\\t\\tvar mode;\\n\\n\\t\\tfunction setMode( value ) {\\n\\n\\t\\t\\tmode = value;\\n\\n\\t\\t}\\n\\n\\t\\tvar type, bytesPerElement;\\n\\n\\t\\tfunction setIndex( value ) {\\n\\n\\t\\t\\ttype = value.type;\\n\\t\\t\\tbytesPerElement = value.bytesPerElement;\\n\\n\\t\\t}\\n\\n\\t\\tfunction render( start, count ) {\\n\\n\\t\\t\\tgl.drawElements( mode, count, type, start * bytesPerElement );\\n\\n\\t\\t\\tinfoRender.calls ++;\\n\\t\\t\\tinfoRender.vertices += count;\\n\\n\\t\\t\\tif ( mode === gl.TRIANGLES ) infoRender.faces += count / 3;\\n\\t\\t\\telse if ( mode === gl.POINTS ) infoRender.points += count;\\n\\n\\t\\t}\\n\\n\\t\\tfunction renderInstances( geometry, start, count ) {\\n\\n\\t\\t\\tvar extension = extensions.get( 'ANGLE_instanced_arrays' );\\n\\n\\t\\t\\tif ( extension === null ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.WebGLIndexedBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\textension.drawElementsInstancedANGLE( mode, count, type, start * bytesPerElement, geometry.maxInstancedCount );\\n\\n\\t\\t\\tinfoRender.calls ++;\\n\\t\\t\\tinfoRender.vertices += count * geometry.maxInstancedCount;\\n\\n\\t\\t\\tif ( mode === gl.TRIANGLES ) infoRender.faces += geometry.maxInstancedCount * count / 3;\\n\\t\\t\\telse if ( mode === gl.POINTS ) infoRender.points += geometry.maxInstancedCount * count;\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tthis.setMode = setMode;\\n\\t\\tthis.setIndex = setIndex;\\n\\t\\tthis.render = render;\\n\\t\\tthis.renderInstances = renderInstances;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLBufferRenderer( gl, extensions, infoRender ) {\\n\\n\\t\\tvar mode;\\n\\n\\t\\tfunction setMode( value ) {\\n\\n\\t\\t\\tmode = value;\\n\\n\\t\\t}\\n\\n\\t\\tfunction render( start, count ) {\\n\\n\\t\\t\\tgl.drawArrays( mode, start, count );\\n\\n\\t\\t\\tinfoRender.calls ++;\\n\\t\\t\\tinfoRender.vertices += count;\\n\\n\\t\\t\\tif ( mode === gl.TRIANGLES ) infoRender.faces += count / 3;\\n\\t\\t\\telse if ( mode === gl.POINTS ) infoRender.points += count;\\n\\n\\t\\t}\\n\\n\\t\\tfunction renderInstances( geometry, start, count ) {\\n\\n\\t\\t\\tvar extension = extensions.get( 'ANGLE_instanced_arrays' );\\n\\n\\t\\t\\tif ( extension === null ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar position = geometry.attributes.position;\\n\\n\\t\\t\\tif ( position.isInterleavedBufferAttribute ) {\\n\\n\\t\\t\\t\\tcount = position.data.count;\\n\\n\\t\\t\\t\\textension.drawArraysInstancedANGLE( mode, 0, count, geometry.maxInstancedCount );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\textension.drawArraysInstancedANGLE( mode, start, count, geometry.maxInstancedCount );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tinfoRender.calls ++;\\n\\t\\t\\tinfoRender.vertices += count * geometry.maxInstancedCount;\\n\\n\\t\\t\\tif ( mode === gl.TRIANGLES ) infoRender.faces += geometry.maxInstancedCount * count / 3;\\n\\t\\t\\telse if ( mode === gl.POINTS ) infoRender.points += geometry.maxInstancedCount * count;\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tthis.setMode = setMode;\\n\\t\\tthis.render = render;\\n\\t\\tthis.renderInstances = renderInstances;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLGeometries( gl, attributes, infoMemory ) {\\n\\n\\t\\tvar geometries = {};\\n\\t\\tvar wireframeAttributes = {};\\n\\n\\t\\tfunction onGeometryDispose( event ) {\\n\\n\\t\\t\\tvar geometry = event.target;\\n\\t\\t\\tvar buffergeometry = geometries[ geometry.id ];\\n\\n\\t\\t\\tif ( buffergeometry.index !== null ) {\\n\\n\\t\\t\\t\\tattributes.remove( buffergeometry.index );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var name in buffergeometry.attributes ) {\\n\\n\\t\\t\\t\\tattributes.remove( buffergeometry.attributes[ name ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tgeometry.removeEventListener( 'dispose', onGeometryDispose );\\n\\n\\t\\t\\tdelete geometries[ geometry.id ];\\n\\n\\t\\t\\t// TODO Remove duplicate code\\n\\n\\t\\t\\tvar attribute = wireframeAttributes[ geometry.id ];\\n\\n\\t\\t\\tif ( attribute ) {\\n\\n\\t\\t\\t\\tattributes.remove( attribute );\\n\\t\\t\\t\\tdelete wireframeAttributes[ geometry.id ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tattribute = wireframeAttributes[ buffergeometry.id ];\\n\\n\\t\\t\\tif ( attribute ) {\\n\\n\\t\\t\\t\\tattributes.remove( attribute );\\n\\t\\t\\t\\tdelete wireframeAttributes[ buffergeometry.id ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tinfoMemory.geometries --;\\n\\n\\t\\t}\\n\\n\\t\\tfunction get( object, geometry ) {\\n\\n\\t\\t\\tvar buffergeometry = geometries[ geometry.id ];\\n\\n\\t\\t\\tif ( buffergeometry ) return buffergeometry;\\n\\n\\t\\t\\tgeometry.addEventListener( 'dispose', onGeometryDispose );\\n\\n\\t\\t\\tif ( geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\tbuffergeometry = geometry;\\n\\n\\t\\t\\t} else if ( geometry.isGeometry ) {\\n\\n\\t\\t\\t\\tif ( geometry._bufferGeometry === undefined ) {\\n\\n\\t\\t\\t\\t\\tgeometry._bufferGeometry = new BufferGeometry().setFromObject( object );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tbuffergeometry = geometry._bufferGeometry;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tgeometries[ geometry.id ] = buffergeometry;\\n\\n\\t\\t\\tinfoMemory.geometries ++;\\n\\n\\t\\t\\treturn buffergeometry;\\n\\n\\t\\t}\\n\\n\\t\\tfunction update( geometry ) {\\n\\n\\t\\t\\tvar index = geometry.index;\\n\\t\\t\\tvar geometryAttributes = geometry.attributes;\\n\\n\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\tattributes.update( index, gl.ELEMENT_ARRAY_BUFFER );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var name in geometryAttributes ) {\\n\\n\\t\\t\\t\\tattributes.update( geometryAttributes[ name ], gl.ARRAY_BUFFER );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// morph targets\\n\\n\\t\\t\\tvar morphAttributes = geometry.morphAttributes;\\n\\n\\t\\t\\tfor ( var name in morphAttributes ) {\\n\\n\\t\\t\\t\\tvar array = morphAttributes[ name ];\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = array.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tattributes.update( array[ i ], gl.ARRAY_BUFFER );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction getWireframeAttribute( geometry ) {\\n\\n\\t\\t\\tvar attribute = wireframeAttributes[ geometry.id ];\\n\\n\\t\\t\\tif ( attribute ) return attribute;\\n\\n\\t\\t\\tvar indices = [];\\n\\n\\t\\t\\tvar geometryIndex = geometry.index;\\n\\t\\t\\tvar geometryAttributes = geometry.attributes;\\n\\n\\t\\t\\t// console.time( 'wireframe' );\\n\\n\\t\\t\\tif ( geometryIndex !== null ) {\\n\\n\\t\\t\\t\\tvar array = geometryIndex.array;\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = array.length; i < l; i += 3 ) {\\n\\n\\t\\t\\t\\t\\tvar a = array[ i + 0 ];\\n\\t\\t\\t\\t\\tvar b = array[ i + 1 ];\\n\\t\\t\\t\\t\\tvar c = array[ i + 2 ];\\n\\n\\t\\t\\t\\t\\tindices.push( a, b, b, c, c, a );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tvar array = geometryAttributes.position.array;\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = ( array.length / 3 ) - 1; i < l; i += 3 ) {\\n\\n\\t\\t\\t\\t\\tvar a = i + 0;\\n\\t\\t\\t\\t\\tvar b = i + 1;\\n\\t\\t\\t\\t\\tvar c = i + 2;\\n\\n\\t\\t\\t\\t\\tindices.push( a, b, b, c, c, a );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// console.timeEnd( 'wireframe' );\\n\\n\\t\\t\\tattribute = new ( arrayMax( indices ) > 65535 ? Uint32BufferAttribute : Uint16BufferAttribute )( indices, 1 );\\n\\n\\t\\t\\tattributes.update( attribute, gl.ELEMENT_ARRAY_BUFFER );\\n\\n\\t\\t\\twireframeAttributes[ geometry.id ] = attribute;\\n\\n\\t\\t\\treturn attribute;\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tget: get,\\n\\t\\t\\tupdate: update,\\n\\n\\t\\t\\tgetWireframeAttribute: getWireframeAttribute\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction UniformsCache() {\\n\\n\\t\\tvar lights = {};\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tget: function ( light ) {\\n\\n\\t\\t\\t\\tif ( lights[ light.id ] !== undefined ) {\\n\\n\\t\\t\\t\\t\\treturn lights[ light.id ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar uniforms;\\n\\n\\t\\t\\t\\tswitch ( light.type ) {\\n\\n\\t\\t\\t\\t\\tcase 'DirectionalLight':\\n\\t\\t\\t\\t\\t\\tuniforms = {\\n\\t\\t\\t\\t\\t\\t\\tdirection: new Vector3(),\\n\\t\\t\\t\\t\\t\\t\\tcolor: new Color(),\\n\\n\\t\\t\\t\\t\\t\\t\\tshadow: false,\\n\\t\\t\\t\\t\\t\\t\\tshadowBias: 0,\\n\\t\\t\\t\\t\\t\\t\\tshadowRadius: 1,\\n\\t\\t\\t\\t\\t\\t\\tshadowMapSize: new Vector2()\\n\\t\\t\\t\\t\\t\\t};\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'SpotLight':\\n\\t\\t\\t\\t\\t\\tuniforms = {\\n\\t\\t\\t\\t\\t\\t\\tposition: new Vector3(),\\n\\t\\t\\t\\t\\t\\t\\tdirection: new Vector3(),\\n\\t\\t\\t\\t\\t\\t\\tcolor: new Color(),\\n\\t\\t\\t\\t\\t\\t\\tdistance: 0,\\n\\t\\t\\t\\t\\t\\t\\tconeCos: 0,\\n\\t\\t\\t\\t\\t\\t\\tpenumbraCos: 0,\\n\\t\\t\\t\\t\\t\\t\\tdecay: 0,\\n\\n\\t\\t\\t\\t\\t\\t\\tshadow: false,\\n\\t\\t\\t\\t\\t\\t\\tshadowBias: 0,\\n\\t\\t\\t\\t\\t\\t\\tshadowRadius: 1,\\n\\t\\t\\t\\t\\t\\t\\tshadowMapSize: new Vector2()\\n\\t\\t\\t\\t\\t\\t};\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'PointLight':\\n\\t\\t\\t\\t\\t\\tuniforms = {\\n\\t\\t\\t\\t\\t\\t\\tposition: new Vector3(),\\n\\t\\t\\t\\t\\t\\t\\tcolor: new Color(),\\n\\t\\t\\t\\t\\t\\t\\tdistance: 0,\\n\\t\\t\\t\\t\\t\\t\\tdecay: 0,\\n\\n\\t\\t\\t\\t\\t\\t\\tshadow: false,\\n\\t\\t\\t\\t\\t\\t\\tshadowBias: 0,\\n\\t\\t\\t\\t\\t\\t\\tshadowRadius: 1,\\n\\t\\t\\t\\t\\t\\t\\tshadowMapSize: new Vector2(),\\n\\t\\t\\t\\t\\t\\t\\tshadowCameraNear: 1,\\n\\t\\t\\t\\t\\t\\t\\tshadowCameraFar: 1000\\n\\t\\t\\t\\t\\t\\t};\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'HemisphereLight':\\n\\t\\t\\t\\t\\t\\tuniforms = {\\n\\t\\t\\t\\t\\t\\t\\tdirection: new Vector3(),\\n\\t\\t\\t\\t\\t\\t\\tskyColor: new Color(),\\n\\t\\t\\t\\t\\t\\t\\tgroundColor: new Color()\\n\\t\\t\\t\\t\\t\\t};\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'RectAreaLight':\\n\\t\\t\\t\\t\\t\\tuniforms = {\\n\\t\\t\\t\\t\\t\\t\\tcolor: new Color(),\\n\\t\\t\\t\\t\\t\\t\\tposition: new Vector3(),\\n\\t\\t\\t\\t\\t\\t\\thalfWidth: new Vector3(),\\n\\t\\t\\t\\t\\t\\t\\thalfHeight: new Vector3()\\n\\t\\t\\t\\t\\t\\t\\t// TODO (abelnation): set RectAreaLight shadow uniforms\\n\\t\\t\\t\\t\\t\\t};\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tlights[ light.id ] = uniforms;\\n\\n\\t\\t\\t\\treturn uniforms;\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\tfunction WebGLLights() {\\n\\n\\t\\tvar cache = new UniformsCache();\\n\\n\\t\\tvar state = {\\n\\n\\t\\t\\thash: '',\\n\\n\\t\\t\\tambient: [ 0, 0, 0 ],\\n\\t\\t\\tdirectional: [],\\n\\t\\t\\tdirectionalShadowMap: [],\\n\\t\\t\\tdirectionalShadowMatrix: [],\\n\\t\\t\\tspot: [],\\n\\t\\t\\tspotShadowMap: [],\\n\\t\\t\\tspotShadowMatrix: [],\\n\\t\\t\\trectArea: [],\\n\\t\\t\\tpoint: [],\\n\\t\\t\\tpointShadowMap: [],\\n\\t\\t\\tpointShadowMatrix: [],\\n\\t\\t\\themi: []\\n\\n\\t\\t};\\n\\n\\t\\tvar vector3 = new Vector3();\\n\\t\\tvar matrix4 = new Matrix4();\\n\\t\\tvar matrix42 = new Matrix4();\\n\\n\\t\\tfunction setup( lights, shadows, camera ) {\\n\\n\\t\\t\\tvar r = 0, g = 0, b = 0;\\n\\n\\t\\t\\tvar directionalLength = 0;\\n\\t\\t\\tvar pointLength = 0;\\n\\t\\t\\tvar spotLength = 0;\\n\\t\\t\\tvar rectAreaLength = 0;\\n\\t\\t\\tvar hemiLength = 0;\\n\\n\\t\\t\\tvar viewMatrix = camera.matrixWorldInverse;\\n\\n\\t\\t\\tfor ( var i = 0, l = lights.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar light = lights[ i ];\\n\\n\\t\\t\\t\\tvar color = light.color;\\n\\t\\t\\t\\tvar intensity = light.intensity;\\n\\t\\t\\t\\tvar distance = light.distance;\\n\\n\\t\\t\\t\\tvar shadowMap = ( light.shadow && light.shadow.map ) ? light.shadow.map.texture : null;\\n\\n\\t\\t\\t\\tif ( light.isAmbientLight ) {\\n\\n\\t\\t\\t\\t\\tr += color.r * intensity;\\n\\t\\t\\t\\t\\tg += color.g * intensity;\\n\\t\\t\\t\\t\\tb += color.b * intensity;\\n\\n\\t\\t\\t\\t} else if ( light.isDirectionalLight ) {\\n\\n\\t\\t\\t\\t\\tvar uniforms = cache.get( light );\\n\\n\\t\\t\\t\\t\\tuniforms.color.copy( light.color ).multiplyScalar( light.intensity );\\n\\t\\t\\t\\t\\tuniforms.direction.setFromMatrixPosition( light.matrixWorld );\\n\\t\\t\\t\\t\\tvector3.setFromMatrixPosition( light.target.matrixWorld );\\n\\t\\t\\t\\t\\tuniforms.direction.sub( vector3 );\\n\\t\\t\\t\\t\\tuniforms.direction.transformDirection( viewMatrix );\\n\\n\\t\\t\\t\\t\\tuniforms.shadow = light.castShadow;\\n\\n\\t\\t\\t\\t\\tif ( light.castShadow ) {\\n\\n\\t\\t\\t\\t\\t\\tvar shadow = light.shadow;\\n\\n\\t\\t\\t\\t\\t\\tuniforms.shadowBias = shadow.bias;\\n\\t\\t\\t\\t\\t\\tuniforms.shadowRadius = shadow.radius;\\n\\t\\t\\t\\t\\t\\tuniforms.shadowMapSize = shadow.mapSize;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tstate.directionalShadowMap[ directionalLength ] = shadowMap;\\n\\t\\t\\t\\t\\tstate.directionalShadowMatrix[ directionalLength ] = light.shadow.matrix;\\n\\t\\t\\t\\t\\tstate.directional[ directionalLength ] = uniforms;\\n\\n\\t\\t\\t\\t\\tdirectionalLength ++;\\n\\n\\t\\t\\t\\t} else if ( light.isSpotLight ) {\\n\\n\\t\\t\\t\\t\\tvar uniforms = cache.get( light );\\n\\n\\t\\t\\t\\t\\tuniforms.position.setFromMatrixPosition( light.matrixWorld );\\n\\t\\t\\t\\t\\tuniforms.position.applyMatrix4( viewMatrix );\\n\\n\\t\\t\\t\\t\\tuniforms.color.copy( color ).multiplyScalar( intensity );\\n\\t\\t\\t\\t\\tuniforms.distance = distance;\\n\\n\\t\\t\\t\\t\\tuniforms.direction.setFromMatrixPosition( light.matrixWorld );\\n\\t\\t\\t\\t\\tvector3.setFromMatrixPosition( light.target.matrixWorld );\\n\\t\\t\\t\\t\\tuniforms.direction.sub( vector3 );\\n\\t\\t\\t\\t\\tuniforms.direction.transformDirection( viewMatrix );\\n\\n\\t\\t\\t\\t\\tuniforms.coneCos = Math.cos( light.angle );\\n\\t\\t\\t\\t\\tuniforms.penumbraCos = Math.cos( light.angle * ( 1 - light.penumbra ) );\\n\\t\\t\\t\\t\\tuniforms.decay = ( light.distance === 0 ) ? 0.0 : light.decay;\\n\\n\\t\\t\\t\\t\\tuniforms.shadow = light.castShadow;\\n\\n\\t\\t\\t\\t\\tif ( light.castShadow ) {\\n\\n\\t\\t\\t\\t\\t\\tvar shadow = light.shadow;\\n\\n\\t\\t\\t\\t\\t\\tuniforms.shadowBias = shadow.bias;\\n\\t\\t\\t\\t\\t\\tuniforms.shadowRadius = shadow.radius;\\n\\t\\t\\t\\t\\t\\tuniforms.shadowMapSize = shadow.mapSize;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tstate.spotShadowMap[ spotLength ] = shadowMap;\\n\\t\\t\\t\\t\\tstate.spotShadowMatrix[ spotLength ] = light.shadow.matrix;\\n\\t\\t\\t\\t\\tstate.spot[ spotLength ] = uniforms;\\n\\n\\t\\t\\t\\t\\tspotLength ++;\\n\\n\\t\\t\\t\\t} else if ( light.isRectAreaLight ) {\\n\\n\\t\\t\\t\\t\\tvar uniforms = cache.get( light );\\n\\n\\t\\t\\t\\t\\t// (a) intensity controls irradiance of entire light\\n\\t\\t\\t\\t\\tuniforms.color\\n\\t\\t\\t\\t\\t\\t.copy( color )\\n\\t\\t\\t\\t\\t\\t.multiplyScalar( intensity / ( light.width * light.height ) );\\n\\n\\t\\t\\t\\t\\t// (b) intensity controls the radiance per light area\\n\\t\\t\\t\\t\\t// uniforms.color.copy( color ).multiplyScalar( intensity );\\n\\n\\t\\t\\t\\t\\tuniforms.position.setFromMatrixPosition( light.matrixWorld );\\n\\t\\t\\t\\t\\tuniforms.position.applyMatrix4( viewMatrix );\\n\\n\\t\\t\\t\\t\\t// extract local rotation of light to derive width/height half vectors\\n\\t\\t\\t\\t\\tmatrix42.identity();\\n\\t\\t\\t\\t\\tmatrix4.copy( light.matrixWorld );\\n\\t\\t\\t\\t\\tmatrix4.premultiply( viewMatrix );\\n\\t\\t\\t\\t\\tmatrix42.extractRotation( matrix4 );\\n\\n\\t\\t\\t\\t\\tuniforms.halfWidth.set( light.width * 0.5, 0.0, 0.0 );\\n\\t\\t\\t\\t\\tuniforms.halfHeight.set( 0.0, light.height * 0.5, 0.0 );\\n\\n\\t\\t\\t\\t\\tuniforms.halfWidth.applyMatrix4( matrix42 );\\n\\t\\t\\t\\t\\tuniforms.halfHeight.applyMatrix4( matrix42 );\\n\\n\\t\\t\\t\\t\\t// TODO (abelnation): RectAreaLight distance?\\n\\t\\t\\t\\t\\t// uniforms.distance = distance;\\n\\n\\t\\t\\t\\t\\tstate.rectArea[ rectAreaLength ] = uniforms;\\n\\n\\t\\t\\t\\t\\trectAreaLength ++;\\n\\n\\t\\t\\t\\t} else if ( light.isPointLight ) {\\n\\n\\t\\t\\t\\t\\tvar uniforms = cache.get( light );\\n\\n\\t\\t\\t\\t\\tuniforms.position.setFromMatrixPosition( light.matrixWorld );\\n\\t\\t\\t\\t\\tuniforms.position.applyMatrix4( viewMatrix );\\n\\n\\t\\t\\t\\t\\tuniforms.color.copy( light.color ).multiplyScalar( light.intensity );\\n\\t\\t\\t\\t\\tuniforms.distance = light.distance;\\n\\t\\t\\t\\t\\tuniforms.decay = ( light.distance === 0 ) ? 0.0 : light.decay;\\n\\n\\t\\t\\t\\t\\tuniforms.shadow = light.castShadow;\\n\\n\\t\\t\\t\\t\\tif ( light.castShadow ) {\\n\\n\\t\\t\\t\\t\\t\\tvar shadow = light.shadow;\\n\\n\\t\\t\\t\\t\\t\\tuniforms.shadowBias = shadow.bias;\\n\\t\\t\\t\\t\\t\\tuniforms.shadowRadius = shadow.radius;\\n\\t\\t\\t\\t\\t\\tuniforms.shadowMapSize = shadow.mapSize;\\n\\t\\t\\t\\t\\t\\tuniforms.shadowCameraNear = shadow.camera.near;\\n\\t\\t\\t\\t\\t\\tuniforms.shadowCameraFar = shadow.camera.far;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tstate.pointShadowMap[ pointLength ] = shadowMap;\\n\\t\\t\\t\\t\\tstate.pointShadowMatrix[ pointLength ] = light.shadow.matrix;\\n\\t\\t\\t\\t\\tstate.point[ pointLength ] = uniforms;\\n\\n\\t\\t\\t\\t\\tpointLength ++;\\n\\n\\t\\t\\t\\t} else if ( light.isHemisphereLight ) {\\n\\n\\t\\t\\t\\t\\tvar uniforms = cache.get( light );\\n\\n\\t\\t\\t\\t\\tuniforms.direction.setFromMatrixPosition( light.matrixWorld );\\n\\t\\t\\t\\t\\tuniforms.direction.transformDirection( viewMatrix );\\n\\t\\t\\t\\t\\tuniforms.direction.normalize();\\n\\n\\t\\t\\t\\t\\tuniforms.skyColor.copy( light.color ).multiplyScalar( intensity );\\n\\t\\t\\t\\t\\tuniforms.groundColor.copy( light.groundColor ).multiplyScalar( intensity );\\n\\n\\t\\t\\t\\t\\tstate.hemi[ hemiLength ] = uniforms;\\n\\n\\t\\t\\t\\t\\themiLength ++;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tstate.ambient[ 0 ] = r;\\n\\t\\t\\tstate.ambient[ 1 ] = g;\\n\\t\\t\\tstate.ambient[ 2 ] = b;\\n\\n\\t\\t\\tstate.directional.length = directionalLength;\\n\\t\\t\\tstate.spot.length = spotLength;\\n\\t\\t\\tstate.rectArea.length = rectAreaLength;\\n\\t\\t\\tstate.point.length = pointLength;\\n\\t\\t\\tstate.hemi.length = hemiLength;\\n\\n\\t\\t\\t// TODO (sam-g-steel) why aren't we using join\\n\\t\\t\\tstate.hash = directionalLength + ',' + pointLength + ',' + spotLength + ',' + rectAreaLength + ',' + hemiLength + ',' + shadows.length;\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\t\\t\\tsetup: setup,\\n\\t\\t\\tstate: state\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLObjects( geometries, infoRender ) {\\n\\n\\t\\tvar updateList = {};\\n\\n\\t\\tfunction update( object ) {\\n\\n\\t\\t\\tvar frame = infoRender.frame;\\n\\n\\t\\t\\tvar geometry = object.geometry;\\n\\t\\t\\tvar buffergeometry = geometries.get( object, geometry );\\n\\n\\t\\t\\t// Update once per frame\\n\\n\\t\\t\\tif ( updateList[ buffergeometry.id ] !== frame ) {\\n\\n\\t\\t\\t\\tif ( geometry.isGeometry ) {\\n\\n\\t\\t\\t\\t\\tbuffergeometry.updateFromObject( object );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometries.update( buffergeometry );\\n\\n\\t\\t\\t\\tupdateList[ buffergeometry.id ] = frame;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn buffergeometry;\\n\\n\\t\\t}\\n\\n\\t\\tfunction clear() {\\n\\n\\t\\t\\tupdateList = {};\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tupdate: update,\\n\\t\\t\\tclear: clear\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction addLineNumbers( string ) {\\n\\n\\t\\tvar lines = string.split( '\\\\n' );\\n\\n\\t\\tfor ( var i = 0; i < lines.length; i ++ ) {\\n\\n\\t\\t\\tlines[ i ] = ( i + 1 ) + ': ' + lines[ i ];\\n\\n\\t\\t}\\n\\n\\t\\treturn lines.join( '\\\\n' );\\n\\n\\t}\\n\\n\\tfunction WebGLShader( gl, type, string ) {\\n\\n\\t\\tvar shader = gl.createShader( type );\\n\\n\\t\\tgl.shaderSource( shader, string );\\n\\t\\tgl.compileShader( shader );\\n\\n\\t\\tif ( gl.getShaderParameter( shader, gl.COMPILE_STATUS ) === false ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.WebGLShader: Shader couldn\\\\'t compile.' );\\n\\n\\t\\t}\\n\\n\\t\\tif ( gl.getShaderInfoLog( shader ) !== '' ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLShader: gl.getShaderInfoLog()', type === gl.VERTEX_SHADER ? 'vertex' : 'fragment', gl.getShaderInfoLog( shader ), addLineNumbers( string ) );\\n\\n\\t\\t}\\n\\n\\t\\t// --enable-privileged-webgl-extension\\n\\t\\t// console.log( type, gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( shader ) );\\n\\n\\t\\treturn shader;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tvar programIdCount = 0;\\n\\n\\tfunction getEncodingComponents( encoding ) {\\n\\n\\t\\tswitch ( encoding ) {\\n\\n\\t\\t\\tcase LinearEncoding:\\n\\t\\t\\t\\treturn [ 'Linear', '( value )' ];\\n\\t\\t\\tcase sRGBEncoding:\\n\\t\\t\\t\\treturn [ 'sRGB', '( value )' ];\\n\\t\\t\\tcase RGBEEncoding:\\n\\t\\t\\t\\treturn [ 'RGBE', '( value )' ];\\n\\t\\t\\tcase RGBM7Encoding:\\n\\t\\t\\t\\treturn [ 'RGBM', '( value, 7.0 )' ];\\n\\t\\t\\tcase RGBM16Encoding:\\n\\t\\t\\t\\treturn [ 'RGBM', '( value, 16.0 )' ];\\n\\t\\t\\tcase RGBDEncoding:\\n\\t\\t\\t\\treturn [ 'RGBD', '( value, 256.0 )' ];\\n\\t\\t\\tcase GammaEncoding:\\n\\t\\t\\t\\treturn [ 'Gamma', '( value, float( GAMMA_FACTOR ) )' ];\\n\\t\\t\\tdefault:\\n\\t\\t\\t\\tthrow new Error( 'unsupported encoding: ' + encoding );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tfunction getTexelDecodingFunction( functionName, encoding ) {\\n\\n\\t\\tvar components = getEncodingComponents( encoding );\\n\\t\\treturn 'vec4 ' + functionName + '( vec4 value ) { return ' + components[ 0 ] + 'ToLinear' + components[ 1 ] + '; }';\\n\\n\\t}\\n\\n\\tfunction getTexelEncodingFunction( functionName, encoding ) {\\n\\n\\t\\tvar components = getEncodingComponents( encoding );\\n\\t\\treturn 'vec4 ' + functionName + '( vec4 value ) { return LinearTo' + components[ 0 ] + components[ 1 ] + '; }';\\n\\n\\t}\\n\\n\\tfunction getToneMappingFunction( functionName, toneMapping ) {\\n\\n\\t\\tvar toneMappingName;\\n\\n\\t\\tswitch ( toneMapping ) {\\n\\n\\t\\t\\tcase LinearToneMapping:\\n\\t\\t\\t\\ttoneMappingName = 'Linear';\\n\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\tcase ReinhardToneMapping:\\n\\t\\t\\t\\ttoneMappingName = 'Reinhard';\\n\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\tcase Uncharted2ToneMapping:\\n\\t\\t\\t\\ttoneMappingName = 'Uncharted2';\\n\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\tcase CineonToneMapping:\\n\\t\\t\\t\\ttoneMappingName = 'OptimizedCineon';\\n\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\tdefault:\\n\\t\\t\\t\\tthrow new Error( 'unsupported toneMapping: ' + toneMapping );\\n\\n\\t\\t}\\n\\n\\t\\treturn 'vec3 ' + functionName + '( vec3 color ) { return ' + toneMappingName + 'ToneMapping( color ); }';\\n\\n\\t}\\n\\n\\tfunction generateExtensions( extensions, parameters, rendererExtensions ) {\\n\\n\\t\\textensions = extensions || {};\\n\\n\\t\\tvar chunks = [\\n\\t\\t\\t( extensions.derivatives || parameters.envMapCubeUV || parameters.bumpMap || parameters.normalMap || parameters.flatShading ) ? '#extension GL_OES_standard_derivatives : enable' : '',\\n\\t\\t\\t( extensions.fragDepth || parameters.logarithmicDepthBuffer ) && rendererExtensions.get( 'EXT_frag_depth' ) ? '#extension GL_EXT_frag_depth : enable' : '',\\n\\t\\t\\t( extensions.drawBuffers ) && rendererExtensions.get( 'WEBGL_draw_buffers' ) ? '#extension GL_EXT_draw_buffers : require' : '',\\n\\t\\t\\t( extensions.shaderTextureLOD || parameters.envMap ) && rendererExtensions.get( 'EXT_shader_texture_lod' ) ? '#extension GL_EXT_shader_texture_lod : enable' : ''\\n\\t\\t];\\n\\n\\t\\treturn chunks.filter( filterEmptyLine ).join( '\\\\n' );\\n\\n\\t}\\n\\n\\tfunction generateDefines( defines ) {\\n\\n\\t\\tvar chunks = [];\\n\\n\\t\\tfor ( var name in defines ) {\\n\\n\\t\\t\\tvar value = defines[ name ];\\n\\n\\t\\t\\tif ( value === false ) continue;\\n\\n\\t\\t\\tchunks.push( '#define ' + name + ' ' + value );\\n\\n\\t\\t}\\n\\n\\t\\treturn chunks.join( '\\\\n' );\\n\\n\\t}\\n\\n\\tfunction fetchAttributeLocations( gl, program ) {\\n\\n\\t\\tvar attributes = {};\\n\\n\\t\\tvar n = gl.getProgramParameter( program, gl.ACTIVE_ATTRIBUTES );\\n\\n\\t\\tfor ( var i = 0; i < n; i ++ ) {\\n\\n\\t\\t\\tvar info = gl.getActiveAttrib( program, i );\\n\\t\\t\\tvar name = info.name;\\n\\n\\t\\t\\t// console.log( 'THREE.WebGLProgram: ACTIVE VERTEX ATTRIBUTE:', name, i );\\n\\n\\t\\t\\tattributes[ name ] = gl.getAttribLocation( program, name );\\n\\n\\t\\t}\\n\\n\\t\\treturn attributes;\\n\\n\\t}\\n\\n\\tfunction filterEmptyLine( string ) {\\n\\n\\t\\treturn string !== '';\\n\\n\\t}\\n\\n\\tfunction replaceLightNums( string, parameters ) {\\n\\n\\t\\treturn string\\n\\t\\t\\t.replace( /NUM_DIR_LIGHTS/g, parameters.numDirLights )\\n\\t\\t\\t.replace( /NUM_SPOT_LIGHTS/g, parameters.numSpotLights )\\n\\t\\t\\t.replace( /NUM_RECT_AREA_LIGHTS/g, parameters.numRectAreaLights )\\n\\t\\t\\t.replace( /NUM_POINT_LIGHTS/g, parameters.numPointLights )\\n\\t\\t\\t.replace( /NUM_HEMI_LIGHTS/g, parameters.numHemiLights );\\n\\n\\t}\\n\\n\\tfunction parseIncludes( string ) {\\n\\n\\t\\tvar pattern = /^[ \\\\t]*#include +<([\\\\w\\\\d.]+)>/gm;\\n\\n\\t\\tfunction replace( match, include ) {\\n\\n\\t\\t\\tvar replace = ShaderChunk[ include ];\\n\\n\\t\\t\\tif ( replace === undefined ) {\\n\\n\\t\\t\\t\\tthrow new Error( 'Can not resolve #include <' + include + '>' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn parseIncludes( replace );\\n\\n\\t\\t}\\n\\n\\t\\treturn string.replace( pattern, replace );\\n\\n\\t}\\n\\n\\tfunction unrollLoops( string ) {\\n\\n\\t\\tvar pattern = /for \\\\( int i \\\\= (\\\\d+)\\\\; i < (\\\\d+)\\\\; i \\\\+\\\\+ \\\\) \\\\{([\\\\s\\\\S]+?)(?=\\\\})\\\\}/g;\\n\\n\\t\\tfunction replace( match, start, end, snippet ) {\\n\\n\\t\\t\\tvar unroll = '';\\n\\n\\t\\t\\tfor ( var i = parseInt( start ); i < parseInt( end ); i ++ ) {\\n\\n\\t\\t\\t\\tunroll += snippet.replace( /\\\\[ i \\\\]/g, '[ ' + i + ' ]' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn unroll;\\n\\n\\t\\t}\\n\\n\\t\\treturn string.replace( pattern, replace );\\n\\n\\t}\\n\\n\\tfunction WebGLProgram( renderer, extensions, code, material, shader, parameters ) {\\n\\n\\t\\tvar gl = renderer.context;\\n\\n\\t\\tvar defines = material.defines;\\n\\n\\t\\tvar vertexShader = shader.vertexShader;\\n\\t\\tvar fragmentShader = shader.fragmentShader;\\n\\n\\t\\tvar shadowMapTypeDefine = 'SHADOWMAP_TYPE_BASIC';\\n\\n\\t\\tif ( parameters.shadowMapType === PCFShadowMap ) {\\n\\n\\t\\t\\tshadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF';\\n\\n\\t\\t} else if ( parameters.shadowMapType === PCFSoftShadowMap ) {\\n\\n\\t\\t\\tshadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF_SOFT';\\n\\n\\t\\t}\\n\\n\\t\\tvar envMapTypeDefine = 'ENVMAP_TYPE_CUBE';\\n\\t\\tvar envMapModeDefine = 'ENVMAP_MODE_REFLECTION';\\n\\t\\tvar envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY';\\n\\n\\t\\tif ( parameters.envMap ) {\\n\\n\\t\\t\\tswitch ( material.envMap.mapping ) {\\n\\n\\t\\t\\t\\tcase CubeReflectionMapping:\\n\\t\\t\\t\\tcase CubeRefractionMapping:\\n\\t\\t\\t\\t\\tenvMapTypeDefine = 'ENVMAP_TYPE_CUBE';\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\tcase CubeUVReflectionMapping:\\n\\t\\t\\t\\tcase CubeUVRefractionMapping:\\n\\t\\t\\t\\t\\tenvMapTypeDefine = 'ENVMAP_TYPE_CUBE_UV';\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\tcase EquirectangularReflectionMapping:\\n\\t\\t\\t\\tcase EquirectangularRefractionMapping:\\n\\t\\t\\t\\t\\tenvMapTypeDefine = 'ENVMAP_TYPE_EQUIREC';\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\tcase SphericalReflectionMapping:\\n\\t\\t\\t\\t\\tenvMapTypeDefine = 'ENVMAP_TYPE_SPHERE';\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tswitch ( material.envMap.mapping ) {\\n\\n\\t\\t\\t\\tcase CubeRefractionMapping:\\n\\t\\t\\t\\tcase EquirectangularRefractionMapping:\\n\\t\\t\\t\\t\\tenvMapModeDefine = 'ENVMAP_MODE_REFRACTION';\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tswitch ( material.combine ) {\\n\\n\\t\\t\\t\\tcase MultiplyOperation:\\n\\t\\t\\t\\t\\tenvMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY';\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\tcase MixOperation:\\n\\t\\t\\t\\t\\tenvMapBlendingDefine = 'ENVMAP_BLENDING_MIX';\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\tcase AddOperation:\\n\\t\\t\\t\\t\\tenvMapBlendingDefine = 'ENVMAP_BLENDING_ADD';\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tvar gammaFactorDefine = ( renderer.gammaFactor > 0 ) ? renderer.gammaFactor : 1.0;\\n\\n\\t\\t// console.log( 'building new program ' );\\n\\n\\t\\t//\\n\\n\\t\\tvar customExtensions = generateExtensions( material.extensions, parameters, extensions );\\n\\n\\t\\tvar customDefines = generateDefines( defines );\\n\\n\\t\\t//\\n\\n\\t\\tvar program = gl.createProgram();\\n\\n\\t\\tvar prefixVertex, prefixFragment;\\n\\n\\t\\tif ( material.isRawShaderMaterial ) {\\n\\n\\t\\t\\tprefixVertex = [\\n\\n\\t\\t\\t\\tcustomDefines\\n\\n\\t\\t\\t].filter( filterEmptyLine ).join( '\\\\n' );\\n\\n\\t\\t\\tif ( prefixVertex.length > 0 ) {\\n\\n\\t\\t\\t\\tprefixVertex += '\\\\n';\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tprefixFragment = [\\n\\n\\t\\t\\t\\tcustomExtensions,\\n\\t\\t\\t\\tcustomDefines\\n\\n\\t\\t\\t].filter( filterEmptyLine ).join( '\\\\n' );\\n\\n\\t\\t\\tif ( prefixFragment.length > 0 ) {\\n\\n\\t\\t\\t\\tprefixFragment += '\\\\n';\\n\\n\\t\\t\\t}\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tprefixVertex = [\\n\\n\\t\\t\\t\\t'precision ' + parameters.precision + ' float;',\\n\\t\\t\\t\\t'precision ' + parameters.precision + ' int;',\\n\\n\\t\\t\\t\\t'#define SHADER_NAME ' + shader.name,\\n\\n\\t\\t\\t\\tcustomDefines,\\n\\n\\t\\t\\t\\tparameters.supportsVertexTextures ? '#define VERTEX_TEXTURES' : '',\\n\\n\\t\\t\\t\\t'#define GAMMA_FACTOR ' + gammaFactorDefine,\\n\\n\\t\\t\\t\\t'#define MAX_BONES ' + parameters.maxBones,\\n\\t\\t\\t\\t( parameters.useFog && parameters.fog ) ? '#define USE_FOG' : '',\\n\\t\\t\\t\\t( parameters.useFog && parameters.fogExp ) ? '#define FOG_EXP2' : '',\\n\\n\\t\\t\\t\\tparameters.map ? '#define USE_MAP' : '',\\n\\t\\t\\t\\tparameters.envMap ? '#define USE_ENVMAP' : '',\\n\\t\\t\\t\\tparameters.envMap ? '#define ' + envMapModeDefine : '',\\n\\t\\t\\t\\tparameters.lightMap ? '#define USE_LIGHTMAP' : '',\\n\\t\\t\\t\\tparameters.aoMap ? '#define USE_AOMAP' : '',\\n\\t\\t\\t\\tparameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',\\n\\t\\t\\t\\tparameters.bumpMap ? '#define USE_BUMPMAP' : '',\\n\\t\\t\\t\\tparameters.normalMap ? '#define USE_NORMALMAP' : '',\\n\\t\\t\\t\\tparameters.displacementMap && parameters.supportsVertexTextures ? '#define USE_DISPLACEMENTMAP' : '',\\n\\t\\t\\t\\tparameters.specularMap ? '#define USE_SPECULARMAP' : '',\\n\\t\\t\\t\\tparameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',\\n\\t\\t\\t\\tparameters.metalnessMap ? '#define USE_METALNESSMAP' : '',\\n\\t\\t\\t\\tparameters.alphaMap ? '#define USE_ALPHAMAP' : '',\\n\\t\\t\\t\\tparameters.vertexColors ? '#define USE_COLOR' : '',\\n\\n\\t\\t\\t\\tparameters.flatShading ? '#define FLAT_SHADED' : '',\\n\\n\\t\\t\\t\\tparameters.skinning ? '#define USE_SKINNING' : '',\\n\\t\\t\\t\\tparameters.useVertexTexture ? '#define BONE_TEXTURE' : '',\\n\\n\\t\\t\\t\\tparameters.morphTargets ? '#define USE_MORPHTARGETS' : '',\\n\\t\\t\\t\\tparameters.morphNormals && parameters.flatShading === false ? '#define USE_MORPHNORMALS' : '',\\n\\t\\t\\t\\tparameters.doubleSided ? '#define DOUBLE_SIDED' : '',\\n\\t\\t\\t\\tparameters.flipSided ? '#define FLIP_SIDED' : '',\\n\\n\\t\\t\\t\\t'#define NUM_CLIPPING_PLANES ' + parameters.numClippingPlanes,\\n\\n\\t\\t\\t\\tparameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',\\n\\t\\t\\t\\tparameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',\\n\\n\\t\\t\\t\\tparameters.sizeAttenuation ? '#define USE_SIZEATTENUATION' : '',\\n\\n\\t\\t\\t\\tparameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',\\n\\t\\t\\t\\tparameters.logarithmicDepthBuffer && extensions.get( 'EXT_frag_depth' ) ? '#define USE_LOGDEPTHBUF_EXT' : '',\\n\\n\\t\\t\\t\\t'uniform mat4 modelMatrix;',\\n\\t\\t\\t\\t'uniform mat4 modelViewMatrix;',\\n\\t\\t\\t\\t'uniform mat4 projectionMatrix;',\\n\\t\\t\\t\\t'uniform mat4 viewMatrix;',\\n\\t\\t\\t\\t'uniform mat3 normalMatrix;',\\n\\t\\t\\t\\t'uniform vec3 cameraPosition;',\\n\\n\\t\\t\\t\\t'attribute vec3 position;',\\n\\t\\t\\t\\t'attribute vec3 normal;',\\n\\t\\t\\t\\t'attribute vec2 uv;',\\n\\n\\t\\t\\t\\t'#ifdef USE_COLOR',\\n\\n\\t\\t\\t\\t'\\tattribute vec3 color;',\\n\\n\\t\\t\\t\\t'#endif',\\n\\n\\t\\t\\t\\t'#ifdef USE_MORPHTARGETS',\\n\\n\\t\\t\\t\\t'\\tattribute vec3 morphTarget0;',\\n\\t\\t\\t\\t'\\tattribute vec3 morphTarget1;',\\n\\t\\t\\t\\t'\\tattribute vec3 morphTarget2;',\\n\\t\\t\\t\\t'\\tattribute vec3 morphTarget3;',\\n\\n\\t\\t\\t\\t'\\t#ifdef USE_MORPHNORMALS',\\n\\n\\t\\t\\t\\t'\\t\\tattribute vec3 morphNormal0;',\\n\\t\\t\\t\\t'\\t\\tattribute vec3 morphNormal1;',\\n\\t\\t\\t\\t'\\t\\tattribute vec3 morphNormal2;',\\n\\t\\t\\t\\t'\\t\\tattribute vec3 morphNormal3;',\\n\\n\\t\\t\\t\\t'\\t#else',\\n\\n\\t\\t\\t\\t'\\t\\tattribute vec3 morphTarget4;',\\n\\t\\t\\t\\t'\\t\\tattribute vec3 morphTarget5;',\\n\\t\\t\\t\\t'\\t\\tattribute vec3 morphTarget6;',\\n\\t\\t\\t\\t'\\t\\tattribute vec3 morphTarget7;',\\n\\n\\t\\t\\t\\t'\\t#endif',\\n\\n\\t\\t\\t\\t'#endif',\\n\\n\\t\\t\\t\\t'#ifdef USE_SKINNING',\\n\\n\\t\\t\\t\\t'\\tattribute vec4 skinIndex;',\\n\\t\\t\\t\\t'\\tattribute vec4 skinWeight;',\\n\\n\\t\\t\\t\\t'#endif',\\n\\n\\t\\t\\t\\t'\\\\n'\\n\\n\\t\\t\\t].filter( filterEmptyLine ).join( '\\\\n' );\\n\\n\\t\\t\\tprefixFragment = [\\n\\n\\t\\t\\t\\tcustomExtensions,\\n\\n\\t\\t\\t\\t'precision ' + parameters.precision + ' float;',\\n\\t\\t\\t\\t'precision ' + parameters.precision + ' int;',\\n\\n\\t\\t\\t\\t'#define SHADER_NAME ' + shader.name,\\n\\n\\t\\t\\t\\tcustomDefines,\\n\\n\\t\\t\\t\\tparameters.alphaTest ? '#define ALPHATEST ' + parameters.alphaTest : '',\\n\\n\\t\\t\\t\\t'#define GAMMA_FACTOR ' + gammaFactorDefine,\\n\\n\\t\\t\\t\\t( parameters.useFog && parameters.fog ) ? '#define USE_FOG' : '',\\n\\t\\t\\t\\t( parameters.useFog && parameters.fogExp ) ? '#define FOG_EXP2' : '',\\n\\n\\t\\t\\t\\tparameters.map ? '#define USE_MAP' : '',\\n\\t\\t\\t\\tparameters.envMap ? '#define USE_ENVMAP' : '',\\n\\t\\t\\t\\tparameters.envMap ? '#define ' + envMapTypeDefine : '',\\n\\t\\t\\t\\tparameters.envMap ? '#define ' + envMapModeDefine : '',\\n\\t\\t\\t\\tparameters.envMap ? '#define ' + envMapBlendingDefine : '',\\n\\t\\t\\t\\tparameters.lightMap ? '#define USE_LIGHTMAP' : '',\\n\\t\\t\\t\\tparameters.aoMap ? '#define USE_AOMAP' : '',\\n\\t\\t\\t\\tparameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',\\n\\t\\t\\t\\tparameters.bumpMap ? '#define USE_BUMPMAP' : '',\\n\\t\\t\\t\\tparameters.normalMap ? '#define USE_NORMALMAP' : '',\\n\\t\\t\\t\\tparameters.specularMap ? '#define USE_SPECULARMAP' : '',\\n\\t\\t\\t\\tparameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',\\n\\t\\t\\t\\tparameters.metalnessMap ? '#define USE_METALNESSMAP' : '',\\n\\t\\t\\t\\tparameters.alphaMap ? '#define USE_ALPHAMAP' : '',\\n\\t\\t\\t\\tparameters.vertexColors ? '#define USE_COLOR' : '',\\n\\n\\t\\t\\t\\tparameters.gradientMap ? '#define USE_GRADIENTMAP' : '',\\n\\n\\t\\t\\t\\tparameters.flatShading ? '#define FLAT_SHADED' : '',\\n\\n\\t\\t\\t\\tparameters.doubleSided ? '#define DOUBLE_SIDED' : '',\\n\\t\\t\\t\\tparameters.flipSided ? '#define FLIP_SIDED' : '',\\n\\n\\t\\t\\t\\t'#define NUM_CLIPPING_PLANES ' + parameters.numClippingPlanes,\\n\\t\\t\\t\\t'#define UNION_CLIPPING_PLANES ' + ( parameters.numClippingPlanes - parameters.numClipIntersection ),\\n\\n\\t\\t\\t\\tparameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',\\n\\t\\t\\t\\tparameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',\\n\\n\\t\\t\\t\\tparameters.premultipliedAlpha ? '#define PREMULTIPLIED_ALPHA' : '',\\n\\n\\t\\t\\t\\tparameters.physicallyCorrectLights ? '#define PHYSICALLY_CORRECT_LIGHTS' : '',\\n\\n\\t\\t\\t\\tparameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',\\n\\t\\t\\t\\tparameters.logarithmicDepthBuffer && extensions.get( 'EXT_frag_depth' ) ? '#define USE_LOGDEPTHBUF_EXT' : '',\\n\\n\\t\\t\\t\\tparameters.envMap && extensions.get( 'EXT_shader_texture_lod' ) ? '#define TEXTURE_LOD_EXT' : '',\\n\\n\\t\\t\\t\\t'uniform mat4 viewMatrix;',\\n\\t\\t\\t\\t'uniform vec3 cameraPosition;',\\n\\n\\t\\t\\t\\t( parameters.toneMapping !== NoToneMapping ) ? '#define TONE_MAPPING' : '',\\n\\t\\t\\t\\t( parameters.toneMapping !== NoToneMapping ) ? ShaderChunk[ 'tonemapping_pars_fragment' ] : '', // this code is required here because it is used by the toneMapping() function defined below\\n\\t\\t\\t\\t( parameters.toneMapping !== NoToneMapping ) ? getToneMappingFunction( 'toneMapping', parameters.toneMapping ) : '',\\n\\n\\t\\t\\t\\tparameters.dithering ? '#define DITHERING' : '',\\n\\n\\t\\t\\t\\t( parameters.outputEncoding || parameters.mapEncoding || parameters.envMapEncoding || parameters.emissiveMapEncoding ) ? ShaderChunk[ 'encodings_pars_fragment' ] : '', // this code is required here because it is used by the various encoding/decoding function defined below\\n\\t\\t\\t\\tparameters.mapEncoding ? getTexelDecodingFunction( 'mapTexelToLinear', parameters.mapEncoding ) : '',\\n\\t\\t\\t\\tparameters.envMapEncoding ? getTexelDecodingFunction( 'envMapTexelToLinear', parameters.envMapEncoding ) : '',\\n\\t\\t\\t\\tparameters.emissiveMapEncoding ? getTexelDecodingFunction( 'emissiveMapTexelToLinear', parameters.emissiveMapEncoding ) : '',\\n\\t\\t\\t\\tparameters.outputEncoding ? getTexelEncodingFunction( 'linearToOutputTexel', parameters.outputEncoding ) : '',\\n\\n\\t\\t\\t\\tparameters.depthPacking ? '#define DEPTH_PACKING ' + material.depthPacking : '',\\n\\n\\t\\t\\t\\t'\\\\n'\\n\\n\\t\\t\\t].filter( filterEmptyLine ).join( '\\\\n' );\\n\\n\\t\\t}\\n\\n\\t\\tvertexShader = parseIncludes( vertexShader );\\n\\t\\tvertexShader = replaceLightNums( vertexShader, parameters );\\n\\n\\t\\tfragmentShader = parseIncludes( fragmentShader );\\n\\t\\tfragmentShader = replaceLightNums( fragmentShader, parameters );\\n\\n\\t\\tif ( ! material.isShaderMaterial ) {\\n\\n\\t\\t\\tvertexShader = unrollLoops( vertexShader );\\n\\t\\t\\tfragmentShader = unrollLoops( fragmentShader );\\n\\n\\t\\t}\\n\\n\\t\\tvar vertexGlsl = prefixVertex + vertexShader;\\n\\t\\tvar fragmentGlsl = prefixFragment + fragmentShader;\\n\\n\\t\\t// console.log( '*VERTEX*', vertexGlsl );\\n\\t\\t// console.log( '*FRAGMENT*', fragmentGlsl );\\n\\n\\t\\tvar glVertexShader = WebGLShader( gl, gl.VERTEX_SHADER, vertexGlsl );\\n\\t\\tvar glFragmentShader = WebGLShader( gl, gl.FRAGMENT_SHADER, fragmentGlsl );\\n\\n\\t\\tgl.attachShader( program, glVertexShader );\\n\\t\\tgl.attachShader( program, glFragmentShader );\\n\\n\\t\\t// Force a particular attribute to index 0.\\n\\n\\t\\tif ( material.index0AttributeName !== undefined ) {\\n\\n\\t\\t\\tgl.bindAttribLocation( program, 0, material.index0AttributeName );\\n\\n\\t\\t} else if ( parameters.morphTargets === true ) {\\n\\n\\t\\t\\t// programs with morphTargets displace position out of attribute 0\\n\\t\\t\\tgl.bindAttribLocation( program, 0, 'position' );\\n\\n\\t\\t}\\n\\n\\t\\tgl.linkProgram( program );\\n\\n\\t\\tvar programLog = gl.getProgramInfoLog( program );\\n\\t\\tvar vertexLog = gl.getShaderInfoLog( glVertexShader );\\n\\t\\tvar fragmentLog = gl.getShaderInfoLog( glFragmentShader );\\n\\n\\t\\tvar runnable = true;\\n\\t\\tvar haveDiagnostics = true;\\n\\n\\t\\t// console.log( '**VERTEX**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( glVertexShader ) );\\n\\t\\t// console.log( '**FRAGMENT**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( glFragmentShader ) );\\n\\n\\t\\tif ( gl.getProgramParameter( program, gl.LINK_STATUS ) === false ) {\\n\\n\\t\\t\\trunnable = false;\\n\\n\\t\\t\\tconsole.error( 'THREE.WebGLProgram: shader error: ', gl.getError(), 'gl.VALIDATE_STATUS', gl.getProgramParameter( program, gl.VALIDATE_STATUS ), 'gl.getProgramInfoLog', programLog, vertexLog, fragmentLog );\\n\\n\\t\\t} else if ( programLog !== '' ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLProgram: gl.getProgramInfoLog()', programLog );\\n\\n\\t\\t} else if ( vertexLog === '' || fragmentLog === '' ) {\\n\\n\\t\\t\\thaveDiagnostics = false;\\n\\n\\t\\t}\\n\\n\\t\\tif ( haveDiagnostics ) {\\n\\n\\t\\t\\tthis.diagnostics = {\\n\\n\\t\\t\\t\\trunnable: runnable,\\n\\t\\t\\t\\tmaterial: material,\\n\\n\\t\\t\\t\\tprogramLog: programLog,\\n\\n\\t\\t\\t\\tvertexShader: {\\n\\n\\t\\t\\t\\t\\tlog: vertexLog,\\n\\t\\t\\t\\t\\tprefix: prefixVertex\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfragmentShader: {\\n\\n\\t\\t\\t\\t\\tlog: fragmentLog,\\n\\t\\t\\t\\t\\tprefix: prefixFragment\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}\\n\\n\\t\\t// clean up\\n\\n\\t\\tgl.deleteShader( glVertexShader );\\n\\t\\tgl.deleteShader( glFragmentShader );\\n\\n\\t\\t// set up caching for uniform locations\\n\\n\\t\\tvar cachedUniforms;\\n\\n\\t\\tthis.getUniforms = function () {\\n\\n\\t\\t\\tif ( cachedUniforms === undefined ) {\\n\\n\\t\\t\\t\\tcachedUniforms = new WebGLUniforms( gl, program, renderer );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn cachedUniforms;\\n\\n\\t\\t};\\n\\n\\t\\t// set up caching for attribute locations\\n\\n\\t\\tvar cachedAttributes;\\n\\n\\t\\tthis.getAttributes = function () {\\n\\n\\t\\t\\tif ( cachedAttributes === undefined ) {\\n\\n\\t\\t\\t\\tcachedAttributes = fetchAttributeLocations( gl, program );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn cachedAttributes;\\n\\n\\t\\t};\\n\\n\\t\\t// free resource\\n\\n\\t\\tthis.destroy = function () {\\n\\n\\t\\t\\tgl.deleteProgram( program );\\n\\t\\t\\tthis.program = undefined;\\n\\n\\t\\t};\\n\\n\\t\\t// DEPRECATED\\n\\n\\t\\tObject.defineProperties( this, {\\n\\n\\t\\t\\tuniforms: {\\n\\t\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLProgram: .uniforms is now .getUniforms().' );\\n\\t\\t\\t\\t\\treturn this.getUniforms();\\n\\n\\t\\t\\t\\t}\\n\\t\\t\\t},\\n\\n\\t\\t\\tattributes: {\\n\\t\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLProgram: .attributes is now .getAttributes().' );\\n\\t\\t\\t\\t\\treturn this.getAttributes();\\n\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\n\\t\\t} );\\n\\n\\n\\t\\t//\\n\\n\\t\\tthis.id = programIdCount ++;\\n\\t\\tthis.code = code;\\n\\t\\tthis.usedTimes = 1;\\n\\t\\tthis.program = program;\\n\\t\\tthis.vertexShader = glVertexShader;\\n\\t\\tthis.fragmentShader = glFragmentShader;\\n\\n\\t\\treturn this;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLPrograms( renderer, extensions, capabilities ) {\\n\\n\\t\\tvar programs = [];\\n\\n\\t\\tvar shaderIDs = {\\n\\t\\t\\tMeshDepthMaterial: 'depth',\\n\\t\\t\\tMeshDistanceMaterial: 'distanceRGBA',\\n\\t\\t\\tMeshNormalMaterial: 'normal',\\n\\t\\t\\tMeshBasicMaterial: 'basic',\\n\\t\\t\\tMeshLambertMaterial: 'lambert',\\n\\t\\t\\tMeshPhongMaterial: 'phong',\\n\\t\\t\\tMeshToonMaterial: 'phong',\\n\\t\\t\\tMeshStandardMaterial: 'physical',\\n\\t\\t\\tMeshPhysicalMaterial: 'physical',\\n\\t\\t\\tLineBasicMaterial: 'basic',\\n\\t\\t\\tLineDashedMaterial: 'dashed',\\n\\t\\t\\tPointsMaterial: 'points',\\n\\t\\t\\tShadowMaterial: 'shadow'\\n\\t\\t};\\n\\n\\t\\tvar parameterNames = [\\n\\t\\t\\t\\\"precision\\\", \\\"supportsVertexTextures\\\", \\\"map\\\", \\\"mapEncoding\\\", \\\"envMap\\\", \\\"envMapMode\\\", \\\"envMapEncoding\\\",\\n\\t\\t\\t\\\"lightMap\\\", \\\"aoMap\\\", \\\"emissiveMap\\\", \\\"emissiveMapEncoding\\\", \\\"bumpMap\\\", \\\"normalMap\\\", \\\"displacementMap\\\", \\\"specularMap\\\",\\n\\t\\t\\t\\\"roughnessMap\\\", \\\"metalnessMap\\\", \\\"gradientMap\\\",\\n\\t\\t\\t\\\"alphaMap\\\", \\\"combine\\\", \\\"vertexColors\\\", \\\"fog\\\", \\\"useFog\\\", \\\"fogExp\\\",\\n\\t\\t\\t\\\"flatShading\\\", \\\"sizeAttenuation\\\", \\\"logarithmicDepthBuffer\\\", \\\"skinning\\\",\\n\\t\\t\\t\\\"maxBones\\\", \\\"useVertexTexture\\\", \\\"morphTargets\\\", \\\"morphNormals\\\",\\n\\t\\t\\t\\\"maxMorphTargets\\\", \\\"maxMorphNormals\\\", \\\"premultipliedAlpha\\\",\\n\\t\\t\\t\\\"numDirLights\\\", \\\"numPointLights\\\", \\\"numSpotLights\\\", \\\"numHemiLights\\\", \\\"numRectAreaLights\\\",\\n\\t\\t\\t\\\"shadowMapEnabled\\\", \\\"shadowMapType\\\", \\\"toneMapping\\\", 'physicallyCorrectLights',\\n\\t\\t\\t\\\"alphaTest\\\", \\\"doubleSided\\\", \\\"flipSided\\\", \\\"numClippingPlanes\\\", \\\"numClipIntersection\\\", \\\"depthPacking\\\", \\\"dithering\\\"\\n\\t\\t];\\n\\n\\n\\t\\tfunction allocateBones( object ) {\\n\\n\\t\\t\\tvar skeleton = object.skeleton;\\n\\t\\t\\tvar bones = skeleton.bones;\\n\\n\\t\\t\\tif ( capabilities.floatVertexTextures ) {\\n\\n\\t\\t\\t\\treturn 1024;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// default for when object is not specified\\n\\t\\t\\t\\t// ( for example when prebuilding shader to be used with multiple objects )\\n\\t\\t\\t\\t//\\n\\t\\t\\t\\t//  - leave some extra space for other uniforms\\n\\t\\t\\t\\t//  - limit here is ANGLE's 254 max uniform vectors\\n\\t\\t\\t\\t//    (up to 54 should be safe)\\n\\n\\t\\t\\t\\tvar nVertexUniforms = capabilities.maxVertexUniforms;\\n\\t\\t\\t\\tvar nVertexMatrices = Math.floor( ( nVertexUniforms - 20 ) / 4 );\\n\\n\\t\\t\\t\\tvar maxBones = Math.min( nVertexMatrices, bones.length );\\n\\n\\t\\t\\t\\tif ( maxBones < bones.length ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Skeleton has ' + bones.length + ' bones. This GPU supports ' + maxBones + '.' );\\n\\t\\t\\t\\t\\treturn 0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn maxBones;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction getTextureEncodingFromMap( map, gammaOverrideLinear ) {\\n\\n\\t\\t\\tvar encoding;\\n\\n\\t\\t\\tif ( ! map ) {\\n\\n\\t\\t\\t\\tencoding = LinearEncoding;\\n\\n\\t\\t\\t} else if ( map.isTexture ) {\\n\\n\\t\\t\\t\\tencoding = map.encoding;\\n\\n\\t\\t\\t} else if ( map.isWebGLRenderTarget ) {\\n\\n\\t\\t\\t\\tconsole.warn( \\\"THREE.WebGLPrograms.getTextureEncodingFromMap: don't use render targets as textures. Use their .texture property instead.\\\" );\\n\\t\\t\\t\\tencoding = map.texture.encoding;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// add backwards compatibility for WebGLRenderer.gammaInput/gammaOutput parameter, should probably be removed at some point.\\n\\t\\t\\tif ( encoding === LinearEncoding && gammaOverrideLinear ) {\\n\\n\\t\\t\\t\\tencoding = GammaEncoding;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn encoding;\\n\\n\\t\\t}\\n\\n\\t\\tthis.getParameters = function ( material, lights, shadows, fog, nClipPlanes, nClipIntersection, object ) {\\n\\n\\t\\t\\tvar shaderID = shaderIDs[ material.type ];\\n\\n\\t\\t\\t// heuristics to create shader parameters according to lights in the scene\\n\\t\\t\\t// (not to blow over maxLights budget)\\n\\n\\t\\t\\tvar maxBones = object.isSkinnedMesh ? allocateBones( object ) : 0;\\n\\t\\t\\tvar precision = capabilities.precision;\\n\\n\\t\\t\\tif ( material.precision !== null ) {\\n\\n\\t\\t\\t\\tprecision = capabilities.getMaxPrecision( material.precision );\\n\\n\\t\\t\\t\\tif ( precision !== material.precision ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLProgram.getParameters:', material.precision, 'not supported, using', precision, 'instead.' );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar currentRenderTarget = renderer.getRenderTarget();\\n\\n\\t\\t\\tvar parameters = {\\n\\n\\t\\t\\t\\tshaderID: shaderID,\\n\\n\\t\\t\\t\\tprecision: precision,\\n\\t\\t\\t\\tsupportsVertexTextures: capabilities.vertexTextures,\\n\\t\\t\\t\\toutputEncoding: getTextureEncodingFromMap( ( ! currentRenderTarget ) ? null : currentRenderTarget.texture, renderer.gammaOutput ),\\n\\t\\t\\t\\tmap: !! material.map,\\n\\t\\t\\t\\tmapEncoding: getTextureEncodingFromMap( material.map, renderer.gammaInput ),\\n\\t\\t\\t\\tenvMap: !! material.envMap,\\n\\t\\t\\t\\tenvMapMode: material.envMap && material.envMap.mapping,\\n\\t\\t\\t\\tenvMapEncoding: getTextureEncodingFromMap( material.envMap, renderer.gammaInput ),\\n\\t\\t\\t\\tenvMapCubeUV: ( !! material.envMap ) && ( ( material.envMap.mapping === CubeUVReflectionMapping ) || ( material.envMap.mapping === CubeUVRefractionMapping ) ),\\n\\t\\t\\t\\tlightMap: !! material.lightMap,\\n\\t\\t\\t\\taoMap: !! material.aoMap,\\n\\t\\t\\t\\temissiveMap: !! material.emissiveMap,\\n\\t\\t\\t\\temissiveMapEncoding: getTextureEncodingFromMap( material.emissiveMap, renderer.gammaInput ),\\n\\t\\t\\t\\tbumpMap: !! material.bumpMap,\\n\\t\\t\\t\\tnormalMap: !! material.normalMap,\\n\\t\\t\\t\\tdisplacementMap: !! material.displacementMap,\\n\\t\\t\\t\\troughnessMap: !! material.roughnessMap,\\n\\t\\t\\t\\tmetalnessMap: !! material.metalnessMap,\\n\\t\\t\\t\\tspecularMap: !! material.specularMap,\\n\\t\\t\\t\\talphaMap: !! material.alphaMap,\\n\\n\\t\\t\\t\\tgradientMap: !! material.gradientMap,\\n\\n\\t\\t\\t\\tcombine: material.combine,\\n\\n\\t\\t\\t\\tvertexColors: material.vertexColors,\\n\\n\\t\\t\\t\\tfog: !! fog,\\n\\t\\t\\t\\tuseFog: material.fog,\\n\\t\\t\\t\\tfogExp: ( fog && fog.isFogExp2 ),\\n\\n\\t\\t\\t\\tflatShading: material.flatShading,\\n\\n\\t\\t\\t\\tsizeAttenuation: material.sizeAttenuation,\\n\\t\\t\\t\\tlogarithmicDepthBuffer: capabilities.logarithmicDepthBuffer,\\n\\n\\t\\t\\t\\tskinning: material.skinning && maxBones > 0,\\n\\t\\t\\t\\tmaxBones: maxBones,\\n\\t\\t\\t\\tuseVertexTexture: capabilities.floatVertexTextures,\\n\\n\\t\\t\\t\\tmorphTargets: material.morphTargets,\\n\\t\\t\\t\\tmorphNormals: material.morphNormals,\\n\\t\\t\\t\\tmaxMorphTargets: renderer.maxMorphTargets,\\n\\t\\t\\t\\tmaxMorphNormals: renderer.maxMorphNormals,\\n\\n\\t\\t\\t\\tnumDirLights: lights.directional.length,\\n\\t\\t\\t\\tnumPointLights: lights.point.length,\\n\\t\\t\\t\\tnumSpotLights: lights.spot.length,\\n\\t\\t\\t\\tnumRectAreaLights: lights.rectArea.length,\\n\\t\\t\\t\\tnumHemiLights: lights.hemi.length,\\n\\n\\t\\t\\t\\tnumClippingPlanes: nClipPlanes,\\n\\t\\t\\t\\tnumClipIntersection: nClipIntersection,\\n\\n\\t\\t\\t\\tdithering: material.dithering,\\n\\n\\t\\t\\t\\tshadowMapEnabled: renderer.shadowMap.enabled && object.receiveShadow && shadows.length > 0,\\n\\t\\t\\t\\tshadowMapType: renderer.shadowMap.type,\\n\\n\\t\\t\\t\\ttoneMapping: renderer.toneMapping,\\n\\t\\t\\t\\tphysicallyCorrectLights: renderer.physicallyCorrectLights,\\n\\n\\t\\t\\t\\tpremultipliedAlpha: material.premultipliedAlpha,\\n\\n\\t\\t\\t\\talphaTest: material.alphaTest,\\n\\t\\t\\t\\tdoubleSided: material.side === DoubleSide,\\n\\t\\t\\t\\tflipSided: material.side === BackSide,\\n\\n\\t\\t\\t\\tdepthPacking: ( material.depthPacking !== undefined ) ? material.depthPacking : false\\n\\n\\t\\t\\t};\\n\\n\\t\\t\\treturn parameters;\\n\\n\\t\\t};\\n\\n\\t\\tthis.getProgramCode = function ( material, parameters ) {\\n\\n\\t\\t\\tvar array = [];\\n\\n\\t\\t\\tif ( parameters.shaderID ) {\\n\\n\\t\\t\\t\\tarray.push( parameters.shaderID );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tarray.push( material.fragmentShader );\\n\\t\\t\\t\\tarray.push( material.vertexShader );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.defines !== undefined ) {\\n\\n\\t\\t\\t\\tfor ( var name in material.defines ) {\\n\\n\\t\\t\\t\\t\\tarray.push( name );\\n\\t\\t\\t\\t\\tarray.push( material.defines[ name ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = 0; i < parameterNames.length; i ++ ) {\\n\\n\\t\\t\\t\\tarray.push( parameters[ parameterNames[ i ] ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tarray.push( material.onBeforeCompile.toString() );\\n\\n\\t\\t\\tarray.push( renderer.gammaOutput );\\n\\n\\t\\t\\treturn array.join();\\n\\n\\t\\t};\\n\\n\\t\\tthis.acquireProgram = function ( material, shader, parameters, code ) {\\n\\n\\t\\t\\tvar program;\\n\\n\\t\\t\\t// Check if code has been already compiled\\n\\t\\t\\tfor ( var p = 0, pl = programs.length; p < pl; p ++ ) {\\n\\n\\t\\t\\t\\tvar programInfo = programs[ p ];\\n\\n\\t\\t\\t\\tif ( programInfo.code === code ) {\\n\\n\\t\\t\\t\\t\\tprogram = programInfo;\\n\\t\\t\\t\\t\\t++ program.usedTimes;\\n\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( program === undefined ) {\\n\\n\\t\\t\\t\\tprogram = new WebGLProgram( renderer, extensions, code, material, shader, parameters );\\n\\t\\t\\t\\tprograms.push( program );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn program;\\n\\n\\t\\t};\\n\\n\\t\\tthis.releaseProgram = function ( program ) {\\n\\n\\t\\t\\tif ( -- program.usedTimes === 0 ) {\\n\\n\\t\\t\\t\\t// Remove from unordered set\\n\\t\\t\\t\\tvar i = programs.indexOf( program );\\n\\t\\t\\t\\tprograms[ i ] = programs[ programs.length - 1 ];\\n\\t\\t\\t\\tprograms.pop();\\n\\n\\t\\t\\t\\t// Free WebGL resources\\n\\t\\t\\t\\tprogram.destroy();\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t\\t// Exposed for resource monitoring & error feedback via renderer.info:\\n\\t\\tthis.programs = programs;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLTextures( _gl, extensions, state, properties, capabilities, utils, infoMemory ) {\\n\\n\\t\\tvar _isWebGL2 = ( typeof WebGL2RenderingContext !== 'undefined' && _gl instanceof window.WebGL2RenderingContext );\\n\\t\\tvar _videoTextures = {};\\n\\n\\t\\t//\\n\\n\\t\\tfunction clampToMaxSize( image, maxSize ) {\\n\\n\\t\\t\\tif ( image.width > maxSize || image.height > maxSize ) {\\n\\n\\t\\t\\t\\t// Warning: Scaling through the canvas will only work with images that use\\n\\t\\t\\t\\t// premultiplied alpha.\\n\\n\\t\\t\\t\\tvar scale = maxSize / Math.max( image.width, image.height );\\n\\n\\t\\t\\t\\tvar canvas = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' );\\n\\t\\t\\t\\tcanvas.width = Math.floor( image.width * scale );\\n\\t\\t\\t\\tcanvas.height = Math.floor( image.height * scale );\\n\\n\\t\\t\\t\\tvar context = canvas.getContext( '2d' );\\n\\t\\t\\t\\tcontext.drawImage( image, 0, 0, image.width, image.height, 0, 0, canvas.width, canvas.height );\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: image is too big (' + image.width + 'x' + image.height + '). Resized to ' + canvas.width + 'x' + canvas.height, image );\\n\\n\\t\\t\\t\\treturn canvas;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn image;\\n\\n\\t\\t}\\n\\n\\t\\tfunction isPowerOfTwo( image ) {\\n\\n\\t\\t\\treturn _Math.isPowerOfTwo( image.width ) && _Math.isPowerOfTwo( image.height );\\n\\n\\t\\t}\\n\\n\\t\\tfunction makePowerOfTwo( image ) {\\n\\n\\t\\t\\tif ( image instanceof HTMLImageElement || image instanceof HTMLCanvasElement || image instanceof ImageBitmap ) {\\n\\n\\t\\t\\t\\tvar canvas = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' );\\n\\t\\t\\t\\tcanvas.width = _Math.floorPowerOfTwo( image.width );\\n\\t\\t\\t\\tcanvas.height = _Math.floorPowerOfTwo( image.height );\\n\\n\\t\\t\\t\\tvar context = canvas.getContext( '2d' );\\n\\t\\t\\t\\tcontext.drawImage( image, 0, 0, canvas.width, canvas.height );\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: image is not power of two (' + image.width + 'x' + image.height + '). Resized to ' + canvas.width + 'x' + canvas.height, image );\\n\\n\\t\\t\\t\\treturn canvas;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn image;\\n\\n\\t\\t}\\n\\n\\t\\tfunction textureNeedsPowerOfTwo( texture ) {\\n\\n\\t\\t\\treturn ( texture.wrapS !== ClampToEdgeWrapping || texture.wrapT !== ClampToEdgeWrapping ) ||\\n\\t\\t\\t\\t( texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter );\\n\\n\\t\\t}\\n\\n\\t\\tfunction textureNeedsGenerateMipmaps( texture, isPowerOfTwo ) {\\n\\n\\t\\t\\treturn texture.generateMipmaps && isPowerOfTwo &&\\n\\t\\t\\t\\ttexture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter;\\n\\n\\t\\t}\\n\\n\\t\\t// Fallback filters for non-power-of-2 textures\\n\\n\\t\\tfunction filterFallback( f ) {\\n\\n\\t\\t\\tif ( f === NearestFilter || f === NearestMipMapNearestFilter || f === NearestMipMapLinearFilter ) {\\n\\n\\t\\t\\t\\treturn _gl.NEAREST;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn _gl.LINEAR;\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tfunction onTextureDispose( event ) {\\n\\n\\t\\t\\tvar texture = event.target;\\n\\n\\t\\t\\ttexture.removeEventListener( 'dispose', onTextureDispose );\\n\\n\\t\\t\\tdeallocateTexture( texture );\\n\\n\\t\\t\\tif ( texture.isVideoTexture ) {\\n\\n\\t\\t\\t\\tdelete _videoTextures[ texture.id ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tinfoMemory.textures --;\\n\\n\\t\\t}\\n\\n\\t\\tfunction onRenderTargetDispose( event ) {\\n\\n\\t\\t\\tvar renderTarget = event.target;\\n\\n\\t\\t\\trenderTarget.removeEventListener( 'dispose', onRenderTargetDispose );\\n\\n\\t\\t\\tdeallocateRenderTarget( renderTarget );\\n\\n\\t\\t\\tinfoMemory.textures --;\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tfunction deallocateTexture( texture ) {\\n\\n\\t\\t\\tvar textureProperties = properties.get( texture );\\n\\n\\t\\t\\tif ( texture.image && textureProperties.__image__webglTextureCube ) {\\n\\n\\t\\t\\t\\t// cube texture\\n\\n\\t\\t\\t\\t_gl.deleteTexture( textureProperties.__image__webglTextureCube );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// 2D texture\\n\\n\\t\\t\\t\\tif ( textureProperties.__webglInit === undefined ) return;\\n\\n\\t\\t\\t\\t_gl.deleteTexture( textureProperties.__webglTexture );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// remove all webgl properties\\n\\t\\t\\tproperties.remove( texture );\\n\\n\\t\\t}\\n\\n\\t\\tfunction deallocateRenderTarget( renderTarget ) {\\n\\n\\t\\t\\tvar renderTargetProperties = properties.get( renderTarget );\\n\\t\\t\\tvar textureProperties = properties.get( renderTarget.texture );\\n\\n\\t\\t\\tif ( ! renderTarget ) return;\\n\\n\\t\\t\\tif ( textureProperties.__webglTexture !== undefined ) {\\n\\n\\t\\t\\t\\t_gl.deleteTexture( textureProperties.__webglTexture );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( renderTarget.depthTexture ) {\\n\\n\\t\\t\\t\\trenderTarget.depthTexture.dispose();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( renderTarget.isWebGLRenderTargetCube ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\t\\t_gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer[ i ] );\\n\\t\\t\\t\\t\\tif ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer[ i ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t_gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer );\\n\\t\\t\\t\\tif ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tproperties.remove( renderTarget.texture );\\n\\t\\t\\tproperties.remove( renderTarget );\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\n\\n\\t\\tfunction setTexture2D( texture, slot ) {\\n\\n\\t\\t\\tvar textureProperties = properties.get( texture );\\n\\n\\t\\t\\tif ( texture.version > 0 && textureProperties.__version !== texture.version ) {\\n\\n\\t\\t\\t\\tvar image = texture.image;\\n\\n\\t\\t\\t\\tif ( image === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Texture marked for update but image is undefined', texture );\\n\\n\\t\\t\\t\\t} else if ( image.complete === false ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Texture marked for update but image is incomplete', texture );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tuploadTexture( textureProperties, texture, slot );\\n\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tstate.activeTexture( _gl.TEXTURE0 + slot );\\n\\t\\t\\tstate.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture );\\n\\n\\t\\t}\\n\\n\\t\\tfunction setTextureCube( texture, slot ) {\\n\\n\\t\\t\\tvar textureProperties = properties.get( texture );\\n\\n\\t\\t\\tif ( texture.image.length === 6 ) {\\n\\n\\t\\t\\t\\tif ( texture.version > 0 && textureProperties.__version !== texture.version ) {\\n\\n\\t\\t\\t\\t\\tif ( ! textureProperties.__image__webglTextureCube ) {\\n\\n\\t\\t\\t\\t\\t\\ttexture.addEventListener( 'dispose', onTextureDispose );\\n\\n\\t\\t\\t\\t\\t\\ttextureProperties.__image__webglTextureCube = _gl.createTexture();\\n\\n\\t\\t\\t\\t\\t\\tinfoMemory.textures ++;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tstate.activeTexture( _gl.TEXTURE0 + slot );\\n\\t\\t\\t\\t\\tstate.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__image__webglTextureCube );\\n\\n\\t\\t\\t\\t\\t_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY );\\n\\n\\t\\t\\t\\t\\tvar isCompressed = ( texture && texture.isCompressedTexture );\\n\\t\\t\\t\\t\\tvar isDataTexture = ( texture.image[ 0 ] && texture.image[ 0 ].isDataTexture );\\n\\n\\t\\t\\t\\t\\tvar cubeImage = [];\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( ! isCompressed && ! isDataTexture ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tcubeImage[ i ] = clampToMaxSize( texture.image[ i ], capabilities.maxCubemapSize );\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tcubeImage[ i ] = isDataTexture ? texture.image[ i ].image : texture.image[ i ];\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tvar image = cubeImage[ 0 ],\\n\\t\\t\\t\\t\\t\\tisPowerOfTwoImage = isPowerOfTwo( image ),\\n\\t\\t\\t\\t\\t\\tglFormat = utils.convert( texture.format ),\\n\\t\\t\\t\\t\\t\\tglType = utils.convert( texture.type );\\n\\n\\t\\t\\t\\t\\tsetTextureParameters( _gl.TEXTURE_CUBE_MAP, texture, isPowerOfTwoImage );\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( ! isCompressed ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( isDataTexture ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glFormat, cubeImage[ i ].width, cubeImage[ i ].height, 0, glFormat, glType, cubeImage[ i ].data );\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glFormat, glFormat, glType, cubeImage[ i ] );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar mipmap, mipmaps = cubeImage[ i ].mipmaps;\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var j = 0, jl = mipmaps.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tmipmap = mipmaps[ j ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( texture.format !== RGBAFormat && texture.format !== RGBFormat ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif ( state.getCompressedTextureFormats().indexOf( glFormat ) > - 1 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tstate.compressedTexImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glFormat, mipmap.width, mipmap.height, 0, mipmap.data );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setTextureCube()' );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( textureNeedsGenerateMipmaps( texture, isPowerOfTwoImage ) ) {\\n\\n\\t\\t\\t\\t\\t\\t_gl.generateMipmap( _gl.TEXTURE_CUBE_MAP );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\ttextureProperties.__version = texture.version;\\n\\n\\t\\t\\t\\t\\tif ( texture.onUpdate ) texture.onUpdate( texture );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tstate.activeTexture( _gl.TEXTURE0 + slot );\\n\\t\\t\\t\\t\\tstate.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__image__webglTextureCube );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction setTextureCubeDynamic( texture, slot ) {\\n\\n\\t\\t\\tstate.activeTexture( _gl.TEXTURE0 + slot );\\n\\t\\t\\tstate.bindTexture( _gl.TEXTURE_CUBE_MAP, properties.get( texture ).__webglTexture );\\n\\n\\t\\t}\\n\\n\\t\\tfunction setTextureParameters( textureType, texture, isPowerOfTwoImage ) {\\n\\n\\t\\t\\tvar extension;\\n\\n\\t\\t\\tif ( isPowerOfTwoImage ) {\\n\\n\\t\\t\\t\\t_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_S, utils.convert( texture.wrapS ) );\\n\\t\\t\\t\\t_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_T, utils.convert( texture.wrapT ) );\\n\\n\\t\\t\\t\\t_gl.texParameteri( textureType, _gl.TEXTURE_MAG_FILTER, utils.convert( texture.magFilter ) );\\n\\t\\t\\t\\t_gl.texParameteri( textureType, _gl.TEXTURE_MIN_FILTER, utils.convert( texture.minFilter ) );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_S, _gl.CLAMP_TO_EDGE );\\n\\t\\t\\t\\t_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_T, _gl.CLAMP_TO_EDGE );\\n\\n\\t\\t\\t\\tif ( texture.wrapS !== ClampToEdgeWrapping || texture.wrapT !== ClampToEdgeWrapping ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping.', texture );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t_gl.texParameteri( textureType, _gl.TEXTURE_MAG_FILTER, filterFallback( texture.magFilter ) );\\n\\t\\t\\t\\t_gl.texParameteri( textureType, _gl.TEXTURE_MIN_FILTER, filterFallback( texture.minFilter ) );\\n\\n\\t\\t\\t\\tif ( texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.', texture );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\textension = extensions.get( 'EXT_texture_filter_anisotropic' );\\n\\n\\t\\t\\tif ( extension ) {\\n\\n\\t\\t\\t\\tif ( texture.type === FloatType && extensions.get( 'OES_texture_float_linear' ) === null ) return;\\n\\t\\t\\t\\tif ( texture.type === HalfFloatType && extensions.get( 'OES_texture_half_float_linear' ) === null ) return;\\n\\n\\t\\t\\t\\tif ( texture.anisotropy > 1 || properties.get( texture ).__currentAnisotropy ) {\\n\\n\\t\\t\\t\\t\\t_gl.texParameterf( textureType, extension.TEXTURE_MAX_ANISOTROPY_EXT, Math.min( texture.anisotropy, capabilities.getMaxAnisotropy() ) );\\n\\t\\t\\t\\t\\tproperties.get( texture ).__currentAnisotropy = texture.anisotropy;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction uploadTexture( textureProperties, texture, slot ) {\\n\\n\\t\\t\\tif ( textureProperties.__webglInit === undefined ) {\\n\\n\\t\\t\\t\\ttextureProperties.__webglInit = true;\\n\\n\\t\\t\\t\\ttexture.addEventListener( 'dispose', onTextureDispose );\\n\\n\\t\\t\\t\\ttextureProperties.__webglTexture = _gl.createTexture();\\n\\n\\t\\t\\t\\tif ( texture.isVideoTexture ) {\\n\\n\\t\\t\\t\\t\\t_videoTextures[ texture.id ] = texture;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tinfoMemory.textures ++;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tstate.activeTexture( _gl.TEXTURE0 + slot );\\n\\t\\t\\tstate.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture );\\n\\n\\t\\t\\t_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY );\\n\\t\\t\\t_gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha );\\n\\t\\t\\t_gl.pixelStorei( _gl.UNPACK_ALIGNMENT, texture.unpackAlignment );\\n\\n\\t\\t\\tvar image = clampToMaxSize( texture.image, capabilities.maxTextureSize );\\n\\n\\t\\t\\tif ( textureNeedsPowerOfTwo( texture ) && isPowerOfTwo( image ) === false ) {\\n\\n\\t\\t\\t\\timage = makePowerOfTwo( image );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar isPowerOfTwoImage = isPowerOfTwo( image ),\\n\\t\\t\\t\\tglFormat = utils.convert( texture.format ),\\n\\t\\t\\t\\tglType = utils.convert( texture.type );\\n\\n\\t\\t\\tsetTextureParameters( _gl.TEXTURE_2D, texture, isPowerOfTwoImage );\\n\\n\\t\\t\\tvar mipmap, mipmaps = texture.mipmaps;\\n\\n\\t\\t\\tif ( texture.isDepthTexture ) {\\n\\n\\t\\t\\t\\t// populate depth texture with dummy data\\n\\n\\t\\t\\t\\tvar internalFormat = _gl.DEPTH_COMPONENT;\\n\\n\\t\\t\\t\\tif ( texture.type === FloatType ) {\\n\\n\\t\\t\\t\\t\\tif ( ! _isWebGL2 ) throw new Error( 'Float Depth Texture only supported in WebGL2.0' );\\n\\t\\t\\t\\t\\tinternalFormat = _gl.DEPTH_COMPONENT32F;\\n\\n\\t\\t\\t\\t} else if ( _isWebGL2 ) {\\n\\n\\t\\t\\t\\t\\t// WebGL 2.0 requires signed internalformat for glTexImage2D\\n\\t\\t\\t\\t\\tinternalFormat = _gl.DEPTH_COMPONENT16;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( texture.format === DepthFormat && internalFormat === _gl.DEPTH_COMPONENT ) {\\n\\n\\t\\t\\t\\t\\t// The error INVALID_OPERATION is generated by texImage2D if format and internalformat are\\n\\t\\t\\t\\t\\t// DEPTH_COMPONENT and type is not UNSIGNED_SHORT or UNSIGNED_INT\\n\\t\\t\\t\\t\\t// (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)\\n\\t\\t\\t\\t\\tif ( texture.type !== UnsignedShortType && texture.type !== UnsignedIntType ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture.' );\\n\\n\\t\\t\\t\\t\\t\\ttexture.type = UnsignedShortType;\\n\\t\\t\\t\\t\\t\\tglType = utils.convert( texture.type );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// Depth stencil textures need the DEPTH_STENCIL internal format\\n\\t\\t\\t\\t// (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)\\n\\t\\t\\t\\tif ( texture.format === DepthStencilFormat ) {\\n\\n\\t\\t\\t\\t\\tinternalFormat = _gl.DEPTH_STENCIL;\\n\\n\\t\\t\\t\\t\\t// The error INVALID_OPERATION is generated by texImage2D if format and internalformat are\\n\\t\\t\\t\\t\\t// DEPTH_STENCIL and type is not UNSIGNED_INT_24_8_WEBGL.\\n\\t\\t\\t\\t\\t// (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)\\n\\t\\t\\t\\t\\tif ( texture.type !== UnsignedInt248Type ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture.' );\\n\\n\\t\\t\\t\\t\\t\\ttexture.type = UnsignedInt248Type;\\n\\t\\t\\t\\t\\t\\tglType = utils.convert( texture.type );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_2D, 0, internalFormat, image.width, image.height, 0, glFormat, glType, null );\\n\\n\\t\\t\\t} else if ( texture.isDataTexture ) {\\n\\n\\t\\t\\t\\t// use manually created mipmaps if available\\n\\t\\t\\t\\t// if there are no manual mipmaps\\n\\t\\t\\t\\t// set 0 level mipmap and then use GL to generate other mipmap levels\\n\\n\\t\\t\\t\\tif ( mipmaps.length > 0 && isPowerOfTwoImage ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, il = mipmaps.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tmipmap = mipmaps[ i ];\\n\\t\\t\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\ttexture.generateMipmaps = false;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_2D, 0, glFormat, image.width, image.height, 0, glFormat, glType, image.data );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( texture.isCompressedTexture ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0, il = mipmaps.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tmipmap = mipmaps[ i ];\\n\\n\\t\\t\\t\\t\\tif ( texture.format !== RGBAFormat && texture.format !== RGBFormat ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( state.getCompressedTextureFormats().indexOf( glFormat ) > - 1 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tstate.compressedTexImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, mipmap.data );\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()' );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// regular Texture (image, video, canvas)\\n\\n\\t\\t\\t\\t// use manually created mipmaps if available\\n\\t\\t\\t\\t// if there are no manual mipmaps\\n\\t\\t\\t\\t// set 0 level mipmap and then use GL to generate other mipmap levels\\n\\n\\t\\t\\t\\tif ( mipmaps.length > 0 && isPowerOfTwoImage ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, il = mipmaps.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tmipmap = mipmaps[ i ];\\n\\t\\t\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_2D, i, glFormat, glFormat, glType, mipmap );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\ttexture.generateMipmaps = false;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tstate.texImage2D( _gl.TEXTURE_2D, 0, glFormat, glFormat, glType, image );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( textureNeedsGenerateMipmaps( texture, isPowerOfTwoImage ) ) _gl.generateMipmap( _gl.TEXTURE_2D );\\n\\n\\t\\t\\ttextureProperties.__version = texture.version;\\n\\n\\t\\t\\tif ( texture.onUpdate ) texture.onUpdate( texture );\\n\\n\\t\\t}\\n\\n\\t\\t// Render targets\\n\\n\\t\\t// Setup storage for target texture and bind it to correct framebuffer\\n\\t\\tfunction setupFrameBufferTexture( framebuffer, renderTarget, attachment, textureTarget ) {\\n\\n\\t\\t\\tvar glFormat = utils.convert( renderTarget.texture.format );\\n\\t\\t\\tvar glType = utils.convert( renderTarget.texture.type );\\n\\t\\t\\tstate.texImage2D( textureTarget, 0, glFormat, renderTarget.width, renderTarget.height, 0, glFormat, glType, null );\\n\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );\\n\\t\\t\\t_gl.framebufferTexture2D( _gl.FRAMEBUFFER, attachment, textureTarget, properties.get( renderTarget.texture ).__webglTexture, 0 );\\n\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, null );\\n\\n\\t\\t}\\n\\n\\t\\t// Setup storage for internal depth/stencil buffers and bind to correct framebuffer\\n\\t\\tfunction setupRenderBufferStorage( renderbuffer, renderTarget ) {\\n\\n\\t\\t\\t_gl.bindRenderbuffer( _gl.RENDERBUFFER, renderbuffer );\\n\\n\\t\\t\\tif ( renderTarget.depthBuffer && ! renderTarget.stencilBuffer ) {\\n\\n\\t\\t\\t\\t_gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.DEPTH_COMPONENT16, renderTarget.width, renderTarget.height );\\n\\t\\t\\t\\t_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer );\\n\\n\\t\\t\\t} else if ( renderTarget.depthBuffer && renderTarget.stencilBuffer ) {\\n\\n\\t\\t\\t\\t_gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.DEPTH_STENCIL, renderTarget.width, renderTarget.height );\\n\\t\\t\\t\\t_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// FIXME: We don't support !depth !stencil\\n\\t\\t\\t\\t_gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.RGBA4, renderTarget.width, renderTarget.height );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t_gl.bindRenderbuffer( _gl.RENDERBUFFER, null );\\n\\n\\t\\t}\\n\\n\\t\\t// Setup resources for a Depth Texture for a FBO (needs an extension)\\n\\t\\tfunction setupDepthTexture( framebuffer, renderTarget ) {\\n\\n\\t\\t\\tvar isCube = ( renderTarget && renderTarget.isWebGLRenderTargetCube );\\n\\t\\t\\tif ( isCube ) throw new Error( 'Depth Texture with cube render targets is not supported' );\\n\\n\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );\\n\\n\\t\\t\\tif ( ! ( renderTarget.depthTexture && renderTarget.depthTexture.isDepthTexture ) ) {\\n\\n\\t\\t\\t\\tthrow new Error( 'renderTarget.depthTexture must be an instance of THREE.DepthTexture' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// upload an empty depth texture with framebuffer size\\n\\t\\t\\tif ( ! properties.get( renderTarget.depthTexture ).__webglTexture ||\\n\\t\\t\\t\\t\\trenderTarget.depthTexture.image.width !== renderTarget.width ||\\n\\t\\t\\t\\t\\trenderTarget.depthTexture.image.height !== renderTarget.height ) {\\n\\n\\t\\t\\t\\trenderTarget.depthTexture.image.width = renderTarget.width;\\n\\t\\t\\t\\trenderTarget.depthTexture.image.height = renderTarget.height;\\n\\t\\t\\t\\trenderTarget.depthTexture.needsUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tsetTexture2D( renderTarget.depthTexture, 0 );\\n\\n\\t\\t\\tvar webglDepthTexture = properties.get( renderTarget.depthTexture ).__webglTexture;\\n\\n\\t\\t\\tif ( renderTarget.depthTexture.format === DepthFormat ) {\\n\\n\\t\\t\\t\\t_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0 );\\n\\n\\t\\t\\t} else if ( renderTarget.depthTexture.format === DepthStencilFormat ) {\\n\\n\\t\\t\\t\\t_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0 );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthrow new Error( 'Unknown depthTexture format' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// Setup GL resources for a non-texture depth buffer\\n\\t\\tfunction setupDepthRenderbuffer( renderTarget ) {\\n\\n\\t\\t\\tvar renderTargetProperties = properties.get( renderTarget );\\n\\n\\t\\t\\tvar isCube = ( renderTarget.isWebGLRenderTargetCube === true );\\n\\n\\t\\t\\tif ( renderTarget.depthTexture ) {\\n\\n\\t\\t\\t\\tif ( isCube ) throw new Error( 'target.depthTexture not supported in Cube render targets' );\\n\\n\\t\\t\\t\\tsetupDepthTexture( renderTargetProperties.__webglFramebuffer, renderTarget );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tif ( isCube ) {\\n\\n\\t\\t\\t\\t\\trenderTargetProperties.__webglDepthbuffer = [];\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer[ i ] );\\n\\t\\t\\t\\t\\t\\trenderTargetProperties.__webglDepthbuffer[ i ] = _gl.createRenderbuffer();\\n\\t\\t\\t\\t\\t\\tsetupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer[ i ], renderTarget );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer );\\n\\t\\t\\t\\t\\trenderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer();\\n\\t\\t\\t\\t\\tsetupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer, renderTarget );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, null );\\n\\n\\t\\t}\\n\\n\\t\\t// Set up GL resources for the render target\\n\\t\\tfunction setupRenderTarget( renderTarget ) {\\n\\n\\t\\t\\tvar renderTargetProperties = properties.get( renderTarget );\\n\\t\\t\\tvar textureProperties = properties.get( renderTarget.texture );\\n\\n\\t\\t\\trenderTarget.addEventListener( 'dispose', onRenderTargetDispose );\\n\\n\\t\\t\\ttextureProperties.__webglTexture = _gl.createTexture();\\n\\n\\t\\t\\tinfoMemory.textures ++;\\n\\n\\t\\t\\tvar isCube = ( renderTarget.isWebGLRenderTargetCube === true );\\n\\t\\t\\tvar isTargetPowerOfTwo = isPowerOfTwo( renderTarget );\\n\\n\\t\\t\\t// Setup framebuffer\\n\\n\\t\\t\\tif ( isCube ) {\\n\\n\\t\\t\\t\\trenderTargetProperties.__webglFramebuffer = [];\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\t\\trenderTargetProperties.__webglFramebuffer[ i ] = _gl.createFramebuffer();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\trenderTargetProperties.__webglFramebuffer = _gl.createFramebuffer();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Setup color buffer\\n\\n\\t\\t\\tif ( isCube ) {\\n\\n\\t\\t\\t\\tstate.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture );\\n\\t\\t\\t\\tsetTextureParameters( _gl.TEXTURE_CUBE_MAP, renderTarget.texture, isTargetPowerOfTwo );\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\t\\tsetupFrameBufferTexture( renderTargetProperties.__webglFramebuffer[ i ], renderTarget, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( textureNeedsGenerateMipmaps( renderTarget.texture, isTargetPowerOfTwo ) ) _gl.generateMipmap( _gl.TEXTURE_CUBE_MAP );\\n\\t\\t\\t\\tstate.bindTexture( _gl.TEXTURE_CUBE_MAP, null );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tstate.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture );\\n\\t\\t\\t\\tsetTextureParameters( _gl.TEXTURE_2D, renderTarget.texture, isTargetPowerOfTwo );\\n\\t\\t\\t\\tsetupFrameBufferTexture( renderTargetProperties.__webglFramebuffer, renderTarget, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D );\\n\\n\\t\\t\\t\\tif ( textureNeedsGenerateMipmaps( renderTarget.texture, isTargetPowerOfTwo ) ) _gl.generateMipmap( _gl.TEXTURE_2D );\\n\\t\\t\\t\\tstate.bindTexture( _gl.TEXTURE_2D, null );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Setup depth and stencil buffers\\n\\n\\t\\t\\tif ( renderTarget.depthBuffer ) {\\n\\n\\t\\t\\t\\tsetupDepthRenderbuffer( renderTarget );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction updateRenderTargetMipmap( renderTarget ) {\\n\\n\\t\\t\\tvar texture = renderTarget.texture;\\n\\t\\t\\tvar isTargetPowerOfTwo = isPowerOfTwo( renderTarget );\\n\\n\\t\\t\\tif ( textureNeedsGenerateMipmaps( texture, isTargetPowerOfTwo ) ) {\\n\\n\\t\\t\\t\\tvar target = renderTarget.isWebGLRenderTargetCube ? _gl.TEXTURE_CUBE_MAP : _gl.TEXTURE_2D;\\n\\t\\t\\t\\tvar webglTexture = properties.get( texture ).__webglTexture;\\n\\n\\t\\t\\t\\tstate.bindTexture( target, webglTexture );\\n\\t\\t\\t\\t_gl.generateMipmap( target );\\n\\t\\t\\t\\tstate.bindTexture( target, null );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction updateVideoTextures() {\\n\\n\\t\\t\\tfor ( var id in _videoTextures ) {\\n\\n\\t\\t\\t\\t_videoTextures[ id ].update();\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tthis.setTexture2D = setTexture2D;\\n\\t\\tthis.setTextureCube = setTextureCube;\\n\\t\\tthis.setTextureCubeDynamic = setTextureCubeDynamic;\\n\\t\\tthis.setupRenderTarget = setupRenderTarget;\\n\\t\\tthis.updateRenderTargetMipmap = updateRenderTargetMipmap;\\n\\t\\tthis.updateVideoTextures = updateVideoTextures;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author fordacious / fordacious.github.io\\n\\t */\\n\\n\\tfunction WebGLProperties() {\\n\\n\\t\\tvar properties = {};\\n\\n\\t\\tfunction get( object ) {\\n\\n\\t\\t\\tvar uuid = object.uuid;\\n\\t\\t\\tvar map = properties[ uuid ];\\n\\n\\t\\t\\tif ( map === undefined ) {\\n\\n\\t\\t\\t\\tmap = {};\\n\\t\\t\\t\\tproperties[ uuid ] = map;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn map;\\n\\n\\t\\t}\\n\\n\\t\\tfunction remove( object ) {\\n\\n\\t\\t\\tdelete properties[ object.uuid ];\\n\\n\\t\\t}\\n\\n\\t\\tfunction clear() {\\n\\n\\t\\t\\tproperties = {};\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\t\\t\\tget: get,\\n\\t\\t\\tremove: remove,\\n\\t\\t\\tclear: clear\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLState( gl, extensions, utils ) {\\n\\n\\t\\tfunction ColorBuffer() {\\n\\n\\t\\t\\tvar locked = false;\\n\\n\\t\\t\\tvar color = new Vector4();\\n\\t\\t\\tvar currentColorMask = null;\\n\\t\\t\\tvar currentColorClear = new Vector4( 0, 0, 0, 0 );\\n\\n\\t\\t\\treturn {\\n\\n\\t\\t\\t\\tsetMask: function ( colorMask ) {\\n\\n\\t\\t\\t\\t\\tif ( currentColorMask !== colorMask && ! locked ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.colorMask( colorMask, colorMask, colorMask, colorMask );\\n\\t\\t\\t\\t\\t\\tcurrentColorMask = colorMask;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetLocked: function ( lock ) {\\n\\n\\t\\t\\t\\t\\tlocked = lock;\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetClear: function ( r, g, b, a, premultipliedAlpha ) {\\n\\n\\t\\t\\t\\t\\tif ( premultipliedAlpha === true ) {\\n\\n\\t\\t\\t\\t\\t\\tr *= a; g *= a; b *= a;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tcolor.set( r, g, b, a );\\n\\n\\t\\t\\t\\t\\tif ( currentColorClear.equals( color ) === false ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.clearColor( r, g, b, a );\\n\\t\\t\\t\\t\\t\\tcurrentColorClear.copy( color );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\treset: function () {\\n\\n\\t\\t\\t\\t\\tlocked = false;\\n\\n\\t\\t\\t\\t\\tcurrentColorMask = null;\\n\\t\\t\\t\\t\\tcurrentColorClear.set( - 1, 0, 0, 0 ); // set to invalid state\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}\\n\\n\\t\\tfunction DepthBuffer() {\\n\\n\\t\\t\\tvar locked = false;\\n\\n\\t\\t\\tvar currentDepthMask = null;\\n\\t\\t\\tvar currentDepthFunc = null;\\n\\t\\t\\tvar currentDepthClear = null;\\n\\n\\t\\t\\treturn {\\n\\n\\t\\t\\t\\tsetTest: function ( depthTest ) {\\n\\n\\t\\t\\t\\t\\tif ( depthTest ) {\\n\\n\\t\\t\\t\\t\\t\\tenable( gl.DEPTH_TEST );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tdisable( gl.DEPTH_TEST );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetMask: function ( depthMask ) {\\n\\n\\t\\t\\t\\t\\tif ( currentDepthMask !== depthMask && ! locked ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.depthMask( depthMask );\\n\\t\\t\\t\\t\\t\\tcurrentDepthMask = depthMask;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetFunc: function ( depthFunc ) {\\n\\n\\t\\t\\t\\t\\tif ( currentDepthFunc !== depthFunc ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( depthFunc ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tswitch ( depthFunc ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase NeverDepth:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.NEVER );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase AlwaysDepth:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.ALWAYS );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase LessDepth:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.LESS );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase LessEqualDepth:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.LEQUAL );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase EqualDepth:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.EQUAL );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase GreaterEqualDepth:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.GEQUAL );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase GreaterDepth:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.GREATER );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase NotEqualDepth:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.NOTEQUAL );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tdefault:\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.LEQUAL );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tgl.depthFunc( gl.LEQUAL );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tcurrentDepthFunc = depthFunc;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetLocked: function ( lock ) {\\n\\n\\t\\t\\t\\t\\tlocked = lock;\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetClear: function ( depth ) {\\n\\n\\t\\t\\t\\t\\tif ( currentDepthClear !== depth ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.clearDepth( depth );\\n\\t\\t\\t\\t\\t\\tcurrentDepthClear = depth;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\treset: function () {\\n\\n\\t\\t\\t\\t\\tlocked = false;\\n\\n\\t\\t\\t\\t\\tcurrentDepthMask = null;\\n\\t\\t\\t\\t\\tcurrentDepthFunc = null;\\n\\t\\t\\t\\t\\tcurrentDepthClear = null;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}\\n\\n\\t\\tfunction StencilBuffer() {\\n\\n\\t\\t\\tvar locked = false;\\n\\n\\t\\t\\tvar currentStencilMask = null;\\n\\t\\t\\tvar currentStencilFunc = null;\\n\\t\\t\\tvar currentStencilRef = null;\\n\\t\\t\\tvar currentStencilFuncMask = null;\\n\\t\\t\\tvar currentStencilFail = null;\\n\\t\\t\\tvar currentStencilZFail = null;\\n\\t\\t\\tvar currentStencilZPass = null;\\n\\t\\t\\tvar currentStencilClear = null;\\n\\n\\t\\t\\treturn {\\n\\n\\t\\t\\t\\tsetTest: function ( stencilTest ) {\\n\\n\\t\\t\\t\\t\\tif ( stencilTest ) {\\n\\n\\t\\t\\t\\t\\t\\tenable( gl.STENCIL_TEST );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tdisable( gl.STENCIL_TEST );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetMask: function ( stencilMask ) {\\n\\n\\t\\t\\t\\t\\tif ( currentStencilMask !== stencilMask && ! locked ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.stencilMask( stencilMask );\\n\\t\\t\\t\\t\\t\\tcurrentStencilMask = stencilMask;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetFunc: function ( stencilFunc, stencilRef, stencilMask ) {\\n\\n\\t\\t\\t\\t\\tif ( currentStencilFunc !== stencilFunc ||\\n\\t\\t\\t\\t\\t     currentStencilRef \\t!== stencilRef \\t||\\n\\t\\t\\t\\t\\t     currentStencilFuncMask !== stencilMask ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.stencilFunc( stencilFunc, stencilRef, stencilMask );\\n\\n\\t\\t\\t\\t\\t\\tcurrentStencilFunc = stencilFunc;\\n\\t\\t\\t\\t\\t\\tcurrentStencilRef = stencilRef;\\n\\t\\t\\t\\t\\t\\tcurrentStencilFuncMask = stencilMask;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetOp: function ( stencilFail, stencilZFail, stencilZPass ) {\\n\\n\\t\\t\\t\\t\\tif ( currentStencilFail\\t !== stencilFail \\t||\\n\\t\\t\\t\\t\\t     currentStencilZFail !== stencilZFail ||\\n\\t\\t\\t\\t\\t     currentStencilZPass !== stencilZPass ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.stencilOp( stencilFail, stencilZFail, stencilZPass );\\n\\n\\t\\t\\t\\t\\t\\tcurrentStencilFail = stencilFail;\\n\\t\\t\\t\\t\\t\\tcurrentStencilZFail = stencilZFail;\\n\\t\\t\\t\\t\\t\\tcurrentStencilZPass = stencilZPass;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetLocked: function ( lock ) {\\n\\n\\t\\t\\t\\t\\tlocked = lock;\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tsetClear: function ( stencil ) {\\n\\n\\t\\t\\t\\t\\tif ( currentStencilClear !== stencil ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.clearStencil( stencil );\\n\\t\\t\\t\\t\\t\\tcurrentStencilClear = stencil;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\treset: function () {\\n\\n\\t\\t\\t\\t\\tlocked = false;\\n\\n\\t\\t\\t\\t\\tcurrentStencilMask = null;\\n\\t\\t\\t\\t\\tcurrentStencilFunc = null;\\n\\t\\t\\t\\t\\tcurrentStencilRef = null;\\n\\t\\t\\t\\t\\tcurrentStencilFuncMask = null;\\n\\t\\t\\t\\t\\tcurrentStencilFail = null;\\n\\t\\t\\t\\t\\tcurrentStencilZFail = null;\\n\\t\\t\\t\\t\\tcurrentStencilZPass = null;\\n\\t\\t\\t\\t\\tcurrentStencilClear = null;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tvar colorBuffer = new ColorBuffer();\\n\\t\\tvar depthBuffer = new DepthBuffer();\\n\\t\\tvar stencilBuffer = new StencilBuffer();\\n\\n\\t\\tvar maxVertexAttributes = gl.getParameter( gl.MAX_VERTEX_ATTRIBS );\\n\\t\\tvar newAttributes = new Uint8Array( maxVertexAttributes );\\n\\t\\tvar enabledAttributes = new Uint8Array( maxVertexAttributes );\\n\\t\\tvar attributeDivisors = new Uint8Array( maxVertexAttributes );\\n\\n\\t\\tvar capabilities = {};\\n\\n\\t\\tvar compressedTextureFormats = null;\\n\\n\\t\\tvar currentProgram = null;\\n\\n\\t\\tvar currentBlending = null;\\n\\t\\tvar currentBlendEquation = null;\\n\\t\\tvar currentBlendSrc = null;\\n\\t\\tvar currentBlendDst = null;\\n\\t\\tvar currentBlendEquationAlpha = null;\\n\\t\\tvar currentBlendSrcAlpha = null;\\n\\t\\tvar currentBlendDstAlpha = null;\\n\\t\\tvar currentPremultipledAlpha = false;\\n\\n\\t\\tvar currentFlipSided = null;\\n\\t\\tvar currentCullFace = null;\\n\\n\\t\\tvar currentLineWidth = null;\\n\\n\\t\\tvar currentPolygonOffsetFactor = null;\\n\\t\\tvar currentPolygonOffsetUnits = null;\\n\\n\\t\\tvar maxTextures = gl.getParameter( gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS );\\n\\n\\t\\tvar version = parseFloat( /^WebGL\\\\ ([0-9])/.exec( gl.getParameter( gl.VERSION ) )[ 1 ] );\\n\\t\\tvar lineWidthAvailable = parseFloat( version ) >= 1.0;\\n\\n\\t\\tvar currentTextureSlot = null;\\n\\t\\tvar currentBoundTextures = {};\\n\\n\\t\\tvar currentScissor = new Vector4();\\n\\t\\tvar currentViewport = new Vector4();\\n\\n\\t\\tfunction createTexture( type, target, count ) {\\n\\n\\t\\t\\tvar data = new Uint8Array( 4 ); // 4 is required to match default unpack alignment of 4.\\n\\t\\t\\tvar texture = gl.createTexture();\\n\\n\\t\\t\\tgl.bindTexture( type, texture );\\n\\t\\t\\tgl.texParameteri( type, gl.TEXTURE_MIN_FILTER, gl.NEAREST );\\n\\t\\t\\tgl.texParameteri( type, gl.TEXTURE_MAG_FILTER, gl.NEAREST );\\n\\n\\t\\t\\tfor ( var i = 0; i < count; i ++ ) {\\n\\n\\t\\t\\t\\tgl.texImage2D( target + i, 0, gl.RGBA, 1, 1, 0, gl.RGBA, gl.UNSIGNED_BYTE, data );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn texture;\\n\\n\\t\\t}\\n\\n\\t\\tvar emptyTextures = {};\\n\\t\\temptyTextures[ gl.TEXTURE_2D ] = createTexture( gl.TEXTURE_2D, gl.TEXTURE_2D, 1 );\\n\\t\\temptyTextures[ gl.TEXTURE_CUBE_MAP ] = createTexture( gl.TEXTURE_CUBE_MAP, gl.TEXTURE_CUBE_MAP_POSITIVE_X, 6 );\\n\\n\\t\\t// init\\n\\n\\t\\tcolorBuffer.setClear( 0, 0, 0, 1 );\\n\\t\\tdepthBuffer.setClear( 1 );\\n\\t\\tstencilBuffer.setClear( 0 );\\n\\n\\t\\tenable( gl.DEPTH_TEST );\\n\\t\\tdepthBuffer.setFunc( LessEqualDepth );\\n\\n\\t\\tsetFlipSided( false );\\n\\t\\tsetCullFace( CullFaceBack );\\n\\t\\tenable( gl.CULL_FACE );\\n\\n\\t\\tenable( gl.BLEND );\\n\\t\\tsetBlending( NormalBlending );\\n\\n\\t\\t//\\n\\n\\t\\tfunction initAttributes() {\\n\\n\\t\\t\\tfor ( var i = 0, l = newAttributes.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tnewAttributes[ i ] = 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction enableAttribute( attribute ) {\\n\\n\\t\\t\\tnewAttributes[ attribute ] = 1;\\n\\n\\t\\t\\tif ( enabledAttributes[ attribute ] === 0 ) {\\n\\n\\t\\t\\t\\tgl.enableVertexAttribArray( attribute );\\n\\t\\t\\t\\tenabledAttributes[ attribute ] = 1;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( attributeDivisors[ attribute ] !== 0 ) {\\n\\n\\t\\t\\t\\tvar extension = extensions.get( 'ANGLE_instanced_arrays' );\\n\\n\\t\\t\\t\\textension.vertexAttribDivisorANGLE( attribute, 0 );\\n\\t\\t\\t\\tattributeDivisors[ attribute ] = 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction enableAttributeAndDivisor( attribute, meshPerAttribute ) {\\n\\n\\t\\t\\tnewAttributes[ attribute ] = 1;\\n\\n\\t\\t\\tif ( enabledAttributes[ attribute ] === 0 ) {\\n\\n\\t\\t\\t\\tgl.enableVertexAttribArray( attribute );\\n\\t\\t\\t\\tenabledAttributes[ attribute ] = 1;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( attributeDivisors[ attribute ] !== meshPerAttribute ) {\\n\\n\\t\\t\\t\\tvar extension = extensions.get( 'ANGLE_instanced_arrays' );\\n\\n\\t\\t\\t\\textension.vertexAttribDivisorANGLE( attribute, meshPerAttribute );\\n\\t\\t\\t\\tattributeDivisors[ attribute ] = meshPerAttribute;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction disableUnusedAttributes() {\\n\\n\\t\\t\\tfor ( var i = 0, l = enabledAttributes.length; i !== l; ++ i ) {\\n\\n\\t\\t\\t\\tif ( enabledAttributes[ i ] !== newAttributes[ i ] ) {\\n\\n\\t\\t\\t\\t\\tgl.disableVertexAttribArray( i );\\n\\t\\t\\t\\t\\tenabledAttributes[ i ] = 0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction enable( id ) {\\n\\n\\t\\t\\tif ( capabilities[ id ] !== true ) {\\n\\n\\t\\t\\t\\tgl.enable( id );\\n\\t\\t\\t\\tcapabilities[ id ] = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction disable( id ) {\\n\\n\\t\\t\\tif ( capabilities[ id ] !== false ) {\\n\\n\\t\\t\\t\\tgl.disable( id );\\n\\t\\t\\t\\tcapabilities[ id ] = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction getCompressedTextureFormats() {\\n\\n\\t\\t\\tif ( compressedTextureFormats === null ) {\\n\\n\\t\\t\\t\\tcompressedTextureFormats = [];\\n\\n\\t\\t\\t\\tif ( extensions.get( 'WEBGL_compressed_texture_pvrtc' ) ||\\n\\t\\t\\t\\t     extensions.get( 'WEBGL_compressed_texture_s3tc' ) ||\\n\\t\\t\\t\\t     extensions.get( 'WEBGL_compressed_texture_etc1' ) ) {\\n\\n\\t\\t\\t\\t\\tvar formats = gl.getParameter( gl.COMPRESSED_TEXTURE_FORMATS );\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < formats.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tcompressedTextureFormats.push( formats[ i ] );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn compressedTextureFormats;\\n\\n\\t\\t}\\n\\n\\t\\tfunction useProgram( program ) {\\n\\n\\t\\t\\tif ( currentProgram !== program ) {\\n\\n\\t\\t\\t\\tgl.useProgram( program );\\n\\n\\t\\t\\t\\tcurrentProgram = program;\\n\\n\\t\\t\\t\\treturn true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn false;\\n\\n\\t\\t}\\n\\n\\t\\tfunction setBlending( blending, blendEquation, blendSrc, blendDst, blendEquationAlpha, blendSrcAlpha, blendDstAlpha, premultipliedAlpha ) {\\n\\n\\t\\t\\tif ( blending !== NoBlending ) {\\n\\n\\t\\t\\t\\tenable( gl.BLEND );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tdisable( gl.BLEND );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( blending !== CustomBlending ) {\\n\\n\\t\\t\\t\\tif ( blending !== currentBlending || premultipliedAlpha !== currentPremultipledAlpha ) {\\n\\n\\t\\t\\t\\t\\tswitch ( blending ) {\\n\\n\\t\\t\\t\\t\\t\\tcase AdditiveBlending:\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( premultipliedAlpha ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendFuncSeparate( gl.ONE, gl.ONE, gl.ONE, gl.ONE );\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendEquation( gl.FUNC_ADD );\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendFunc( gl.SRC_ALPHA, gl.ONE );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase SubtractiveBlending:\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( premultipliedAlpha ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendFuncSeparate( gl.ZERO, gl.ZERO, gl.ONE_MINUS_SRC_COLOR, gl.ONE_MINUS_SRC_ALPHA );\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendEquation( gl.FUNC_ADD );\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendFunc( gl.ZERO, gl.ONE_MINUS_SRC_COLOR );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase MultiplyBlending:\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( premultipliedAlpha ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendFuncSeparate( gl.ZERO, gl.SRC_COLOR, gl.ZERO, gl.SRC_ALPHA );\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendEquation( gl.FUNC_ADD );\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendFunc( gl.ZERO, gl.SRC_COLOR );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tdefault:\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( premultipliedAlpha ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendFuncSeparate( gl.ONE, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA );\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );\\n\\t\\t\\t\\t\\t\\t\\t\\tgl.blendFuncSeparate( gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tcurrentBlendEquation = null;\\n\\t\\t\\t\\tcurrentBlendSrc = null;\\n\\t\\t\\t\\tcurrentBlendDst = null;\\n\\t\\t\\t\\tcurrentBlendEquationAlpha = null;\\n\\t\\t\\t\\tcurrentBlendSrcAlpha = null;\\n\\t\\t\\t\\tcurrentBlendDstAlpha = null;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tblendEquationAlpha = blendEquationAlpha || blendEquation;\\n\\t\\t\\t\\tblendSrcAlpha = blendSrcAlpha || blendSrc;\\n\\t\\t\\t\\tblendDstAlpha = blendDstAlpha || blendDst;\\n\\n\\t\\t\\t\\tif ( blendEquation !== currentBlendEquation || blendEquationAlpha !== currentBlendEquationAlpha ) {\\n\\n\\t\\t\\t\\t\\tgl.blendEquationSeparate( utils.convert( blendEquation ), utils.convert( blendEquationAlpha ) );\\n\\n\\t\\t\\t\\t\\tcurrentBlendEquation = blendEquation;\\n\\t\\t\\t\\t\\tcurrentBlendEquationAlpha = blendEquationAlpha;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( blendSrc !== currentBlendSrc || blendDst !== currentBlendDst || blendSrcAlpha !== currentBlendSrcAlpha || blendDstAlpha !== currentBlendDstAlpha ) {\\n\\n\\t\\t\\t\\t\\tgl.blendFuncSeparate( utils.convert( blendSrc ), utils.convert( blendDst ), utils.convert( blendSrcAlpha ), utils.convert( blendDstAlpha ) );\\n\\n\\t\\t\\t\\t\\tcurrentBlendSrc = blendSrc;\\n\\t\\t\\t\\t\\tcurrentBlendDst = blendDst;\\n\\t\\t\\t\\t\\tcurrentBlendSrcAlpha = blendSrcAlpha;\\n\\t\\t\\t\\t\\tcurrentBlendDstAlpha = blendDstAlpha;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tcurrentBlending = blending;\\n\\t\\t\\tcurrentPremultipledAlpha = premultipliedAlpha;\\n\\n\\t\\t}\\n\\n\\t\\tfunction setMaterial( material, frontFaceCW ) {\\n\\n\\t\\t\\tmaterial.side === DoubleSide\\n\\t\\t\\t\\t? disable( gl.CULL_FACE )\\n\\t\\t\\t\\t: enable( gl.CULL_FACE );\\n\\n\\t\\t\\tvar flipSided = ( material.side === BackSide );\\n\\t\\t\\tif ( frontFaceCW ) flipSided = ! flipSided;\\n\\n\\t\\t\\tsetFlipSided( flipSided );\\n\\n\\t\\t\\tmaterial.transparent === true\\n\\t\\t\\t\\t? setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha, material.premultipliedAlpha )\\n\\t\\t\\t\\t: setBlending( NoBlending );\\n\\n\\t\\t\\tdepthBuffer.setFunc( material.depthFunc );\\n\\t\\t\\tdepthBuffer.setTest( material.depthTest );\\n\\t\\t\\tdepthBuffer.setMask( material.depthWrite );\\n\\t\\t\\tcolorBuffer.setMask( material.colorWrite );\\n\\n\\t\\t\\tsetPolygonOffset( material.polygonOffset, material.polygonOffsetFactor, material.polygonOffsetUnits );\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tfunction setFlipSided( flipSided ) {\\n\\n\\t\\t\\tif ( currentFlipSided !== flipSided ) {\\n\\n\\t\\t\\t\\tif ( flipSided ) {\\n\\n\\t\\t\\t\\t\\tgl.frontFace( gl.CW );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tgl.frontFace( gl.CCW );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tcurrentFlipSided = flipSided;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction setCullFace( cullFace ) {\\n\\n\\t\\t\\tif ( cullFace !== CullFaceNone ) {\\n\\n\\t\\t\\t\\tenable( gl.CULL_FACE );\\n\\n\\t\\t\\t\\tif ( cullFace !== currentCullFace ) {\\n\\n\\t\\t\\t\\t\\tif ( cullFace === CullFaceBack ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.cullFace( gl.BACK );\\n\\n\\t\\t\\t\\t\\t} else if ( cullFace === CullFaceFront ) {\\n\\n\\t\\t\\t\\t\\t\\tgl.cullFace( gl.FRONT );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tgl.cullFace( gl.FRONT_AND_BACK );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tdisable( gl.CULL_FACE );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tcurrentCullFace = cullFace;\\n\\n\\t\\t}\\n\\n\\t\\tfunction setLineWidth( width ) {\\n\\n\\t\\t\\tif ( width !== currentLineWidth ) {\\n\\n\\t\\t\\t\\tif ( lineWidthAvailable ) gl.lineWidth( width );\\n\\n\\t\\t\\t\\tcurrentLineWidth = width;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction setPolygonOffset( polygonOffset, factor, units ) {\\n\\n\\t\\t\\tif ( polygonOffset ) {\\n\\n\\t\\t\\t\\tenable( gl.POLYGON_OFFSET_FILL );\\n\\n\\t\\t\\t\\tif ( currentPolygonOffsetFactor !== factor || currentPolygonOffsetUnits !== units ) {\\n\\n\\t\\t\\t\\t\\tgl.polygonOffset( factor, units );\\n\\n\\t\\t\\t\\t\\tcurrentPolygonOffsetFactor = factor;\\n\\t\\t\\t\\t\\tcurrentPolygonOffsetUnits = units;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tdisable( gl.POLYGON_OFFSET_FILL );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction setScissorTest( scissorTest ) {\\n\\n\\t\\t\\tif ( scissorTest ) {\\n\\n\\t\\t\\t\\tenable( gl.SCISSOR_TEST );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tdisable( gl.SCISSOR_TEST );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// texture\\n\\n\\t\\tfunction activeTexture( webglSlot ) {\\n\\n\\t\\t\\tif ( webglSlot === undefined ) webglSlot = gl.TEXTURE0 + maxTextures - 1;\\n\\n\\t\\t\\tif ( currentTextureSlot !== webglSlot ) {\\n\\n\\t\\t\\t\\tgl.activeTexture( webglSlot );\\n\\t\\t\\t\\tcurrentTextureSlot = webglSlot;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction bindTexture( webglType, webglTexture ) {\\n\\n\\t\\t\\tif ( currentTextureSlot === null ) {\\n\\n\\t\\t\\t\\tactiveTexture();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar boundTexture = currentBoundTextures[ currentTextureSlot ];\\n\\n\\t\\t\\tif ( boundTexture === undefined ) {\\n\\n\\t\\t\\t\\tboundTexture = { type: undefined, texture: undefined };\\n\\t\\t\\t\\tcurrentBoundTextures[ currentTextureSlot ] = boundTexture;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( boundTexture.type !== webglType || boundTexture.texture !== webglTexture ) {\\n\\n\\t\\t\\t\\tgl.bindTexture( webglType, webglTexture || emptyTextures[ webglType ] );\\n\\n\\t\\t\\t\\tboundTexture.type = webglType;\\n\\t\\t\\t\\tboundTexture.texture = webglTexture;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction compressedTexImage2D() {\\n\\n\\t\\t\\ttry {\\n\\n\\t\\t\\t\\tgl.compressedTexImage2D.apply( gl, arguments );\\n\\n\\t\\t\\t} catch ( error ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.WebGLState:', error );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction texImage2D() {\\n\\n\\t\\t\\ttry {\\n\\n\\t\\t\\t\\tgl.texImage2D.apply( gl, arguments );\\n\\n\\t\\t\\t} catch ( error ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.WebGLState:', error );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tfunction scissor( scissor ) {\\n\\n\\t\\t\\tif ( currentScissor.equals( scissor ) === false ) {\\n\\n\\t\\t\\t\\tgl.scissor( scissor.x, scissor.y, scissor.z, scissor.w );\\n\\t\\t\\t\\tcurrentScissor.copy( scissor );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction viewport( viewport ) {\\n\\n\\t\\t\\tif ( currentViewport.equals( viewport ) === false ) {\\n\\n\\t\\t\\t\\tgl.viewport( viewport.x, viewport.y, viewport.z, viewport.w );\\n\\t\\t\\t\\tcurrentViewport.copy( viewport );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tfunction reset() {\\n\\n\\t\\t\\tfor ( var i = 0; i < enabledAttributes.length; i ++ ) {\\n\\n\\t\\t\\t\\tif ( enabledAttributes[ i ] === 1 ) {\\n\\n\\t\\t\\t\\t\\tgl.disableVertexAttribArray( i );\\n\\t\\t\\t\\t\\tenabledAttributes[ i ] = 0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tcapabilities = {};\\n\\n\\t\\t\\tcompressedTextureFormats = null;\\n\\n\\t\\t\\tcurrentTextureSlot = null;\\n\\t\\t\\tcurrentBoundTextures = {};\\n\\n\\t\\t\\tcurrentProgram = null;\\n\\n\\t\\t\\tcurrentBlending = null;\\n\\n\\t\\t\\tcurrentFlipSided = null;\\n\\t\\t\\tcurrentCullFace = null;\\n\\n\\t\\t\\tcolorBuffer.reset();\\n\\t\\t\\tdepthBuffer.reset();\\n\\t\\t\\tstencilBuffer.reset();\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tbuffers: {\\n\\t\\t\\t\\tcolor: colorBuffer,\\n\\t\\t\\t\\tdepth: depthBuffer,\\n\\t\\t\\t\\tstencil: stencilBuffer\\n\\t\\t\\t},\\n\\n\\t\\t\\tinitAttributes: initAttributes,\\n\\t\\t\\tenableAttribute: enableAttribute,\\n\\t\\t\\tenableAttributeAndDivisor: enableAttributeAndDivisor,\\n\\t\\t\\tdisableUnusedAttributes: disableUnusedAttributes,\\n\\t\\t\\tenable: enable,\\n\\t\\t\\tdisable: disable,\\n\\t\\t\\tgetCompressedTextureFormats: getCompressedTextureFormats,\\n\\n\\t\\t\\tuseProgram: useProgram,\\n\\n\\t\\t\\tsetBlending: setBlending,\\n\\t\\t\\tsetMaterial: setMaterial,\\n\\n\\t\\t\\tsetFlipSided: setFlipSided,\\n\\t\\t\\tsetCullFace: setCullFace,\\n\\n\\t\\t\\tsetLineWidth: setLineWidth,\\n\\t\\t\\tsetPolygonOffset: setPolygonOffset,\\n\\n\\t\\t\\tsetScissorTest: setScissorTest,\\n\\n\\t\\t\\tactiveTexture: activeTexture,\\n\\t\\t\\tbindTexture: bindTexture,\\n\\t\\t\\tcompressedTexImage2D: compressedTexImage2D,\\n\\t\\t\\ttexImage2D: texImage2D,\\n\\n\\t\\t\\tscissor: scissor,\\n\\t\\t\\tviewport: viewport,\\n\\n\\t\\t\\treset: reset\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLCapabilities( gl, extensions, parameters ) {\\n\\n\\t\\tvar maxAnisotropy;\\n\\n\\t\\tfunction getMaxAnisotropy() {\\n\\n\\t\\t\\tif ( maxAnisotropy !== undefined ) return maxAnisotropy;\\n\\n\\t\\t\\tvar extension = extensions.get( 'EXT_texture_filter_anisotropic' );\\n\\n\\t\\t\\tif ( extension !== null ) {\\n\\n\\t\\t\\t\\tmaxAnisotropy = gl.getParameter( extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tmaxAnisotropy = 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn maxAnisotropy;\\n\\n\\t\\t}\\n\\n\\t\\tfunction getMaxPrecision( precision ) {\\n\\n\\t\\t\\tif ( precision === 'highp' ) {\\n\\n\\t\\t\\t\\tif ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.HIGH_FLOAT ).precision > 0 &&\\n\\t\\t\\t\\t     gl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.HIGH_FLOAT ).precision > 0 ) {\\n\\n\\t\\t\\t\\t\\treturn 'highp';\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tprecision = 'mediump';\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( precision === 'mediump' ) {\\n\\n\\t\\t\\t\\tif ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.MEDIUM_FLOAT ).precision > 0 &&\\n\\t\\t\\t\\t     gl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT ).precision > 0 ) {\\n\\n\\t\\t\\t\\t\\treturn 'mediump';\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn 'lowp';\\n\\n\\t\\t}\\n\\n\\t\\tvar precision = parameters.precision !== undefined ? parameters.precision : 'highp';\\n\\t\\tvar maxPrecision = getMaxPrecision( precision );\\n\\n\\t\\tif ( maxPrecision !== precision ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer:', precision, 'not supported, using', maxPrecision, 'instead.' );\\n\\t\\t\\tprecision = maxPrecision;\\n\\n\\t\\t}\\n\\n\\t\\tvar logarithmicDepthBuffer = parameters.logarithmicDepthBuffer === true;\\n\\n\\t\\tvar maxTextures = gl.getParameter( gl.MAX_TEXTURE_IMAGE_UNITS );\\n\\t\\tvar maxVertexTextures = gl.getParameter( gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS );\\n\\t\\tvar maxTextureSize = gl.getParameter( gl.MAX_TEXTURE_SIZE );\\n\\t\\tvar maxCubemapSize = gl.getParameter( gl.MAX_CUBE_MAP_TEXTURE_SIZE );\\n\\n\\t\\tvar maxAttributes = gl.getParameter( gl.MAX_VERTEX_ATTRIBS );\\n\\t\\tvar maxVertexUniforms = gl.getParameter( gl.MAX_VERTEX_UNIFORM_VECTORS );\\n\\t\\tvar maxVaryings = gl.getParameter( gl.MAX_VARYING_VECTORS );\\n\\t\\tvar maxFragmentUniforms = gl.getParameter( gl.MAX_FRAGMENT_UNIFORM_VECTORS );\\n\\n\\t\\tvar vertexTextures = maxVertexTextures > 0;\\n\\t\\tvar floatFragmentTextures = !! extensions.get( 'OES_texture_float' );\\n\\t\\tvar floatVertexTextures = vertexTextures && floatFragmentTextures;\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tgetMaxAnisotropy: getMaxAnisotropy,\\n\\t\\t\\tgetMaxPrecision: getMaxPrecision,\\n\\n\\t\\t\\tprecision: precision,\\n\\t\\t\\tlogarithmicDepthBuffer: logarithmicDepthBuffer,\\n\\n\\t\\t\\tmaxTextures: maxTextures,\\n\\t\\t\\tmaxVertexTextures: maxVertexTextures,\\n\\t\\t\\tmaxTextureSize: maxTextureSize,\\n\\t\\t\\tmaxCubemapSize: maxCubemapSize,\\n\\n\\t\\t\\tmaxAttributes: maxAttributes,\\n\\t\\t\\tmaxVertexUniforms: maxVertexUniforms,\\n\\t\\t\\tmaxVaryings: maxVaryings,\\n\\t\\t\\tmaxFragmentUniforms: maxFragmentUniforms,\\n\\n\\t\\t\\tvertexTextures: vertexTextures,\\n\\t\\t\\tfloatFragmentTextures: floatFragmentTextures,\\n\\t\\t\\tfloatVertexTextures: floatVertexTextures\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author greggman / http://games.greggman.com/\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction PerspectiveCamera( fov, aspect, near, far ) {\\n\\n\\t\\tCamera.call( this );\\n\\n\\t\\tthis.type = 'PerspectiveCamera';\\n\\n\\t\\tthis.fov = fov !== undefined ? fov : 50;\\n\\t\\tthis.zoom = 1;\\n\\n\\t\\tthis.near = near !== undefined ? near : 0.1;\\n\\t\\tthis.far = far !== undefined ? far : 2000;\\n\\t\\tthis.focus = 10;\\n\\n\\t\\tthis.aspect = aspect !== undefined ? aspect : 1;\\n\\t\\tthis.view = null;\\n\\n\\t\\tthis.filmGauge = 35;\\t// width of the film (default in millimeters)\\n\\t\\tthis.filmOffset = 0;\\t// horizontal film offset (same unit as gauge)\\n\\n\\t\\tthis.updateProjectionMatrix();\\n\\n\\t}\\n\\n\\tPerspectiveCamera.prototype = Object.assign( Object.create( Camera.prototype ), {\\n\\n\\t\\tconstructor: PerspectiveCamera,\\n\\n\\t\\tisPerspectiveCamera: true,\\n\\n\\t\\tcopy: function ( source, recursive ) {\\n\\n\\t\\t\\tCamera.prototype.copy.call( this, source, recursive );\\n\\n\\t\\t\\tthis.fov = source.fov;\\n\\t\\t\\tthis.zoom = source.zoom;\\n\\n\\t\\t\\tthis.near = source.near;\\n\\t\\t\\tthis.far = source.far;\\n\\t\\t\\tthis.focus = source.focus;\\n\\n\\t\\t\\tthis.aspect = source.aspect;\\n\\t\\t\\tthis.view = source.view === null ? null : Object.assign( {}, source.view );\\n\\n\\t\\t\\tthis.filmGauge = source.filmGauge;\\n\\t\\t\\tthis.filmOffset = source.filmOffset;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t/**\\n\\t\\t * Sets the FOV by focal length in respect to the current .filmGauge.\\n\\t\\t *\\n\\t\\t * The default film gauge is 35, so that the focal length can be specified for\\n\\t\\t * a 35mm (full frame) camera.\\n\\t\\t *\\n\\t\\t * Values for focal length and film gauge must have the same unit.\\n\\t\\t */\\n\\t\\tsetFocalLength: function ( focalLength ) {\\n\\n\\t\\t\\t// see http://www.bobatkins.com/photography/technical/field_of_view.html\\n\\t\\t\\tvar vExtentSlope = 0.5 * this.getFilmHeight() / focalLength;\\n\\n\\t\\t\\tthis.fov = _Math.RAD2DEG * 2 * Math.atan( vExtentSlope );\\n\\t\\t\\tthis.updateProjectionMatrix();\\n\\n\\t\\t},\\n\\n\\t\\t/**\\n\\t\\t * Calculates the focal length from the current .fov and .filmGauge.\\n\\t\\t */\\n\\t\\tgetFocalLength: function () {\\n\\n\\t\\t\\tvar vExtentSlope = Math.tan( _Math.DEG2RAD * 0.5 * this.fov );\\n\\n\\t\\t\\treturn 0.5 * this.getFilmHeight() / vExtentSlope;\\n\\n\\t\\t},\\n\\n\\t\\tgetEffectiveFOV: function () {\\n\\n\\t\\t\\treturn _Math.RAD2DEG * 2 * Math.atan(\\n\\t\\t\\t\\tMath.tan( _Math.DEG2RAD * 0.5 * this.fov ) / this.zoom );\\n\\n\\t\\t},\\n\\n\\t\\tgetFilmWidth: function () {\\n\\n\\t\\t\\t// film not completely covered in portrait format (aspect < 1)\\n\\t\\t\\treturn this.filmGauge * Math.min( this.aspect, 1 );\\n\\n\\t\\t},\\n\\n\\t\\tgetFilmHeight: function () {\\n\\n\\t\\t\\t// film not completely covered in landscape format (aspect > 1)\\n\\t\\t\\treturn this.filmGauge / Math.max( this.aspect, 1 );\\n\\n\\t\\t},\\n\\n\\t\\t/**\\n\\t\\t * Sets an offset in a larger frustum. This is useful for multi-window or\\n\\t\\t * multi-monitor/multi-machine setups.\\n\\t\\t *\\n\\t\\t * For example, if you have 3x2 monitors and each monitor is 1920x1080 and\\n\\t\\t * the monitors are in grid like this\\n\\t\\t *\\n\\t\\t *   +---+---+---+\\n\\t\\t *   | A | B | C |\\n\\t\\t *   +---+---+---+\\n\\t\\t *   | D | E | F |\\n\\t\\t *   +---+---+---+\\n\\t\\t *\\n\\t\\t * then for each monitor you would call it like this\\n\\t\\t *\\n\\t\\t *   var w = 1920;\\n\\t\\t *   var h = 1080;\\n\\t\\t *   var fullWidth = w * 3;\\n\\t\\t *   var fullHeight = h * 2;\\n\\t\\t *\\n\\t\\t *   --A--\\n\\t\\t *   camera.setOffset( fullWidth, fullHeight, w * 0, h * 0, w, h );\\n\\t\\t *   --B--\\n\\t\\t *   camera.setOffset( fullWidth, fullHeight, w * 1, h * 0, w, h );\\n\\t\\t *   --C--\\n\\t\\t *   camera.setOffset( fullWidth, fullHeight, w * 2, h * 0, w, h );\\n\\t\\t *   --D--\\n\\t\\t *   camera.setOffset( fullWidth, fullHeight, w * 0, h * 1, w, h );\\n\\t\\t *   --E--\\n\\t\\t *   camera.setOffset( fullWidth, fullHeight, w * 1, h * 1, w, h );\\n\\t\\t *   --F--\\n\\t\\t *   camera.setOffset( fullWidth, fullHeight, w * 2, h * 1, w, h );\\n\\t\\t *\\n\\t\\t *   Note there is no reason monitors have to be the same size or in a grid.\\n\\t\\t */\\n\\t\\tsetViewOffset: function ( fullWidth, fullHeight, x, y, width, height ) {\\n\\n\\t\\t\\tthis.aspect = fullWidth / fullHeight;\\n\\n\\t\\t\\tif ( this.view === null ) {\\n\\n\\t\\t\\t\\tthis.view = {\\n\\t\\t\\t\\t\\tenabled: true,\\n\\t\\t\\t\\t\\tfullWidth: 1,\\n\\t\\t\\t\\t\\tfullHeight: 1,\\n\\t\\t\\t\\t\\toffsetX: 0,\\n\\t\\t\\t\\t\\toffsetY: 0,\\n\\t\\t\\t\\t\\twidth: 1,\\n\\t\\t\\t\\t\\theight: 1\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.view.enabled = true;\\n\\t\\t\\tthis.view.fullWidth = fullWidth;\\n\\t\\t\\tthis.view.fullHeight = fullHeight;\\n\\t\\t\\tthis.view.offsetX = x;\\n\\t\\t\\tthis.view.offsetY = y;\\n\\t\\t\\tthis.view.width = width;\\n\\t\\t\\tthis.view.height = height;\\n\\n\\t\\t\\tthis.updateProjectionMatrix();\\n\\n\\t\\t},\\n\\n\\t\\tclearViewOffset: function () {\\n\\n\\t\\t\\tif ( this.view !== null ) {\\n\\n\\t\\t\\t\\tthis.view.enabled = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.updateProjectionMatrix();\\n\\n\\t\\t},\\n\\n\\t\\tupdateProjectionMatrix: function () {\\n\\n\\t\\t\\tvar near = this.near,\\n\\t\\t\\t\\ttop = near * Math.tan(\\n\\t\\t\\t\\t\\t_Math.DEG2RAD * 0.5 * this.fov ) / this.zoom,\\n\\t\\t\\t\\theight = 2 * top,\\n\\t\\t\\t\\twidth = this.aspect * height,\\n\\t\\t\\t\\tleft = - 0.5 * width,\\n\\t\\t\\t\\tview = this.view;\\n\\n\\t\\t\\tif ( this.view !== null && this.view.enabled ) {\\n\\n\\t\\t\\t\\tvar fullWidth = view.fullWidth,\\n\\t\\t\\t\\t\\tfullHeight = view.fullHeight;\\n\\n\\t\\t\\t\\tleft += view.offsetX * width / fullWidth;\\n\\t\\t\\t\\ttop -= view.offsetY * height / fullHeight;\\n\\t\\t\\t\\twidth *= view.width / fullWidth;\\n\\t\\t\\t\\theight *= view.height / fullHeight;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar skew = this.filmOffset;\\n\\t\\t\\tif ( skew !== 0 ) left += near * skew / this.getFilmWidth();\\n\\n\\t\\t\\tthis.projectionMatrix.makePerspective( left, left + width, top, top - height, near, this.far );\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\tvar data = Object3D.prototype.toJSON.call( this, meta );\\n\\n\\t\\t\\tdata.object.fov = this.fov;\\n\\t\\t\\tdata.object.zoom = this.zoom;\\n\\n\\t\\t\\tdata.object.near = this.near;\\n\\t\\t\\tdata.object.far = this.far;\\n\\t\\t\\tdata.object.focus = this.focus;\\n\\n\\t\\t\\tdata.object.aspect = this.aspect;\\n\\n\\t\\t\\tif ( this.view !== null ) data.object.view = Object.assign( {}, this.view );\\n\\n\\t\\t\\tdata.object.filmGauge = this.filmGauge;\\n\\t\\t\\tdata.object.filmOffset = this.filmOffset;\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction ArrayCamera( array ) {\\n\\n\\t\\tPerspectiveCamera.call( this );\\n\\n\\t\\tthis.cameras = array || [];\\n\\n\\t}\\n\\n\\tArrayCamera.prototype = Object.assign( Object.create( PerspectiveCamera.prototype ), {\\n\\n\\t\\tconstructor: ArrayCamera,\\n\\n\\t\\tisArrayCamera: true\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebVRManager( renderer ) {\\n\\n\\t\\tvar scope = this;\\n\\n\\t\\tvar device = null;\\n\\t\\tvar frameData = null;\\n\\n\\t\\tvar poseTarget = null;\\n\\n\\t\\tif ( typeof window !== 'undefined' && 'VRFrameData' in window ) {\\n\\n\\t\\t\\tframeData = new window.VRFrameData();\\n\\n\\t\\t}\\n\\n\\t\\tvar matrixWorldInverse = new Matrix4();\\n\\n\\t\\tvar cameraL = new PerspectiveCamera();\\n\\t\\tcameraL.bounds = new Vector4( 0.0, 0.0, 0.5, 1.0 );\\n\\t\\tcameraL.layers.enable( 1 );\\n\\n\\t\\tvar cameraR = new PerspectiveCamera();\\n\\t\\tcameraR.bounds = new Vector4( 0.5, 0.0, 0.5, 1.0 );\\n\\t\\tcameraR.layers.enable( 2 );\\n\\n\\t\\tvar cameraVR = new ArrayCamera( [ cameraL, cameraR ] );\\n\\t\\tcameraVR.layers.enable( 1 );\\n\\t\\tcameraVR.layers.enable( 2 );\\n\\n\\t\\t//\\n\\n\\t\\tvar currentSize, currentPixelRatio;\\n\\n\\t\\tfunction onVRDisplayPresentChange() {\\n\\n\\t\\t\\tif ( device !== null && device.isPresenting ) {\\n\\n\\t\\t\\t\\tvar eyeParameters = device.getEyeParameters( 'left' );\\n\\t\\t\\t\\tvar renderWidth = eyeParameters.renderWidth;\\n\\t\\t\\t\\tvar renderHeight = eyeParameters.renderHeight;\\n\\n\\t\\t\\t\\tcurrentPixelRatio = renderer.getPixelRatio();\\n\\t\\t\\t\\tcurrentSize = renderer.getSize();\\n\\n\\t\\t\\t\\trenderer.setDrawingBufferSize( renderWidth * 2, renderHeight, 1 );\\n\\n\\t\\t\\t} else if ( scope.enabled ) {\\n\\n\\t\\t\\t\\trenderer.setDrawingBufferSize( currentSize.width, currentSize.height, currentPixelRatio );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tif ( typeof window !== 'undefined' ) {\\n\\n\\t\\t\\twindow.addEventListener( 'vrdisplaypresentchange', onVRDisplayPresentChange, false );\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tthis.enabled = false;\\n\\n\\t\\tthis.getDevice = function () {\\n\\n\\t\\t\\treturn device;\\n\\n\\t\\t};\\n\\n\\t\\tthis.setDevice = function ( value ) {\\n\\n\\t\\t\\tif ( value !== undefined ) device = value;\\n\\n\\t\\t};\\n\\n\\t\\tthis.setPoseTarget = function ( object ) {\\n\\n\\t\\t\\tif ( object !== undefined ) poseTarget = object;\\n\\n\\t\\t};\\n\\n\\t\\tthis.getCamera = function ( camera ) {\\n\\n\\t\\t\\tif ( device === null ) return camera;\\n\\n\\t\\t\\tdevice.depthNear = camera.near;\\n\\t\\t\\tdevice.depthFar = camera.far;\\n\\n\\t\\t\\tdevice.getFrameData( frameData );\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar pose = frameData.pose;\\n\\t\\t\\tvar poseObject = poseTarget !== null ? poseTarget : camera;\\n\\n\\t\\t\\tif ( pose.position !== null ) {\\n\\n\\t\\t\\t\\tposeObject.position.fromArray( pose.position );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tposeObject.position.set( 0, 0, 0 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( pose.orientation !== null ) {\\n\\n\\t\\t\\t\\tposeObject.quaternion.fromArray( pose.orientation );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tposeObject.updateMatrixWorld();\\n\\n\\t\\t\\tif ( device.isPresenting === false ) return camera;\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tcameraL.near = camera.near;\\n\\t\\t\\tcameraR.near = camera.near;\\n\\n\\t\\t\\tcameraL.far = camera.far;\\n\\t\\t\\tcameraR.far = camera.far;\\n\\n\\t\\t\\tcameraVR.matrixWorld.copy( camera.matrixWorld );\\n\\t\\t\\tcameraVR.matrixWorldInverse.copy( camera.matrixWorldInverse );\\n\\n\\t\\t\\tcameraL.matrixWorldInverse.fromArray( frameData.leftViewMatrix );\\n\\t\\t\\tcameraR.matrixWorldInverse.fromArray( frameData.rightViewMatrix );\\n\\n\\t\\t\\tvar parent = poseObject.parent;\\n\\n\\t\\t\\tif ( parent !== null ) {\\n\\n\\t\\t\\t\\tmatrixWorldInverse.getInverse( parent.matrixWorld );\\n\\n\\t\\t\\t\\tcameraL.matrixWorldInverse.multiply( matrixWorldInverse );\\n\\t\\t\\t\\tcameraR.matrixWorldInverse.multiply( matrixWorldInverse );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// envMap and Mirror needs camera.matrixWorld\\n\\n\\t\\t\\tcameraL.matrixWorld.getInverse( cameraL.matrixWorldInverse );\\n\\t\\t\\tcameraR.matrixWorld.getInverse( cameraR.matrixWorldInverse );\\n\\n\\t\\t\\tcameraL.projectionMatrix.fromArray( frameData.leftProjectionMatrix );\\n\\t\\t\\tcameraR.projectionMatrix.fromArray( frameData.rightProjectionMatrix );\\n\\n\\t\\t\\t// HACK @mrdoob\\n\\t\\t\\t// https://github.com/w3c/webvr/issues/203\\n\\n\\t\\t\\tcameraVR.projectionMatrix.copy( cameraL.projectionMatrix );\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar layers = device.getLayers();\\n\\n\\t\\t\\tif ( layers.length ) {\\n\\n\\t\\t\\t\\tvar layer = layers[ 0 ];\\n\\n\\t\\t\\t\\tif ( layer.leftBounds !== null && layer.leftBounds.length === 4 ) {\\n\\n\\t\\t\\t\\t\\tcameraL.bounds.fromArray( layer.leftBounds );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( layer.rightBounds !== null && layer.rightBounds.length === 4 ) {\\n\\n\\t\\t\\t\\t\\tcameraR.bounds.fromArray( layer.rightBounds );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn cameraVR;\\n\\n\\t\\t};\\n\\n\\t\\tthis.submitFrame = function () {\\n\\n\\t\\t\\tif ( device && device.isPresenting ) device.submitFrame();\\n\\n\\t\\t};\\n\\n\\t\\tthis.dispose = function () {\\n\\n\\t\\t\\tif ( typeof window !== 'undefined' ) {\\n\\n\\t\\t\\t\\twindow.removeEventListener( 'vrdisplaypresentchange', onVRDisplayPresentChange );\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction WebGLExtensions( gl ) {\\n\\n\\t\\tvar extensions = {};\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tget: function ( name ) {\\n\\n\\t\\t\\t\\tif ( extensions[ name ] !== undefined ) {\\n\\n\\t\\t\\t\\t\\treturn extensions[ name ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar extension;\\n\\n\\t\\t\\t\\tswitch ( name ) {\\n\\n\\t\\t\\t\\t\\tcase 'WEBGL_depth_texture':\\n\\t\\t\\t\\t\\t\\textension = gl.getExtension( 'WEBGL_depth_texture' ) || gl.getExtension( 'MOZ_WEBGL_depth_texture' ) || gl.getExtension( 'WEBKIT_WEBGL_depth_texture' );\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'EXT_texture_filter_anisotropic':\\n\\t\\t\\t\\t\\t\\textension = gl.getExtension( 'EXT_texture_filter_anisotropic' ) || gl.getExtension( 'MOZ_EXT_texture_filter_anisotropic' ) || gl.getExtension( 'WEBKIT_EXT_texture_filter_anisotropic' );\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'WEBGL_compressed_texture_s3tc':\\n\\t\\t\\t\\t\\t\\textension = gl.getExtension( 'WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'MOZ_WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_s3tc' );\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'WEBGL_compressed_texture_pvrtc':\\n\\t\\t\\t\\t\\t\\textension = gl.getExtension( 'WEBGL_compressed_texture_pvrtc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_pvrtc' );\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'WEBGL_compressed_texture_etc1':\\n\\t\\t\\t\\t\\t\\textension = gl.getExtension( 'WEBGL_compressed_texture_etc1' );\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tdefault:\\n\\t\\t\\t\\t\\t\\textension = gl.getExtension( name );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( extension === null ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: ' + name + ' extension not supported.' );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\textensions[ name ] = extension;\\n\\n\\t\\t\\t\\treturn extension;\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction WebGLClipping() {\\n\\n\\t\\tvar scope = this,\\n\\n\\t\\t\\tglobalState = null,\\n\\t\\t\\tnumGlobalPlanes = 0,\\n\\t\\t\\tlocalClippingEnabled = false,\\n\\t\\t\\trenderingShadows = false,\\n\\n\\t\\t\\tplane = new Plane(),\\n\\t\\t\\tviewNormalMatrix = new Matrix3(),\\n\\n\\t\\t\\tuniform = { value: null, needsUpdate: false };\\n\\n\\t\\tthis.uniform = uniform;\\n\\t\\tthis.numPlanes = 0;\\n\\t\\tthis.numIntersection = 0;\\n\\n\\t\\tthis.init = function ( planes, enableLocalClipping, camera ) {\\n\\n\\t\\t\\tvar enabled =\\n\\t\\t\\t\\tplanes.length !== 0 ||\\n\\t\\t\\t\\tenableLocalClipping ||\\n\\t\\t\\t\\t// enable state of previous frame - the clipping code has to\\n\\t\\t\\t\\t// run another frame in order to reset the state:\\n\\t\\t\\t\\tnumGlobalPlanes !== 0 ||\\n\\t\\t\\t\\tlocalClippingEnabled;\\n\\n\\t\\t\\tlocalClippingEnabled = enableLocalClipping;\\n\\n\\t\\t\\tglobalState = projectPlanes( planes, camera, 0 );\\n\\t\\t\\tnumGlobalPlanes = planes.length;\\n\\n\\t\\t\\treturn enabled;\\n\\n\\t\\t};\\n\\n\\t\\tthis.beginShadows = function () {\\n\\n\\t\\t\\trenderingShadows = true;\\n\\t\\t\\tprojectPlanes( null );\\n\\n\\t\\t};\\n\\n\\t\\tthis.endShadows = function () {\\n\\n\\t\\t\\trenderingShadows = false;\\n\\t\\t\\tresetGlobalState();\\n\\n\\t\\t};\\n\\n\\t\\tthis.setState = function ( planes, clipIntersection, clipShadows, camera, cache, fromCache ) {\\n\\n\\t\\t\\tif ( ! localClippingEnabled || planes === null || planes.length === 0 || renderingShadows && ! clipShadows ) {\\n\\n\\t\\t\\t\\t// there's no local clipping\\n\\n\\t\\t\\t\\tif ( renderingShadows ) {\\n\\n\\t\\t\\t\\t\\t// there's no global clipping\\n\\n\\t\\t\\t\\t\\tprojectPlanes( null );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tresetGlobalState();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tvar nGlobal = renderingShadows ? 0 : numGlobalPlanes,\\n\\t\\t\\t\\t\\tlGlobal = nGlobal * 4,\\n\\n\\t\\t\\t\\t\\tdstArray = cache.clippingState || null;\\n\\n\\t\\t\\t\\tuniform.value = dstArray; // ensure unique state\\n\\n\\t\\t\\t\\tdstArray = projectPlanes( planes, camera, lGlobal, fromCache );\\n\\n\\t\\t\\t\\tfor ( var i = 0; i !== lGlobal; ++ i ) {\\n\\n\\t\\t\\t\\t\\tdstArray[ i ] = globalState[ i ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tcache.clippingState = dstArray;\\n\\t\\t\\t\\tthis.numIntersection = clipIntersection ? this.numPlanes : 0;\\n\\t\\t\\t\\tthis.numPlanes += nGlobal;\\n\\n\\t\\t\\t}\\n\\n\\n\\t\\t};\\n\\n\\t\\tfunction resetGlobalState() {\\n\\n\\t\\t\\tif ( uniform.value !== globalState ) {\\n\\n\\t\\t\\t\\tuniform.value = globalState;\\n\\t\\t\\t\\tuniform.needsUpdate = numGlobalPlanes > 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tscope.numPlanes = numGlobalPlanes;\\n\\t\\t\\tscope.numIntersection = 0;\\n\\n\\t\\t}\\n\\n\\t\\tfunction projectPlanes( planes, camera, dstOffset, skipTransform ) {\\n\\n\\t\\t\\tvar nPlanes = planes !== null ? planes.length : 0,\\n\\t\\t\\t\\tdstArray = null;\\n\\n\\t\\t\\tif ( nPlanes !== 0 ) {\\n\\n\\t\\t\\t\\tdstArray = uniform.value;\\n\\n\\t\\t\\t\\tif ( skipTransform !== true || dstArray === null ) {\\n\\n\\t\\t\\t\\t\\tvar flatSize = dstOffset + nPlanes * 4,\\n\\t\\t\\t\\t\\t\\tviewMatrix = camera.matrixWorldInverse;\\n\\n\\t\\t\\t\\t\\tviewNormalMatrix.getNormalMatrix( viewMatrix );\\n\\n\\t\\t\\t\\t\\tif ( dstArray === null || dstArray.length < flatSize ) {\\n\\n\\t\\t\\t\\t\\t\\tdstArray = new Float32Array( flatSize );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, i4 = dstOffset; i !== nPlanes; ++ i, i4 += 4 ) {\\n\\n\\t\\t\\t\\t\\t\\tplane.copy( planes[ i ] ).applyMatrix4( viewMatrix, viewNormalMatrix );\\n\\n\\t\\t\\t\\t\\t\\tplane.normal.toArray( dstArray, i4 );\\n\\t\\t\\t\\t\\t\\tdstArray[ i4 + 3 ] = plane.constant;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tuniform.value = dstArray;\\n\\t\\t\\t\\tuniform.needsUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tscope.numPlanes = nPlanes;\\n\\n\\t\\t\\treturn dstArray;\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author thespite / http://www.twitter.com/thespite\\n\\t */\\n\\n\\tfunction WebGLUtils( gl, extensions ) {\\n\\n\\t\\tfunction convert( p ) {\\n\\n\\t\\t\\tvar extension;\\n\\n\\t\\t\\tif ( p === RepeatWrapping ) return gl.REPEAT;\\n\\t\\t\\tif ( p === ClampToEdgeWrapping ) return gl.CLAMP_TO_EDGE;\\n\\t\\t\\tif ( p === MirroredRepeatWrapping ) return gl.MIRRORED_REPEAT;\\n\\n\\t\\t\\tif ( p === NearestFilter ) return gl.NEAREST;\\n\\t\\t\\tif ( p === NearestMipMapNearestFilter ) return gl.NEAREST_MIPMAP_NEAREST;\\n\\t\\t\\tif ( p === NearestMipMapLinearFilter ) return gl.NEAREST_MIPMAP_LINEAR;\\n\\n\\t\\t\\tif ( p === LinearFilter ) return gl.LINEAR;\\n\\t\\t\\tif ( p === LinearMipMapNearestFilter ) return gl.LINEAR_MIPMAP_NEAREST;\\n\\t\\t\\tif ( p === LinearMipMapLinearFilter ) return gl.LINEAR_MIPMAP_LINEAR;\\n\\n\\t\\t\\tif ( p === UnsignedByteType ) return gl.UNSIGNED_BYTE;\\n\\t\\t\\tif ( p === UnsignedShort4444Type ) return gl.UNSIGNED_SHORT_4_4_4_4;\\n\\t\\t\\tif ( p === UnsignedShort5551Type ) return gl.UNSIGNED_SHORT_5_5_5_1;\\n\\t\\t\\tif ( p === UnsignedShort565Type ) return gl.UNSIGNED_SHORT_5_6_5;\\n\\n\\t\\t\\tif ( p === ByteType ) return gl.BYTE;\\n\\t\\t\\tif ( p === ShortType ) return gl.SHORT;\\n\\t\\t\\tif ( p === UnsignedShortType ) return gl.UNSIGNED_SHORT;\\n\\t\\t\\tif ( p === IntType ) return gl.INT;\\n\\t\\t\\tif ( p === UnsignedIntType ) return gl.UNSIGNED_INT;\\n\\t\\t\\tif ( p === FloatType ) return gl.FLOAT;\\n\\n\\t\\t\\tif ( p === HalfFloatType ) {\\n\\n\\t\\t\\t\\textension = extensions.get( 'OES_texture_half_float' );\\n\\n\\t\\t\\t\\tif ( extension !== null ) return extension.HALF_FLOAT_OES;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( p === AlphaFormat ) return gl.ALPHA;\\n\\t\\t\\tif ( p === RGBFormat ) return gl.RGB;\\n\\t\\t\\tif ( p === RGBAFormat ) return gl.RGBA;\\n\\t\\t\\tif ( p === LuminanceFormat ) return gl.LUMINANCE;\\n\\t\\t\\tif ( p === LuminanceAlphaFormat ) return gl.LUMINANCE_ALPHA;\\n\\t\\t\\tif ( p === DepthFormat ) return gl.DEPTH_COMPONENT;\\n\\t\\t\\tif ( p === DepthStencilFormat ) return gl.DEPTH_STENCIL;\\n\\n\\t\\t\\tif ( p === AddEquation ) return gl.FUNC_ADD;\\n\\t\\t\\tif ( p === SubtractEquation ) return gl.FUNC_SUBTRACT;\\n\\t\\t\\tif ( p === ReverseSubtractEquation ) return gl.FUNC_REVERSE_SUBTRACT;\\n\\n\\t\\t\\tif ( p === ZeroFactor ) return gl.ZERO;\\n\\t\\t\\tif ( p === OneFactor ) return gl.ONE;\\n\\t\\t\\tif ( p === SrcColorFactor ) return gl.SRC_COLOR;\\n\\t\\t\\tif ( p === OneMinusSrcColorFactor ) return gl.ONE_MINUS_SRC_COLOR;\\n\\t\\t\\tif ( p === SrcAlphaFactor ) return gl.SRC_ALPHA;\\n\\t\\t\\tif ( p === OneMinusSrcAlphaFactor ) return gl.ONE_MINUS_SRC_ALPHA;\\n\\t\\t\\tif ( p === DstAlphaFactor ) return gl.DST_ALPHA;\\n\\t\\t\\tif ( p === OneMinusDstAlphaFactor ) return gl.ONE_MINUS_DST_ALPHA;\\n\\n\\t\\t\\tif ( p === DstColorFactor ) return gl.DST_COLOR;\\n\\t\\t\\tif ( p === OneMinusDstColorFactor ) return gl.ONE_MINUS_DST_COLOR;\\n\\t\\t\\tif ( p === SrcAlphaSaturateFactor ) return gl.SRC_ALPHA_SATURATE;\\n\\n\\t\\t\\tif ( p === RGB_S3TC_DXT1_Format || p === RGBA_S3TC_DXT1_Format ||\\n\\t\\t\\t\\tp === RGBA_S3TC_DXT3_Format || p === RGBA_S3TC_DXT5_Format ) {\\n\\n\\t\\t\\t\\textension = extensions.get( 'WEBGL_compressed_texture_s3tc' );\\n\\n\\t\\t\\t\\tif ( extension !== null ) {\\n\\n\\t\\t\\t\\t\\tif ( p === RGB_S3TC_DXT1_Format ) return extension.COMPRESSED_RGB_S3TC_DXT1_EXT;\\n\\t\\t\\t\\t\\tif ( p === RGBA_S3TC_DXT1_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT1_EXT;\\n\\t\\t\\t\\t\\tif ( p === RGBA_S3TC_DXT3_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT3_EXT;\\n\\t\\t\\t\\t\\tif ( p === RGBA_S3TC_DXT5_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT5_EXT;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( p === RGB_PVRTC_4BPPV1_Format || p === RGB_PVRTC_2BPPV1_Format ||\\n\\t\\t\\t\\tp === RGBA_PVRTC_4BPPV1_Format || p === RGBA_PVRTC_2BPPV1_Format ) {\\n\\n\\t\\t\\t\\textension = extensions.get( 'WEBGL_compressed_texture_pvrtc' );\\n\\n\\t\\t\\t\\tif ( extension !== null ) {\\n\\n\\t\\t\\t\\t\\tif ( p === RGB_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;\\n\\t\\t\\t\\t\\tif ( p === RGB_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;\\n\\t\\t\\t\\t\\tif ( p === RGBA_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;\\n\\t\\t\\t\\t\\tif ( p === RGBA_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( p === RGB_ETC1_Format ) {\\n\\n\\t\\t\\t\\textension = extensions.get( 'WEBGL_compressed_texture_etc1' );\\n\\n\\t\\t\\t\\tif ( extension !== null ) return extension.COMPRESSED_RGB_ETC1_WEBGL;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( p === MinEquation || p === MaxEquation ) {\\n\\n\\t\\t\\t\\textension = extensions.get( 'EXT_blend_minmax' );\\n\\n\\t\\t\\t\\tif ( extension !== null ) {\\n\\n\\t\\t\\t\\t\\tif ( p === MinEquation ) return extension.MIN_EXT;\\n\\t\\t\\t\\t\\tif ( p === MaxEquation ) return extension.MAX_EXT;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( p === UnsignedInt248Type ) {\\n\\n\\t\\t\\t\\textension = extensions.get( 'WEBGL_depth_texture' );\\n\\n\\t\\t\\t\\tif ( extension !== null ) return extension.UNSIGNED_INT_24_8_WEBGL;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn 0;\\n\\n\\t\\t}\\n\\n\\t\\treturn { convert: convert };\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author supereggbert / http://www.paulbrunt.co.uk/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author szimek / https://github.com/szimek/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction WebGLRenderer( parameters ) {\\n\\n\\t\\tconsole.log( 'THREE.WebGLRenderer', REVISION );\\n\\n\\t\\tparameters = parameters || {};\\n\\n\\t\\tvar _canvas = parameters.canvas !== undefined ? parameters.canvas : document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' ),\\n\\t\\t\\t_context = parameters.context !== undefined ? parameters.context : null,\\n\\n\\t\\t\\t_alpha = parameters.alpha !== undefined ? parameters.alpha : false,\\n\\t\\t\\t_depth = parameters.depth !== undefined ? parameters.depth : true,\\n\\t\\t\\t_stencil = parameters.stencil !== undefined ? parameters.stencil : true,\\n\\t\\t\\t_antialias = parameters.antialias !== undefined ? parameters.antialias : false,\\n\\t\\t\\t_premultipliedAlpha = parameters.premultipliedAlpha !== undefined ? parameters.premultipliedAlpha : true,\\n\\t\\t\\t_preserveDrawingBuffer = parameters.preserveDrawingBuffer !== undefined ? parameters.preserveDrawingBuffer : false,\\n\\t\\t\\t_powerPreference = parameters.powerPreference !== undefined ? parameters.powerPreference : 'default';\\n\\n\\t\\tvar lightsArray = [];\\n\\t\\tvar shadowsArray = [];\\n\\n\\t\\tvar currentRenderList = null;\\n\\n\\t\\tvar spritesArray = [];\\n\\t\\tvar flaresArray = [];\\n\\n\\t\\t// public properties\\n\\n\\t\\tthis.domElement = _canvas;\\n\\t\\tthis.context = null;\\n\\n\\t\\t// clearing\\n\\n\\t\\tthis.autoClear = true;\\n\\t\\tthis.autoClearColor = true;\\n\\t\\tthis.autoClearDepth = true;\\n\\t\\tthis.autoClearStencil = true;\\n\\n\\t\\t// scene graph\\n\\n\\t\\tthis.sortObjects = true;\\n\\n\\t\\t// user-defined clipping\\n\\n\\t\\tthis.clippingPlanes = [];\\n\\t\\tthis.localClippingEnabled = false;\\n\\n\\t\\t// physically based shading\\n\\n\\t\\tthis.gammaFactor = 2.0;\\t// for backwards compatibility\\n\\t\\tthis.gammaInput = false;\\n\\t\\tthis.gammaOutput = false;\\n\\n\\t\\t// physical lights\\n\\n\\t\\tthis.physicallyCorrectLights = false;\\n\\n\\t\\t// tone mapping\\n\\n\\t\\tthis.toneMapping = LinearToneMapping;\\n\\t\\tthis.toneMappingExposure = 1.0;\\n\\t\\tthis.toneMappingWhitePoint = 1.0;\\n\\n\\t\\t// morphs\\n\\n\\t\\tthis.maxMorphTargets = 8;\\n\\t\\tthis.maxMorphNormals = 4;\\n\\n\\t\\t// internal properties\\n\\n\\t\\tvar _this = this,\\n\\n\\t\\t\\t_isContextLost = false,\\n\\n\\t\\t\\t// internal state cache\\n\\n\\t\\t\\t_currentRenderTarget = null,\\n\\t\\t\\t_currentFramebuffer = null,\\n\\t\\t\\t_currentMaterialId = - 1,\\n\\t\\t\\t_currentGeometryProgram = '',\\n\\n\\t\\t\\t_currentCamera = null,\\n\\t\\t\\t_currentArrayCamera = null,\\n\\n\\t\\t\\t_currentViewport = new Vector4(),\\n\\t\\t\\t_currentScissor = new Vector4(),\\n\\t\\t\\t_currentScissorTest = null,\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\t_usedTextureUnits = 0,\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\t_width = _canvas.width,\\n\\t\\t\\t_height = _canvas.height,\\n\\n\\t\\t\\t_pixelRatio = 1,\\n\\n\\t\\t\\t_viewport = new Vector4( 0, 0, _width, _height ),\\n\\t\\t\\t_scissor = new Vector4( 0, 0, _width, _height ),\\n\\t\\t\\t_scissorTest = false,\\n\\n\\t\\t\\t// frustum\\n\\n\\t\\t\\t_frustum = new Frustum(),\\n\\n\\t\\t\\t// clipping\\n\\n\\t\\t\\t_clipping = new WebGLClipping(),\\n\\t\\t\\t_clippingEnabled = false,\\n\\t\\t\\t_localClippingEnabled = false,\\n\\n\\t\\t\\t// camera matrices cache\\n\\n\\t\\t\\t_projScreenMatrix = new Matrix4(),\\n\\n\\t\\t\\t_vector3 = new Vector3(),\\n\\n\\t\\t\\t// info\\n\\n\\t\\t\\t_infoMemory = {\\n\\t\\t\\t\\tgeometries: 0,\\n\\t\\t\\t\\ttextures: 0\\n\\t\\t\\t},\\n\\n\\t\\t\\t_infoRender = {\\n\\n\\t\\t\\t\\tframe: 0,\\n\\t\\t\\t\\tcalls: 0,\\n\\t\\t\\t\\tvertices: 0,\\n\\t\\t\\t\\tfaces: 0,\\n\\t\\t\\t\\tpoints: 0\\n\\n\\t\\t\\t};\\n\\n\\t\\tthis.info = {\\n\\n\\t\\t\\trender: _infoRender,\\n\\t\\t\\tmemory: _infoMemory,\\n\\t\\t\\tprograms: null\\n\\n\\t\\t};\\n\\n\\t\\tfunction getTargetPixelRatio() {\\n\\n\\t\\t\\treturn _currentRenderTarget === null ? _pixelRatio : 1;\\n\\n\\t\\t}\\n\\n\\t\\t// initialize\\n\\n\\t\\tvar _gl;\\n\\n\\t\\ttry {\\n\\n\\t\\t\\tvar contextAttributes = {\\n\\t\\t\\t\\talpha: _alpha,\\n\\t\\t\\t\\tdepth: _depth,\\n\\t\\t\\t\\tstencil: _stencil,\\n\\t\\t\\t\\tantialias: _antialias,\\n\\t\\t\\t\\tpremultipliedAlpha: _premultipliedAlpha,\\n\\t\\t\\t\\tpreserveDrawingBuffer: _preserveDrawingBuffer,\\n\\t\\t\\t\\tpowerPreference: _powerPreference\\n\\t\\t\\t};\\n\\n\\t\\t\\t// event listeners must be registered before WebGL context is created, see #12753\\n\\n\\t\\t\\t_canvas.addEventListener( 'webglcontextlost', onContextLost, false );\\n\\t\\t\\t_canvas.addEventListener( 'webglcontextrestored', onContextRestore, false );\\n\\n\\t\\t\\t_gl = _context || _canvas.getContext( 'webgl', contextAttributes ) || _canvas.getContext( 'experimental-webgl', contextAttributes );\\n\\n\\t\\t\\tif ( _gl === null ) {\\n\\n\\t\\t\\t\\tif ( _canvas.getContext( 'webgl' ) !== null ) {\\n\\n\\t\\t\\t\\t\\tthrow new Error( 'Error creating WebGL context with your selected attributes.' );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tthrow new Error( 'Error creating WebGL context.' );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Some experimental-webgl implementations do not have getShaderPrecisionFormat\\n\\n\\t\\t\\tif ( _gl.getShaderPrecisionFormat === undefined ) {\\n\\n\\t\\t\\t\\t_gl.getShaderPrecisionFormat = function () {\\n\\n\\t\\t\\t\\t\\treturn { 'rangeMin': 1, 'rangeMax': 1, 'precision': 1 };\\n\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t}\\n\\n\\t\\t} catch ( error ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.WebGLRenderer: ' + error.message );\\n\\n\\t\\t}\\n\\n\\t\\tvar extensions, capabilities, state;\\n\\t\\tvar properties, textures, attributes, geometries, objects, lights;\\n\\t\\tvar programCache, renderLists;\\n\\n\\t\\tvar background, morphtargets, bufferRenderer, indexedBufferRenderer;\\n\\t\\tvar flareRenderer, spriteRenderer;\\n\\n\\t\\tvar utils;\\n\\n\\t\\tfunction initGLContext() {\\n\\n\\t\\t\\textensions = new WebGLExtensions( _gl );\\n\\t\\t\\textensions.get( 'WEBGL_depth_texture' );\\n\\t\\t\\textensions.get( 'OES_texture_float' );\\n\\t\\t\\textensions.get( 'OES_texture_float_linear' );\\n\\t\\t\\textensions.get( 'OES_texture_half_float' );\\n\\t\\t\\textensions.get( 'OES_texture_half_float_linear' );\\n\\t\\t\\textensions.get( 'OES_standard_derivatives' );\\n\\t\\t\\textensions.get( 'OES_element_index_uint' );\\n\\t\\t\\textensions.get( 'ANGLE_instanced_arrays' );\\n\\n\\t\\t\\tutils = new WebGLUtils( _gl, extensions );\\n\\n\\t\\t\\tcapabilities = new WebGLCapabilities( _gl, extensions, parameters );\\n\\n\\t\\t\\tstate = new WebGLState( _gl, extensions, utils );\\n\\t\\t\\tstate.scissor( _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ) );\\n\\t\\t\\tstate.viewport( _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ) );\\n\\n\\t\\t\\tproperties = new WebGLProperties();\\n\\t\\t\\ttextures = new WebGLTextures( _gl, extensions, state, properties, capabilities, utils, _infoMemory );\\n\\t\\t\\tattributes = new WebGLAttributes( _gl );\\n\\t\\t\\tgeometries = new WebGLGeometries( _gl, attributes, _infoMemory );\\n\\t\\t\\tobjects = new WebGLObjects( geometries, _infoRender );\\n\\t\\t\\tmorphtargets = new WebGLMorphtargets( _gl );\\n\\t\\t\\tprogramCache = new WebGLPrograms( _this, extensions, capabilities );\\n\\t\\t\\tlights = new WebGLLights();\\n\\t\\t\\trenderLists = new WebGLRenderLists();\\n\\n\\t\\t\\tbackground = new WebGLBackground( _this, state, geometries, _premultipliedAlpha );\\n\\n\\t\\t\\tbufferRenderer = new WebGLBufferRenderer( _gl, extensions, _infoRender );\\n\\t\\t\\tindexedBufferRenderer = new WebGLIndexedBufferRenderer( _gl, extensions, _infoRender );\\n\\n\\t\\t\\tflareRenderer = new WebGLFlareRenderer( _this, _gl, state, textures, capabilities );\\n\\t\\t\\tspriteRenderer = new WebGLSpriteRenderer( _this, _gl, state, textures, capabilities );\\n\\n\\t\\t\\t_this.info.programs = programCache.programs;\\n\\n\\t\\t\\t_this.context = _gl;\\n\\t\\t\\t_this.capabilities = capabilities;\\n\\t\\t\\t_this.extensions = extensions;\\n\\t\\t\\t_this.properties = properties;\\n\\t\\t\\t_this.renderLists = renderLists;\\n\\t\\t\\t_this.state = state;\\n\\n\\t\\t}\\n\\n\\t\\tinitGLContext();\\n\\n\\t\\t// vr\\n\\n\\t\\tvar vr = new WebVRManager( _this );\\n\\n\\t\\tthis.vr = vr;\\n\\n\\t\\t// shadow map\\n\\n\\t\\tvar shadowMap = new WebGLShadowMap( _this, objects, capabilities.maxTextureSize );\\n\\n\\t\\tthis.shadowMap = shadowMap;\\n\\n\\t\\t// API\\n\\n\\t\\tthis.getContext = function () {\\n\\n\\t\\t\\treturn _gl;\\n\\n\\t\\t};\\n\\n\\t\\tthis.getContextAttributes = function () {\\n\\n\\t\\t\\treturn _gl.getContextAttributes();\\n\\n\\t\\t};\\n\\n\\t\\tthis.forceContextLoss = function () {\\n\\n\\t\\t\\tvar extension = extensions.get( 'WEBGL_lose_context' );\\n\\t\\t\\tif ( extension ) extension.loseContext();\\n\\n\\t\\t};\\n\\n\\t\\tthis.forceContextRestore = function () {\\n\\n\\t\\t\\tvar extension = extensions.get( 'WEBGL_lose_context' );\\n\\t\\t\\tif ( extension ) extension.restoreContext();\\n\\n\\t\\t};\\n\\n\\t\\tthis.getPixelRatio = function () {\\n\\n\\t\\t\\treturn _pixelRatio;\\n\\n\\t\\t};\\n\\n\\t\\tthis.setPixelRatio = function ( value ) {\\n\\n\\t\\t\\tif ( value === undefined ) return;\\n\\n\\t\\t\\t_pixelRatio = value;\\n\\n\\t\\t\\tthis.setSize( _width, _height, false );\\n\\n\\t\\t};\\n\\n\\t\\tthis.getSize = function () {\\n\\n\\t\\t\\treturn {\\n\\t\\t\\t\\twidth: _width,\\n\\t\\t\\t\\theight: _height\\n\\t\\t\\t};\\n\\n\\t\\t};\\n\\n\\t\\tthis.setSize = function ( width, height, updateStyle ) {\\n\\n\\t\\t\\tvar device = vr.getDevice();\\n\\n\\t\\t\\tif ( device && device.isPresenting ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Can\\\\'t change size while VR device is presenting.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t_width = width;\\n\\t\\t\\t_height = height;\\n\\n\\t\\t\\t_canvas.width = width * _pixelRatio;\\n\\t\\t\\t_canvas.height = height * _pixelRatio;\\n\\n\\t\\t\\tif ( updateStyle !== false ) {\\n\\n\\t\\t\\t\\t_canvas.style.width = width + 'px';\\n\\t\\t\\t\\t_canvas.style.height = height + 'px';\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.setViewport( 0, 0, width, height );\\n\\n\\t\\t};\\n\\n\\t\\tthis.getDrawingBufferSize = function () {\\n\\n\\t\\t\\treturn {\\n\\t\\t\\t\\twidth: _width * _pixelRatio,\\n\\t\\t\\t\\theight: _height * _pixelRatio\\n\\t\\t\\t};\\n\\n\\t\\t};\\n\\n\\t\\tthis.setDrawingBufferSize = function ( width, height, pixelRatio ) {\\n\\n\\t\\t\\t_width = width;\\n\\t\\t\\t_height = height;\\n\\n\\t\\t\\t_pixelRatio = pixelRatio;\\n\\n\\t\\t\\t_canvas.width = width * pixelRatio;\\n\\t\\t\\t_canvas.height = height * pixelRatio;\\n\\n\\t\\t\\tthis.setViewport( 0, 0, width, height );\\n\\n\\t\\t};\\n\\n\\t\\tthis.setViewport = function ( x, y, width, height ) {\\n\\n\\t\\t\\t_viewport.set( x, _height - y - height, width, height );\\n\\t\\t\\tstate.viewport( _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ) );\\n\\n\\t\\t};\\n\\n\\t\\tthis.setScissor = function ( x, y, width, height ) {\\n\\n\\t\\t\\t_scissor.set( x, _height - y - height, width, height );\\n\\t\\t\\tstate.scissor( _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ) );\\n\\n\\t\\t};\\n\\n\\t\\tthis.setScissorTest = function ( boolean ) {\\n\\n\\t\\t\\tstate.setScissorTest( _scissorTest = boolean );\\n\\n\\t\\t};\\n\\n\\t\\t// Clearing\\n\\n\\t\\tthis.getClearColor = function () {\\n\\n\\t\\t\\treturn background.getClearColor();\\n\\n\\t\\t};\\n\\n\\t\\tthis.setClearColor = function () {\\n\\n\\t\\t\\tbackground.setClearColor.apply( background, arguments );\\n\\n\\t\\t};\\n\\n\\t\\tthis.getClearAlpha = function () {\\n\\n\\t\\t\\treturn background.getClearAlpha();\\n\\n\\t\\t};\\n\\n\\t\\tthis.setClearAlpha = function () {\\n\\n\\t\\t\\tbackground.setClearAlpha.apply( background, arguments );\\n\\n\\t\\t};\\n\\n\\t\\tthis.clear = function ( color, depth, stencil ) {\\n\\n\\t\\t\\tvar bits = 0;\\n\\n\\t\\t\\tif ( color === undefined || color ) bits |= _gl.COLOR_BUFFER_BIT;\\n\\t\\t\\tif ( depth === undefined || depth ) bits |= _gl.DEPTH_BUFFER_BIT;\\n\\t\\t\\tif ( stencil === undefined || stencil ) bits |= _gl.STENCIL_BUFFER_BIT;\\n\\n\\t\\t\\t_gl.clear( bits );\\n\\n\\t\\t};\\n\\n\\t\\tthis.clearColor = function () {\\n\\n\\t\\t\\tthis.clear( true, false, false );\\n\\n\\t\\t};\\n\\n\\t\\tthis.clearDepth = function () {\\n\\n\\t\\t\\tthis.clear( false, true, false );\\n\\n\\t\\t};\\n\\n\\t\\tthis.clearStencil = function () {\\n\\n\\t\\t\\tthis.clear( false, false, true );\\n\\n\\t\\t};\\n\\n\\t\\tthis.clearTarget = function ( renderTarget, color, depth, stencil ) {\\n\\n\\t\\t\\tthis.setRenderTarget( renderTarget );\\n\\t\\t\\tthis.clear( color, depth, stencil );\\n\\n\\t\\t};\\n\\n\\t\\t//\\n\\n\\t\\tthis.dispose = function () {\\n\\n\\t\\t\\t_canvas.removeEventListener( 'webglcontextlost', onContextLost, false );\\n\\t\\t\\t_canvas.removeEventListener( 'webglcontextrestored', onContextRestore, false );\\n\\n\\t\\t\\trenderLists.dispose();\\n\\n\\t\\t\\tvr.dispose();\\n\\n\\t\\t};\\n\\n\\t\\t// Events\\n\\n\\t\\tfunction onContextLost( event ) {\\n\\n\\t\\t\\tevent.preventDefault();\\n\\n\\t\\t\\tconsole.log( 'THREE.WebGLRenderer: Context Lost.' );\\n\\n\\t\\t\\t_isContextLost = true;\\n\\n\\t\\t}\\n\\n\\t\\tfunction onContextRestore( /* event */ ) {\\n\\n\\t\\t\\tconsole.log( 'THREE.WebGLRenderer: Context Restored.' );\\n\\n\\t\\t\\t_isContextLost = false;\\n\\n\\t\\t\\tinitGLContext();\\n\\n\\t\\t}\\n\\n\\t\\tfunction onMaterialDispose( event ) {\\n\\n\\t\\t\\tvar material = event.target;\\n\\n\\t\\t\\tmaterial.removeEventListener( 'dispose', onMaterialDispose );\\n\\n\\t\\t\\tdeallocateMaterial( material );\\n\\n\\t\\t}\\n\\n\\t\\t// Buffer deallocation\\n\\n\\t\\tfunction deallocateMaterial( material ) {\\n\\n\\t\\t\\treleaseMaterialProgramReference( material );\\n\\n\\t\\t\\tproperties.remove( material );\\n\\n\\t\\t}\\n\\n\\n\\t\\tfunction releaseMaterialProgramReference( material ) {\\n\\n\\t\\t\\tvar programInfo = properties.get( material ).program;\\n\\n\\t\\t\\tmaterial.program = undefined;\\n\\n\\t\\t\\tif ( programInfo !== undefined ) {\\n\\n\\t\\t\\t\\tprogramCache.releaseProgram( programInfo );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// Buffer rendering\\n\\n\\t\\tfunction renderObjectImmediate( object, program, material ) {\\n\\n\\t\\t\\tobject.render( function ( object ) {\\n\\n\\t\\t\\t\\t_this.renderBufferImmediate( object, program, material );\\n\\n\\t\\t\\t} );\\n\\n\\t\\t}\\n\\n\\t\\tthis.renderBufferImmediate = function ( object, program, material ) {\\n\\n\\t\\t\\tstate.initAttributes();\\n\\n\\t\\t\\tvar buffers = properties.get( object );\\n\\n\\t\\t\\tif ( object.hasPositions && ! buffers.position ) buffers.position = _gl.createBuffer();\\n\\t\\t\\tif ( object.hasNormals && ! buffers.normal ) buffers.normal = _gl.createBuffer();\\n\\t\\t\\tif ( object.hasUvs && ! buffers.uv ) buffers.uv = _gl.createBuffer();\\n\\t\\t\\tif ( object.hasColors && ! buffers.color ) buffers.color = _gl.createBuffer();\\n\\n\\t\\t\\tvar programAttributes = program.getAttributes();\\n\\n\\t\\t\\tif ( object.hasPositions ) {\\n\\n\\t\\t\\t\\t_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.position );\\n\\t\\t\\t\\t_gl.bufferData( _gl.ARRAY_BUFFER, object.positionArray, _gl.DYNAMIC_DRAW );\\n\\n\\t\\t\\t\\tstate.enableAttribute( programAttributes.position );\\n\\t\\t\\t\\t_gl.vertexAttribPointer( programAttributes.position, 3, _gl.FLOAT, false, 0, 0 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( object.hasNormals ) {\\n\\n\\t\\t\\t\\t_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.normal );\\n\\n\\t\\t\\t\\tif ( ! material.isMeshPhongMaterial &&\\n\\t\\t\\t\\t\\t! material.isMeshStandardMaterial &&\\n\\t\\t\\t\\t\\t! material.isMeshNormalMaterial &&\\n\\t\\t\\t\\t\\tmaterial.flatShading === true ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, l = object.count * 3; i < l; i += 9 ) {\\n\\n\\t\\t\\t\\t\\t\\tvar array = object.normalArray;\\n\\n\\t\\t\\t\\t\\t\\tvar nx = ( array[ i + 0 ] + array[ i + 3 ] + array[ i + 6 ] ) / 3;\\n\\t\\t\\t\\t\\t\\tvar ny = ( array[ i + 1 ] + array[ i + 4 ] + array[ i + 7 ] ) / 3;\\n\\t\\t\\t\\t\\t\\tvar nz = ( array[ i + 2 ] + array[ i + 5 ] + array[ i + 8 ] ) / 3;\\n\\n\\t\\t\\t\\t\\t\\tarray[ i + 0 ] = nx;\\n\\t\\t\\t\\t\\t\\tarray[ i + 1 ] = ny;\\n\\t\\t\\t\\t\\t\\tarray[ i + 2 ] = nz;\\n\\n\\t\\t\\t\\t\\t\\tarray[ i + 3 ] = nx;\\n\\t\\t\\t\\t\\t\\tarray[ i + 4 ] = ny;\\n\\t\\t\\t\\t\\t\\tarray[ i + 5 ] = nz;\\n\\n\\t\\t\\t\\t\\t\\tarray[ i + 6 ] = nx;\\n\\t\\t\\t\\t\\t\\tarray[ i + 7 ] = ny;\\n\\t\\t\\t\\t\\t\\tarray[ i + 8 ] = nz;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t_gl.bufferData( _gl.ARRAY_BUFFER, object.normalArray, _gl.DYNAMIC_DRAW );\\n\\n\\t\\t\\t\\tstate.enableAttribute( programAttributes.normal );\\n\\n\\t\\t\\t\\t_gl.vertexAttribPointer( programAttributes.normal, 3, _gl.FLOAT, false, 0, 0 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( object.hasUvs && material.map ) {\\n\\n\\t\\t\\t\\t_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.uv );\\n\\t\\t\\t\\t_gl.bufferData( _gl.ARRAY_BUFFER, object.uvArray, _gl.DYNAMIC_DRAW );\\n\\n\\t\\t\\t\\tstate.enableAttribute( programAttributes.uv );\\n\\n\\t\\t\\t\\t_gl.vertexAttribPointer( programAttributes.uv, 2, _gl.FLOAT, false, 0, 0 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( object.hasColors && material.vertexColors !== NoColors ) {\\n\\n\\t\\t\\t\\t_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.color );\\n\\t\\t\\t\\t_gl.bufferData( _gl.ARRAY_BUFFER, object.colorArray, _gl.DYNAMIC_DRAW );\\n\\n\\t\\t\\t\\tstate.enableAttribute( programAttributes.color );\\n\\n\\t\\t\\t\\t_gl.vertexAttribPointer( programAttributes.color, 3, _gl.FLOAT, false, 0, 0 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tstate.disableUnusedAttributes();\\n\\n\\t\\t\\t_gl.drawArrays( _gl.TRIANGLES, 0, object.count );\\n\\n\\t\\t\\tobject.count = 0;\\n\\n\\t\\t};\\n\\n\\t\\tthis.renderBufferDirect = function ( camera, fog, geometry, material, object, group ) {\\n\\n\\t\\t\\tvar frontFaceCW = ( object.isMesh && object.matrixWorld.determinant() < 0 );\\n\\n\\t\\t\\tstate.setMaterial( material, frontFaceCW );\\n\\n\\t\\t\\tvar program = setProgram( camera, fog, material, object );\\n\\t\\t\\tvar geometryProgram = geometry.id + '_' + program.id + '_' + ( material.wireframe === true );\\n\\n\\t\\t\\tvar updateBuffers = false;\\n\\n\\t\\t\\tif ( geometryProgram !== _currentGeometryProgram ) {\\n\\n\\t\\t\\t\\t_currentGeometryProgram = geometryProgram;\\n\\t\\t\\t\\tupdateBuffers = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( object.morphTargetInfluences ) {\\n\\n\\t\\t\\t\\tmorphtargets.update( object, geometry, material, program );\\n\\n\\t\\t\\t\\tupdateBuffers = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar index = geometry.index;\\n\\t\\t\\tvar position = geometry.attributes.position;\\n\\t\\t\\tvar rangeFactor = 1;\\n\\n\\t\\t\\tif ( material.wireframe === true ) {\\n\\n\\t\\t\\t\\tindex = geometries.getWireframeAttribute( geometry );\\n\\t\\t\\t\\trangeFactor = 2;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar attribute;\\n\\t\\t\\tvar renderer = bufferRenderer;\\n\\n\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\tattribute = attributes.get( index );\\n\\n\\t\\t\\t\\trenderer = indexedBufferRenderer;\\n\\t\\t\\t\\trenderer.setIndex( attribute );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( updateBuffers ) {\\n\\n\\t\\t\\t\\tsetupVertexAttributes( material, program, geometry );\\n\\n\\t\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\t\\t_gl.bindBuffer( _gl.ELEMENT_ARRAY_BUFFER, attribute.buffer );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar dataCount = 0;\\n\\n\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\tdataCount = index.count;\\n\\n\\t\\t\\t} else if ( position !== undefined ) {\\n\\n\\t\\t\\t\\tdataCount = position.count;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar rangeStart = geometry.drawRange.start * rangeFactor;\\n\\t\\t\\tvar rangeCount = geometry.drawRange.count * rangeFactor;\\n\\n\\t\\t\\tvar groupStart = group !== null ? group.start * rangeFactor : 0;\\n\\t\\t\\tvar groupCount = group !== null ? group.count * rangeFactor : Infinity;\\n\\n\\t\\t\\tvar drawStart = Math.max( rangeStart, groupStart );\\n\\t\\t\\tvar drawEnd = Math.min( dataCount, rangeStart + rangeCount, groupStart + groupCount ) - 1;\\n\\n\\t\\t\\tvar drawCount = Math.max( 0, drawEnd - drawStart + 1 );\\n\\n\\t\\t\\tif ( drawCount === 0 ) return;\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tif ( object.isMesh ) {\\n\\n\\t\\t\\t\\tif ( material.wireframe === true ) {\\n\\n\\t\\t\\t\\t\\tstate.setLineWidth( material.wireframeLinewidth * getTargetPixelRatio() );\\n\\t\\t\\t\\t\\trenderer.setMode( _gl.LINES );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tswitch ( object.drawMode ) {\\n\\n\\t\\t\\t\\t\\t\\tcase TrianglesDrawMode:\\n\\t\\t\\t\\t\\t\\t\\trenderer.setMode( _gl.TRIANGLES );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase TriangleStripDrawMode:\\n\\t\\t\\t\\t\\t\\t\\trenderer.setMode( _gl.TRIANGLE_STRIP );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase TriangleFanDrawMode:\\n\\t\\t\\t\\t\\t\\t\\trenderer.setMode( _gl.TRIANGLE_FAN );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\n\\t\\t\\t} else if ( object.isLine ) {\\n\\n\\t\\t\\t\\tvar lineWidth = material.linewidth;\\n\\n\\t\\t\\t\\tif ( lineWidth === undefined ) lineWidth = 1; // Not using Line*Material\\n\\n\\t\\t\\t\\tstate.setLineWidth( lineWidth * getTargetPixelRatio() );\\n\\n\\t\\t\\t\\tif ( object.isLineSegments ) {\\n\\n\\t\\t\\t\\t\\trenderer.setMode( _gl.LINES );\\n\\n\\t\\t\\t\\t} else if ( object.isLineLoop ) {\\n\\n\\t\\t\\t\\t\\trenderer.setMode( _gl.LINE_LOOP );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\trenderer.setMode( _gl.LINE_STRIP );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( object.isPoints ) {\\n\\n\\t\\t\\t\\trenderer.setMode( _gl.POINTS );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( geometry && geometry.isInstancedBufferGeometry ) {\\n\\n\\t\\t\\t\\tif ( geometry.maxInstancedCount > 0 ) {\\n\\n\\t\\t\\t\\t\\trenderer.renderInstances( geometry, drawStart, drawCount );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\trenderer.render( drawStart, drawCount );\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t\\tfunction setupVertexAttributes( material, program, geometry, startIndex ) {\\n\\n\\t\\t\\tif ( geometry && geometry.isInstancedBufferGeometry ) {\\n\\n\\t\\t\\t\\tif ( extensions.get( 'ANGLE_instanced_arrays' ) === null ) {\\n\\n\\t\\t\\t\\t\\tconsole.error( 'THREE.WebGLRenderer.setupVertexAttributes: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' );\\n\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( startIndex === undefined ) startIndex = 0;\\n\\n\\t\\t\\tstate.initAttributes();\\n\\n\\t\\t\\tvar geometryAttributes = geometry.attributes;\\n\\n\\t\\t\\tvar programAttributes = program.getAttributes();\\n\\n\\t\\t\\tvar materialDefaultAttributeValues = material.defaultAttributeValues;\\n\\n\\t\\t\\tfor ( var name in programAttributes ) {\\n\\n\\t\\t\\t\\tvar programAttribute = programAttributes[ name ];\\n\\n\\t\\t\\t\\tif ( programAttribute >= 0 ) {\\n\\n\\t\\t\\t\\t\\tvar geometryAttribute = geometryAttributes[ name ];\\n\\n\\t\\t\\t\\t\\tif ( geometryAttribute !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tvar normalized = geometryAttribute.normalized;\\n\\t\\t\\t\\t\\t\\tvar size = geometryAttribute.itemSize;\\n\\n\\t\\t\\t\\t\\t\\tvar attribute = attributes.get( geometryAttribute );\\n\\n\\t\\t\\t\\t\\t\\t// TODO Attribute may not be available on context restore\\n\\n\\t\\t\\t\\t\\t\\tif ( attribute === undefined ) continue;\\n\\n\\t\\t\\t\\t\\t\\tvar buffer = attribute.buffer;\\n\\t\\t\\t\\t\\t\\tvar type = attribute.type;\\n\\t\\t\\t\\t\\t\\tvar bytesPerElement = attribute.bytesPerElement;\\n\\n\\t\\t\\t\\t\\t\\tif ( geometryAttribute.isInterleavedBufferAttribute ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar data = geometryAttribute.data;\\n\\t\\t\\t\\t\\t\\t\\tvar stride = data.stride;\\n\\t\\t\\t\\t\\t\\t\\tvar offset = geometryAttribute.offset;\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( data && data.isInstancedInterleavedBuffer ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tstate.enableAttributeAndDivisor( programAttribute, data.meshPerAttribute );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( geometry.maxInstancedCount === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgeometry.maxInstancedCount = data.meshPerAttribute * data.count;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tstate.enableAttribute( programAttribute );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t_gl.bindBuffer( _gl.ARRAY_BUFFER, buffer );\\n\\t\\t\\t\\t\\t\\t\\t_gl.vertexAttribPointer( programAttribute, size, type, normalized, stride * bytesPerElement, ( startIndex * stride + offset ) * bytesPerElement );\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( geometryAttribute.isInstancedBufferAttribute ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tstate.enableAttributeAndDivisor( programAttribute, geometryAttribute.meshPerAttribute );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( geometry.maxInstancedCount === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgeometry.maxInstancedCount = geometryAttribute.meshPerAttribute * geometryAttribute.count;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tstate.enableAttribute( programAttribute );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t_gl.bindBuffer( _gl.ARRAY_BUFFER, buffer );\\n\\t\\t\\t\\t\\t\\t\\t_gl.vertexAttribPointer( programAttribute, size, type, normalized, 0, startIndex * size * bytesPerElement );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else if ( materialDefaultAttributeValues !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tvar value = materialDefaultAttributeValues[ name ];\\n\\n\\t\\t\\t\\t\\t\\tif ( value !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tswitch ( value.length ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase 2:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t_gl.vertexAttrib2fv( programAttribute, value );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase 3:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t_gl.vertexAttrib3fv( programAttribute, value );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcase 4:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t_gl.vertexAttrib4fv( programAttribute, value );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tdefault:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t_gl.vertexAttrib1fv( programAttribute, value );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tstate.disableUnusedAttributes();\\n\\n\\t\\t}\\n\\n\\t\\t// Compile\\n\\n\\t\\tthis.compile = function ( scene, camera ) {\\n\\n\\t\\t\\tlightsArray.length = 0;\\n\\t\\t\\tshadowsArray.length = 0;\\n\\n\\t\\t\\tscene.traverse( function ( object ) {\\n\\n\\t\\t\\t\\tif ( object.isLight ) {\\n\\n\\t\\t\\t\\t\\tlightsArray.push( object );\\n\\n\\t\\t\\t\\t\\tif ( object.castShadow ) {\\n\\n\\t\\t\\t\\t\\t\\tshadowsArray.push( object );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} );\\n\\n\\t\\t\\tlights.setup( lightsArray, shadowsArray, camera );\\n\\n\\t\\t\\tscene.traverse( function ( object ) {\\n\\n\\t\\t\\t\\tif ( object.material ) {\\n\\n\\t\\t\\t\\t\\tif ( Array.isArray( object.material ) ) {\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0; i < object.material.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tinitMaterial( object.material[ i ], scene.fog, object );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tinitMaterial( object.material, scene.fog, object );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} );\\n\\n\\t\\t};\\n\\n\\t\\t// Animation Loop\\n\\n\\t\\tvar isAnimating = false;\\n\\t\\tvar onAnimationFrame = null;\\n\\n\\t\\tfunction start() {\\n\\n\\t\\t\\tif ( isAnimating ) return;\\n\\n\\t\\t\\tvar device = vr.getDevice();\\n\\n\\t\\t\\tif ( device && device.isPresenting ) {\\n\\n\\t\\t\\t\\tdevice.requestAnimationFrame( loop );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\twindow.requestAnimationFrame( loop );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tisAnimating = true;\\n\\n\\t\\t}\\n\\n\\t\\tfunction loop( time ) {\\n\\n\\t\\t\\tif ( onAnimationFrame !== null ) onAnimationFrame( time );\\n\\n\\t\\t\\tvar device = vr.getDevice();\\n\\n\\t\\t\\tif ( device && device.isPresenting ) {\\n\\n\\t\\t\\t\\tdevice.requestAnimationFrame( loop );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\twindow.requestAnimationFrame( loop );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tthis.animate = function ( callback ) {\\n\\n\\t\\t\\tonAnimationFrame = callback;\\n\\t\\t\\tstart();\\n\\n\\t\\t};\\n\\n\\t\\t// Rendering\\n\\n\\t\\tthis.render = function ( scene, camera, renderTarget, forceClear ) {\\n\\n\\t\\t\\tif ( ! ( camera && camera.isCamera ) ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( _isContextLost ) return;\\n\\n\\t\\t\\t// reset caching for this frame\\n\\n\\t\\t\\t_currentGeometryProgram = '';\\n\\t\\t\\t_currentMaterialId = - 1;\\n\\t\\t\\t_currentCamera = null;\\n\\n\\t\\t\\t// update scene graph\\n\\n\\t\\t\\tif ( scene.autoUpdate === true ) scene.updateMatrixWorld();\\n\\n\\t\\t\\t// update camera matrices and frustum\\n\\n\\t\\t\\tif ( camera.parent === null ) camera.updateMatrixWorld();\\n\\n\\t\\t\\tif ( vr.enabled ) {\\n\\n\\t\\t\\t\\tcamera = vr.getCamera( camera );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t_projScreenMatrix.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse );\\n\\t\\t\\t_frustum.setFromMatrix( _projScreenMatrix );\\n\\n\\t\\t\\tlightsArray.length = 0;\\n\\t\\t\\tshadowsArray.length = 0;\\n\\n\\t\\t\\tspritesArray.length = 0;\\n\\t\\t\\tflaresArray.length = 0;\\n\\n\\t\\t\\t_localClippingEnabled = this.localClippingEnabled;\\n\\t\\t\\t_clippingEnabled = _clipping.init( this.clippingPlanes, _localClippingEnabled, camera );\\n\\n\\t\\t\\tcurrentRenderList = renderLists.get( scene, camera );\\n\\t\\t\\tcurrentRenderList.init();\\n\\n\\t\\t\\tprojectObject( scene, camera, _this.sortObjects );\\n\\n\\t\\t\\tif ( _this.sortObjects === true ) {\\n\\n\\t\\t\\t\\tcurrentRenderList.sort();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\ttextures.updateVideoTextures();\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tif ( _clippingEnabled ) _clipping.beginShadows();\\n\\n\\t\\t\\tshadowMap.render( shadowsArray, scene, camera );\\n\\n\\t\\t\\tlights.setup( lightsArray, shadowsArray, camera );\\n\\n\\t\\t\\tif ( _clippingEnabled ) _clipping.endShadows();\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\t_infoRender.frame ++;\\n\\t\\t\\t_infoRender.calls = 0;\\n\\t\\t\\t_infoRender.vertices = 0;\\n\\t\\t\\t_infoRender.faces = 0;\\n\\t\\t\\t_infoRender.points = 0;\\n\\n\\t\\t\\tif ( renderTarget === undefined ) {\\n\\n\\t\\t\\t\\trenderTarget = null;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.setRenderTarget( renderTarget );\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tbackground.render( currentRenderList, scene, camera, forceClear );\\n\\n\\t\\t\\t// render scene\\n\\n\\t\\t\\tvar opaqueObjects = currentRenderList.opaque;\\n\\t\\t\\tvar transparentObjects = currentRenderList.transparent;\\n\\n\\t\\t\\tif ( scene.overrideMaterial ) {\\n\\n\\t\\t\\t\\tvar overrideMaterial = scene.overrideMaterial;\\n\\n\\t\\t\\t\\tif ( opaqueObjects.length ) renderObjects( opaqueObjects, scene, camera, overrideMaterial );\\n\\t\\t\\t\\tif ( transparentObjects.length ) renderObjects( transparentObjects, scene, camera, overrideMaterial );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// opaque pass (front-to-back order)\\n\\n\\t\\t\\t\\tif ( opaqueObjects.length ) renderObjects( opaqueObjects, scene, camera );\\n\\n\\t\\t\\t\\t// transparent pass (back-to-front order)\\n\\n\\t\\t\\t\\tif ( transparentObjects.length ) renderObjects( transparentObjects, scene, camera );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// custom renderers\\n\\n\\t\\t\\tspriteRenderer.render( spritesArray, scene, camera );\\n\\t\\t\\tflareRenderer.render( flaresArray, scene, camera, _currentViewport );\\n\\n\\t\\t\\t// Generate mipmap if we're using any kind of mipmap filtering\\n\\n\\t\\t\\tif ( renderTarget ) {\\n\\n\\t\\t\\t\\ttextures.updateRenderTargetMipmap( renderTarget );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Ensure depth buffer writing is enabled so it can be cleared on next render\\n\\n\\t\\t\\tstate.buffers.depth.setTest( true );\\n\\t\\t\\tstate.buffers.depth.setMask( true );\\n\\t\\t\\tstate.buffers.color.setMask( true );\\n\\n\\t\\t\\tstate.setPolygonOffset( false );\\n\\n\\t\\t\\tif ( vr.enabled ) {\\n\\n\\t\\t\\t\\tvr.submitFrame();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// _gl.finish();\\n\\n\\t\\t};\\n\\n\\t\\t/*\\n\\t\\t// TODO Duplicated code (Frustum)\\n\\n\\t\\tvar _sphere = new Sphere();\\n\\n\\t\\tfunction isObjectViewable( object ) {\\n\\n\\t\\t\\tvar geometry = object.geometry;\\n\\n\\t\\t\\tif ( geometry.boundingSphere === null )\\n\\t\\t\\t\\tgeometry.computeBoundingSphere();\\n\\n\\t\\t\\t_sphere.copy( geometry.boundingSphere ).\\n\\t\\t\\tapplyMatrix4( object.matrixWorld );\\n\\n\\t\\t\\treturn isSphereViewable( _sphere );\\n\\n\\t\\t}\\n\\n\\t\\tfunction isSpriteViewable( sprite ) {\\n\\n\\t\\t\\t_sphere.center.set( 0, 0, 0 );\\n\\t\\t\\t_sphere.radius = 0.7071067811865476;\\n\\t\\t\\t_sphere.applyMatrix4( sprite.matrixWorld );\\n\\n\\t\\t\\treturn isSphereViewable( _sphere );\\n\\n\\t\\t}\\n\\n\\t\\tfunction isSphereViewable( sphere ) {\\n\\n\\t\\t\\tif ( ! _frustum.intersectsSphere( sphere ) ) return false;\\n\\n\\t\\t\\tvar numPlanes = _clipping.numPlanes;\\n\\n\\t\\t\\tif ( numPlanes === 0 ) return true;\\n\\n\\t\\t\\tvar planes = _this.clippingPlanes,\\n\\n\\t\\t\\t\\tcenter = sphere.center,\\n\\t\\t\\t\\tnegRad = - sphere.radius,\\n\\t\\t\\t\\ti = 0;\\n\\n\\t\\t\\tdo {\\n\\n\\t\\t\\t\\t// out when deeper than radius in the negative halfspace\\n\\t\\t\\t\\tif ( planes[ i ].distanceToPoint( center ) < negRad ) return false;\\n\\n\\t\\t\\t} while ( ++ i !== numPlanes );\\n\\n\\t\\t\\treturn true;\\n\\n\\t\\t}\\n\\t\\t*/\\n\\n\\t\\tfunction projectObject( object, camera, sortObjects ) {\\n\\n\\t\\t\\tif ( object.visible === false ) return;\\n\\n\\t\\t\\tvar visible = object.layers.test( camera.layers );\\n\\n\\t\\t\\tif ( visible ) {\\n\\n\\t\\t\\t\\tif ( object.isLight ) {\\n\\n\\t\\t\\t\\t\\tlightsArray.push( object );\\n\\n\\t\\t\\t\\t\\tif ( object.castShadow ) {\\n\\n\\t\\t\\t\\t\\t\\tshadowsArray.push( object );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( object.isSprite ) {\\n\\n\\t\\t\\t\\t\\tif ( ! object.frustumCulled || _frustum.intersectsSprite( object ) ) {\\n\\n\\t\\t\\t\\t\\t\\tspritesArray.push( object );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( object.isLensFlare ) {\\n\\n\\t\\t\\t\\t\\tflaresArray.push( object );\\n\\n\\t\\t\\t\\t} else if ( object.isImmediateRenderObject ) {\\n\\n\\t\\t\\t\\t\\tif ( sortObjects ) {\\n\\n\\t\\t\\t\\t\\t\\t_vector3.setFromMatrixPosition( object.matrixWorld )\\n\\t\\t\\t\\t\\t\\t\\t.applyMatrix4( _projScreenMatrix );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tcurrentRenderList.push( object, null, object.material, _vector3.z, null );\\n\\n\\t\\t\\t\\t} else if ( object.isMesh || object.isLine || object.isPoints ) {\\n\\n\\t\\t\\t\\t\\tif ( object.isSkinnedMesh ) {\\n\\n\\t\\t\\t\\t\\t\\tobject.skeleton.update();\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( ! object.frustumCulled || _frustum.intersectsObject( object ) ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( sortObjects ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t_vector3.setFromMatrixPosition( object.matrixWorld )\\n\\t\\t\\t\\t\\t\\t\\t\\t.applyMatrix4( _projScreenMatrix );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tvar geometry = objects.update( object );\\n\\t\\t\\t\\t\\t\\tvar material = object.material;\\n\\n\\t\\t\\t\\t\\t\\tif ( Array.isArray( material ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar groups = geometry.groups;\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var i = 0, l = groups.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tvar group = groups[ i ];\\n\\t\\t\\t\\t\\t\\t\\t\\tvar groupMaterial = material[ group.materialIndex ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( groupMaterial && groupMaterial.visible ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcurrentRenderList.push( object, geometry, groupMaterial, _vector3.z, group );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t} else if ( material.visible ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tcurrentRenderList.push( object, geometry, material, _vector3.z, null );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar children = object.children;\\n\\n\\t\\t\\tfor ( var i = 0, l = children.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tprojectObject( children[ i ], camera, sortObjects );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction renderObjects( renderList, scene, camera, overrideMaterial ) {\\n\\n\\t\\t\\tfor ( var i = 0, l = renderList.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar renderItem = renderList[ i ];\\n\\n\\t\\t\\t\\tvar object = renderItem.object;\\n\\t\\t\\t\\tvar geometry = renderItem.geometry;\\n\\t\\t\\t\\tvar material = overrideMaterial === undefined ? renderItem.material : overrideMaterial;\\n\\t\\t\\t\\tvar group = renderItem.group;\\n\\n\\t\\t\\t\\tif ( camera.isArrayCamera ) {\\n\\n\\t\\t\\t\\t\\t_currentArrayCamera = camera;\\n\\n\\t\\t\\t\\t\\tvar cameras = camera.cameras;\\n\\n\\t\\t\\t\\t\\tfor ( var j = 0, jl = cameras.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar camera2 = cameras[ j ];\\n\\n\\t\\t\\t\\t\\t\\tif ( object.layers.test( camera2.layers ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar bounds = camera2.bounds;\\n\\n\\t\\t\\t\\t\\t\\t\\tvar x = bounds.x * _width;\\n\\t\\t\\t\\t\\t\\t\\tvar y = bounds.y * _height;\\n\\t\\t\\t\\t\\t\\t\\tvar width = bounds.z * _width;\\n\\t\\t\\t\\t\\t\\t\\tvar height = bounds.w * _height;\\n\\n\\t\\t\\t\\t\\t\\t\\tstate.viewport( _currentViewport.set( x, y, width, height ).multiplyScalar( _pixelRatio ) );\\n\\n\\t\\t\\t\\t\\t\\t\\trenderObject( object, scene, camera2, geometry, material, group );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t_currentArrayCamera = null;\\n\\n\\t\\t\\t\\t\\trenderObject( object, scene, camera, geometry, material, group );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction renderObject( object, scene, camera, geometry, material, group ) {\\n\\n\\t\\t\\tobject.onBeforeRender( _this, scene, camera, geometry, material, group );\\n\\n\\t\\t\\tobject.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, object.matrixWorld );\\n\\t\\t\\tobject.normalMatrix.getNormalMatrix( object.modelViewMatrix );\\n\\n\\t\\t\\tif ( object.isImmediateRenderObject ) {\\n\\n\\t\\t\\t\\tvar frontFaceCW = ( object.isMesh && object.matrixWorld.determinant() < 0 );\\n\\n\\t\\t\\t\\tstate.setMaterial( material, frontFaceCW );\\n\\n\\t\\t\\t\\tvar program = setProgram( camera, scene.fog, material, object );\\n\\n\\t\\t\\t\\t_currentGeometryProgram = '';\\n\\n\\t\\t\\t\\trenderObjectImmediate( object, program, material );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t_this.renderBufferDirect( camera, scene.fog, geometry, material, object, group );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tobject.onAfterRender( _this, scene, camera, geometry, material, group );\\n\\n\\t\\t}\\n\\n\\t\\tfunction initMaterial( material, fog, object ) {\\n\\n\\t\\t\\tvar materialProperties = properties.get( material );\\n\\n\\t\\t\\tvar parameters = programCache.getParameters(\\n\\t\\t\\t\\tmaterial, lights.state, shadowsArray, fog, _clipping.numPlanes, _clipping.numIntersection, object );\\n\\n\\t\\t\\tvar code = programCache.getProgramCode( material, parameters );\\n\\n\\t\\t\\tvar program = materialProperties.program;\\n\\t\\t\\tvar programChange = true;\\n\\n\\t\\t\\tif ( program === undefined ) {\\n\\n\\t\\t\\t\\t// new material\\n\\t\\t\\t\\tmaterial.addEventListener( 'dispose', onMaterialDispose );\\n\\n\\t\\t\\t} else if ( program.code !== code ) {\\n\\n\\t\\t\\t\\t// changed glsl or parameters\\n\\t\\t\\t\\treleaseMaterialProgramReference( material );\\n\\n\\t\\t\\t} else if ( parameters.shaderID !== undefined ) {\\n\\n\\t\\t\\t\\t// same glsl and uniform list\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// only rebuild uniform list\\n\\t\\t\\t\\tprogramChange = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( programChange ) {\\n\\n\\t\\t\\t\\tif ( parameters.shaderID ) {\\n\\n\\t\\t\\t\\t\\tvar shader = ShaderLib[ parameters.shaderID ];\\n\\n\\t\\t\\t\\t\\tmaterialProperties.shader = {\\n\\t\\t\\t\\t\\t\\tname: material.type,\\n\\t\\t\\t\\t\\t\\tuniforms: UniformsUtils.clone( shader.uniforms ),\\n\\t\\t\\t\\t\\t\\tvertexShader: shader.vertexShader,\\n\\t\\t\\t\\t\\t\\tfragmentShader: shader.fragmentShader\\n\\t\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tmaterialProperties.shader = {\\n\\t\\t\\t\\t\\t\\tname: material.type,\\n\\t\\t\\t\\t\\t\\tuniforms: material.uniforms,\\n\\t\\t\\t\\t\\t\\tvertexShader: material.vertexShader,\\n\\t\\t\\t\\t\\t\\tfragmentShader: material.fragmentShader\\n\\t\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tmaterial.onBeforeCompile( materialProperties.shader );\\n\\n\\t\\t\\t\\tprogram = programCache.acquireProgram( material, materialProperties.shader, parameters, code );\\n\\n\\t\\t\\t\\tmaterialProperties.program = program;\\n\\t\\t\\t\\tmaterial.program = program;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar programAttributes = program.getAttributes();\\n\\n\\t\\t\\tif ( material.morphTargets ) {\\n\\n\\t\\t\\t\\tmaterial.numSupportedMorphTargets = 0;\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < _this.maxMorphTargets; i ++ ) {\\n\\n\\t\\t\\t\\t\\tif ( programAttributes[ 'morphTarget' + i ] >= 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tmaterial.numSupportedMorphTargets ++;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.morphNormals ) {\\n\\n\\t\\t\\t\\tmaterial.numSupportedMorphNormals = 0;\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < _this.maxMorphNormals; i ++ ) {\\n\\n\\t\\t\\t\\t\\tif ( programAttributes[ 'morphNormal' + i ] >= 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tmaterial.numSupportedMorphNormals ++;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar uniforms = materialProperties.shader.uniforms;\\n\\n\\t\\t\\tif ( ! material.isShaderMaterial &&\\n\\t\\t\\t\\t! material.isRawShaderMaterial ||\\n\\t\\t\\t\\tmaterial.clipping === true ) {\\n\\n\\t\\t\\t\\tmaterialProperties.numClippingPlanes = _clipping.numPlanes;\\n\\t\\t\\t\\tmaterialProperties.numIntersection = _clipping.numIntersection;\\n\\t\\t\\t\\tuniforms.clippingPlanes = _clipping.uniform;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tmaterialProperties.fog = fog;\\n\\n\\t\\t\\t// store the light setup it was created for\\n\\n\\t\\t\\tmaterialProperties.lightsHash = lights.state.hash;\\n\\n\\t\\t\\tif ( material.lights ) {\\n\\n\\t\\t\\t\\t// wire up the material to this renderer's lighting state\\n\\n\\t\\t\\t\\tuniforms.ambientLightColor.value = lights.state.ambient;\\n\\t\\t\\t\\tuniforms.directionalLights.value = lights.state.directional;\\n\\t\\t\\t\\tuniforms.spotLights.value = lights.state.spot;\\n\\t\\t\\t\\tuniforms.rectAreaLights.value = lights.state.rectArea;\\n\\t\\t\\t\\tuniforms.pointLights.value = lights.state.point;\\n\\t\\t\\t\\tuniforms.hemisphereLights.value = lights.state.hemi;\\n\\n\\t\\t\\t\\tuniforms.directionalShadowMap.value = lights.state.directionalShadowMap;\\n\\t\\t\\t\\tuniforms.directionalShadowMatrix.value = lights.state.directionalShadowMatrix;\\n\\t\\t\\t\\tuniforms.spotShadowMap.value = lights.state.spotShadowMap;\\n\\t\\t\\t\\tuniforms.spotShadowMatrix.value = lights.state.spotShadowMatrix;\\n\\t\\t\\t\\tuniforms.pointShadowMap.value = lights.state.pointShadowMap;\\n\\t\\t\\t\\tuniforms.pointShadowMatrix.value = lights.state.pointShadowMatrix;\\n\\t\\t\\t\\t// TODO (abelnation): add area lights shadow info to uniforms\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar progUniforms = materialProperties.program.getUniforms(),\\n\\t\\t\\t\\tuniformsList =\\n\\t\\t\\t\\t\\tWebGLUniforms.seqWithValue( progUniforms.seq, uniforms );\\n\\n\\t\\t\\tmaterialProperties.uniformsList = uniformsList;\\n\\n\\t\\t}\\n\\n\\t\\tfunction setProgram( camera, fog, material, object ) {\\n\\n\\t\\t\\t_usedTextureUnits = 0;\\n\\n\\t\\t\\tvar materialProperties = properties.get( material );\\n\\n\\t\\t\\tif ( _clippingEnabled ) {\\n\\n\\t\\t\\t\\tif ( _localClippingEnabled || camera !== _currentCamera ) {\\n\\n\\t\\t\\t\\t\\tvar useCache =\\n\\t\\t\\t\\t\\t\\tcamera === _currentCamera &&\\n\\t\\t\\t\\t\\t\\tmaterial.id === _currentMaterialId;\\n\\n\\t\\t\\t\\t\\t// we might want to call this function with some ClippingGroup\\n\\t\\t\\t\\t\\t// object instead of the material, once it becomes feasible\\n\\t\\t\\t\\t\\t// (#8465, #8379)\\n\\t\\t\\t\\t\\t_clipping.setState(\\n\\t\\t\\t\\t\\t\\tmaterial.clippingPlanes, material.clipIntersection, material.clipShadows,\\n\\t\\t\\t\\t\\t\\tcamera, materialProperties, useCache );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.needsUpdate === false ) {\\n\\n\\t\\t\\t\\tif ( materialProperties.program === undefined ) {\\n\\n\\t\\t\\t\\t\\tmaterial.needsUpdate = true;\\n\\n\\t\\t\\t\\t} else if ( material.fog && materialProperties.fog !== fog ) {\\n\\n\\t\\t\\t\\t\\tmaterial.needsUpdate = true;\\n\\n\\t\\t\\t\\t} else if ( material.lights && materialProperties.lightsHash !== lights.state.hash ) {\\n\\n\\t\\t\\t\\t\\tmaterial.needsUpdate = true;\\n\\n\\t\\t\\t\\t} else if ( materialProperties.numClippingPlanes !== undefined &&\\n\\t\\t\\t\\t\\t( materialProperties.numClippingPlanes !== _clipping.numPlanes ||\\n\\t\\t\\t\\t\\tmaterialProperties.numIntersection !== _clipping.numIntersection ) ) {\\n\\n\\t\\t\\t\\t\\tmaterial.needsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.needsUpdate ) {\\n\\n\\t\\t\\t\\tinitMaterial( material, fog, object );\\n\\t\\t\\t\\tmaterial.needsUpdate = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar refreshProgram = false;\\n\\t\\t\\tvar refreshMaterial = false;\\n\\t\\t\\tvar refreshLights = false;\\n\\n\\t\\t\\tvar program = materialProperties.program,\\n\\t\\t\\t\\tp_uniforms = program.getUniforms(),\\n\\t\\t\\t\\tm_uniforms = materialProperties.shader.uniforms;\\n\\n\\t\\t\\tif ( state.useProgram( program.program ) ) {\\n\\n\\t\\t\\t\\trefreshProgram = true;\\n\\t\\t\\t\\trefreshMaterial = true;\\n\\t\\t\\t\\trefreshLights = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.id !== _currentMaterialId ) {\\n\\n\\t\\t\\t\\t_currentMaterialId = material.id;\\n\\n\\t\\t\\t\\trefreshMaterial = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( refreshProgram || camera !== _currentCamera ) {\\n\\n\\t\\t\\t\\tp_uniforms.setValue( _gl, 'projectionMatrix', camera.projectionMatrix );\\n\\n\\t\\t\\t\\tif ( capabilities.logarithmicDepthBuffer ) {\\n\\n\\t\\t\\t\\t\\tp_uniforms.setValue( _gl, 'logDepthBufFC',\\n\\t\\t\\t\\t\\t\\t2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// Avoid unneeded uniform updates per ArrayCamera's sub-camera\\n\\n\\t\\t\\t\\tif ( _currentCamera !== ( _currentArrayCamera || camera ) ) {\\n\\n\\t\\t\\t\\t\\t_currentCamera = ( _currentArrayCamera || camera );\\n\\n\\t\\t\\t\\t\\t// lighting uniforms depend on the camera so enforce an update\\n\\t\\t\\t\\t\\t// now, in case this material supports lights - or later, when\\n\\t\\t\\t\\t\\t// the next material that does gets activated:\\n\\n\\t\\t\\t\\t\\trefreshMaterial = true;\\t\\t// set to true on material change\\n\\t\\t\\t\\t\\trefreshLights = true;\\t\\t// remains set until update done\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// load material specific uniforms\\n\\t\\t\\t\\t// (shader material also gets them for the sake of genericity)\\n\\n\\t\\t\\t\\tif ( material.isShaderMaterial ||\\n\\t\\t\\t\\t\\tmaterial.isMeshPhongMaterial ||\\n\\t\\t\\t\\t\\tmaterial.isMeshStandardMaterial ||\\n\\t\\t\\t\\t\\tmaterial.envMap ) {\\n\\n\\t\\t\\t\\t\\tvar uCamPos = p_uniforms.map.cameraPosition;\\n\\n\\t\\t\\t\\t\\tif ( uCamPos !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tuCamPos.setValue( _gl,\\n\\t\\t\\t\\t\\t\\t\\t_vector3.setFromMatrixPosition( camera.matrixWorld ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( material.isMeshPhongMaterial ||\\n\\t\\t\\t\\t\\tmaterial.isMeshLambertMaterial ||\\n\\t\\t\\t\\t\\tmaterial.isMeshBasicMaterial ||\\n\\t\\t\\t\\t\\tmaterial.isMeshStandardMaterial ||\\n\\t\\t\\t\\t\\tmaterial.isShaderMaterial ||\\n\\t\\t\\t\\t\\tmaterial.skinning ) {\\n\\n\\t\\t\\t\\t\\tp_uniforms.setValue( _gl, 'viewMatrix', camera.matrixWorldInverse );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// skinning uniforms must be set even if material didn't change\\n\\t\\t\\t// auto-setting of texture unit for bone texture must go before other textures\\n\\t\\t\\t// not sure why, but otherwise weird things happen\\n\\n\\t\\t\\tif ( material.skinning ) {\\n\\n\\t\\t\\t\\tp_uniforms.setOptional( _gl, object, 'bindMatrix' );\\n\\t\\t\\t\\tp_uniforms.setOptional( _gl, object, 'bindMatrixInverse' );\\n\\n\\t\\t\\t\\tvar skeleton = object.skeleton;\\n\\n\\t\\t\\t\\tif ( skeleton ) {\\n\\n\\t\\t\\t\\t\\tvar bones = skeleton.bones;\\n\\n\\t\\t\\t\\t\\tif ( capabilities.floatVertexTextures ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( skeleton.boneTexture === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// layout (1 matrix = 4 pixels)\\n\\t\\t\\t\\t\\t\\t\\t//      RGBA RGBA RGBA RGBA (=> column1, column2, column3, column4)\\n\\t\\t\\t\\t\\t\\t\\t//  with  8x8  pixel texture max   16 bones * 4 pixels =  (8 * 8)\\n\\t\\t\\t\\t\\t\\t\\t//       16x16 pixel texture max   64 bones * 4 pixels = (16 * 16)\\n\\t\\t\\t\\t\\t\\t\\t//       32x32 pixel texture max  256 bones * 4 pixels = (32 * 32)\\n\\t\\t\\t\\t\\t\\t\\t//       64x64 pixel texture max 1024 bones * 4 pixels = (64 * 64)\\n\\n\\n\\t\\t\\t\\t\\t\\t\\tvar size = Math.sqrt( bones.length * 4 ); // 4 pixels needed for 1 matrix\\n\\t\\t\\t\\t\\t\\t\\tsize = _Math.ceilPowerOfTwo( size );\\n\\t\\t\\t\\t\\t\\t\\tsize = Math.max( size, 4 );\\n\\n\\t\\t\\t\\t\\t\\t\\tvar boneMatrices = new Float32Array( size * size * 4 ); // 4 floats per RGBA pixel\\n\\t\\t\\t\\t\\t\\t\\tboneMatrices.set( skeleton.boneMatrices ); // copy current values\\n\\n\\t\\t\\t\\t\\t\\t\\tvar boneTexture = new DataTexture( boneMatrices, size, size, RGBAFormat, FloatType );\\n\\n\\t\\t\\t\\t\\t\\t\\tskeleton.boneMatrices = boneMatrices;\\n\\t\\t\\t\\t\\t\\t\\tskeleton.boneTexture = boneTexture;\\n\\t\\t\\t\\t\\t\\t\\tskeleton.boneTextureSize = size;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tp_uniforms.setValue( _gl, 'boneTexture', skeleton.boneTexture );\\n\\t\\t\\t\\t\\t\\tp_uniforms.setValue( _gl, 'boneTextureSize', skeleton.boneTextureSize );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tp_uniforms.setOptional( _gl, skeleton, 'boneMatrices' );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( refreshMaterial ) {\\n\\n\\t\\t\\t\\tp_uniforms.setValue( _gl, 'toneMappingExposure', _this.toneMappingExposure );\\n\\t\\t\\t\\tp_uniforms.setValue( _gl, 'toneMappingWhitePoint', _this.toneMappingWhitePoint );\\n\\n\\t\\t\\t\\tif ( material.lights ) {\\n\\n\\t\\t\\t\\t\\t// the current material requires lighting info\\n\\n\\t\\t\\t\\t\\t// note: all lighting uniforms are always set correctly\\n\\t\\t\\t\\t\\t// they simply reference the renderer's state for their\\n\\t\\t\\t\\t\\t// values\\n\\t\\t\\t\\t\\t//\\n\\t\\t\\t\\t\\t// use the current material's .needsUpdate flags to set\\n\\t\\t\\t\\t\\t// the GL state when required\\n\\n\\t\\t\\t\\t\\tmarkUniformsLightsNeedsUpdate( m_uniforms, refreshLights );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// refresh uniforms common to several materials\\n\\n\\t\\t\\t\\tif ( fog && material.fog ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsFog( m_uniforms, fog );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( material.isMeshBasicMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsCommon( m_uniforms, material );\\n\\n\\t\\t\\t\\t} else if ( material.isMeshLambertMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsCommon( m_uniforms, material );\\n\\t\\t\\t\\t\\trefreshUniformsLambert( m_uniforms, material );\\n\\n\\t\\t\\t\\t} else if ( material.isMeshPhongMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsCommon( m_uniforms, material );\\n\\n\\t\\t\\t\\t\\tif ( material.isMeshToonMaterial ) {\\n\\n\\t\\t\\t\\t\\t\\trefreshUniformsToon( m_uniforms, material );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\trefreshUniformsPhong( m_uniforms, material );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( material.isMeshStandardMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsCommon( m_uniforms, material );\\n\\n\\t\\t\\t\\t\\tif ( material.isMeshPhysicalMaterial ) {\\n\\n\\t\\t\\t\\t\\t\\trefreshUniformsPhysical( m_uniforms, material );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\trefreshUniformsStandard( m_uniforms, material );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( material.isMeshDepthMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsCommon( m_uniforms, material );\\n\\t\\t\\t\\t\\trefreshUniformsDepth( m_uniforms, material );\\n\\n\\t\\t\\t\\t} else if ( material.isMeshDistanceMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsCommon( m_uniforms, material );\\n\\t\\t\\t\\t\\trefreshUniformsDistance( m_uniforms, material );\\n\\n\\t\\t\\t\\t} else if ( material.isMeshNormalMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsCommon( m_uniforms, material );\\n\\t\\t\\t\\t\\trefreshUniformsNormal( m_uniforms, material );\\n\\n\\t\\t\\t\\t} else if ( material.isLineBasicMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsLine( m_uniforms, material );\\n\\n\\t\\t\\t\\t\\tif ( material.isLineDashedMaterial ) {\\n\\n\\t\\t\\t\\t\\t\\trefreshUniformsDash( m_uniforms, material );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( material.isPointsMaterial ) {\\n\\n\\t\\t\\t\\t\\trefreshUniformsPoints( m_uniforms, material );\\n\\n\\t\\t\\t\\t} else if ( material.isShadowMaterial ) {\\n\\n\\t\\t\\t\\t\\tm_uniforms.color.value = material.color;\\n\\t\\t\\t\\t\\tm_uniforms.opacity.value = material.opacity;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// RectAreaLight Texture\\n\\t\\t\\t\\t// TODO (mrdoob): Find a nicer implementation\\n\\n\\t\\t\\t\\tif ( m_uniforms.ltcMat !== undefined ) m_uniforms.ltcMat.value = UniformsLib.LTC_MAT_TEXTURE;\\n\\t\\t\\t\\tif ( m_uniforms.ltcMag !== undefined ) m_uniforms.ltcMag.value = UniformsLib.LTC_MAG_TEXTURE;\\n\\n\\t\\t\\t\\tWebGLUniforms.upload(\\n\\t\\t\\t\\t\\t_gl, materialProperties.uniformsList, m_uniforms, _this );\\n\\n\\t\\t\\t}\\n\\n\\n\\t\\t\\t// common matrices\\n\\n\\t\\t\\tp_uniforms.setValue( _gl, 'modelViewMatrix', object.modelViewMatrix );\\n\\t\\t\\tp_uniforms.setValue( _gl, 'normalMatrix', object.normalMatrix );\\n\\t\\t\\tp_uniforms.setValue( _gl, 'modelMatrix', object.matrixWorld );\\n\\n\\t\\t\\treturn program;\\n\\n\\t\\t}\\n\\n\\t\\t// Uniforms (refresh uniforms objects)\\n\\n\\t\\tfunction refreshUniformsCommon( uniforms, material ) {\\n\\n\\t\\t\\tuniforms.opacity.value = material.opacity;\\n\\n\\t\\t\\tif ( material.color ) {\\n\\n\\t\\t\\t\\tuniforms.diffuse.value = material.color;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.emissive ) {\\n\\n\\t\\t\\t\\tuniforms.emissive.value.copy( material.emissive ).multiplyScalar( material.emissiveIntensity );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.map ) {\\n\\n\\t\\t\\t\\tuniforms.map.value = material.map;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.alphaMap ) {\\n\\n\\t\\t\\t\\tuniforms.alphaMap.value = material.alphaMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.specularMap ) {\\n\\n\\t\\t\\t\\tuniforms.specularMap.value = material.specularMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.envMap ) {\\n\\n\\t\\t\\t\\tuniforms.envMap.value = material.envMap;\\n\\n\\t\\t\\t\\t// don't flip CubeTexture envMaps, flip everything else:\\n\\t\\t\\t\\t//  WebGLRenderTargetCube will be flipped for backwards compatibility\\n\\t\\t\\t\\t//  WebGLRenderTargetCube.texture will be flipped because it's a Texture and NOT a CubeTexture\\n\\t\\t\\t\\t// this check must be handled differently, or removed entirely, if WebGLRenderTargetCube uses a CubeTexture in the future\\n\\t\\t\\t\\tuniforms.flipEnvMap.value = ( ! ( material.envMap && material.envMap.isCubeTexture ) ) ? 1 : - 1;\\n\\n\\t\\t\\t\\tuniforms.reflectivity.value = material.reflectivity;\\n\\t\\t\\t\\tuniforms.refractionRatio.value = material.refractionRatio;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.lightMap ) {\\n\\n\\t\\t\\t\\tuniforms.lightMap.value = material.lightMap;\\n\\t\\t\\t\\tuniforms.lightMapIntensity.value = material.lightMapIntensity;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.aoMap ) {\\n\\n\\t\\t\\t\\tuniforms.aoMap.value = material.aoMap;\\n\\t\\t\\t\\tuniforms.aoMapIntensity.value = material.aoMapIntensity;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// uv repeat and offset setting priorities\\n\\t\\t\\t// 1. color map\\n\\t\\t\\t// 2. specular map\\n\\t\\t\\t// 3. normal map\\n\\t\\t\\t// 4. bump map\\n\\t\\t\\t// 5. alpha map\\n\\t\\t\\t// 6. emissive map\\n\\n\\t\\t\\tvar uvScaleMap;\\n\\n\\t\\t\\tif ( material.map ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.map;\\n\\n\\t\\t\\t} else if ( material.specularMap ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.specularMap;\\n\\n\\t\\t\\t} else if ( material.displacementMap ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.displacementMap;\\n\\n\\t\\t\\t} else if ( material.normalMap ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.normalMap;\\n\\n\\t\\t\\t} else if ( material.bumpMap ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.bumpMap;\\n\\n\\t\\t\\t} else if ( material.roughnessMap ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.roughnessMap;\\n\\n\\t\\t\\t} else if ( material.metalnessMap ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.metalnessMap;\\n\\n\\t\\t\\t} else if ( material.alphaMap ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.alphaMap;\\n\\n\\t\\t\\t} else if ( material.emissiveMap ) {\\n\\n\\t\\t\\t\\tuvScaleMap = material.emissiveMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( uvScaleMap !== undefined ) {\\n\\n\\t\\t\\t\\t// backwards compatibility\\n\\t\\t\\t\\tif ( uvScaleMap.isWebGLRenderTarget ) {\\n\\n\\t\\t\\t\\t\\tuvScaleMap = uvScaleMap.texture;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( uvScaleMap.matrixAutoUpdate === true ) {\\n\\n\\t\\t\\t\\t\\tvar offset = uvScaleMap.offset;\\n\\t\\t\\t\\t\\tvar repeat = uvScaleMap.repeat;\\n\\t\\t\\t\\t\\tvar rotation = uvScaleMap.rotation;\\n\\t\\t\\t\\t\\tvar center = uvScaleMap.center;\\n\\n\\t\\t\\t\\t\\tuvScaleMap.matrix.setUvTransform( offset.x, offset.y, repeat.x, repeat.y, rotation, center.x, center.y );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tuniforms.uvTransform.value.copy( uvScaleMap.matrix );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsLine( uniforms, material ) {\\n\\n\\t\\t\\tuniforms.diffuse.value = material.color;\\n\\t\\t\\tuniforms.opacity.value = material.opacity;\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsDash( uniforms, material ) {\\n\\n\\t\\t\\tuniforms.dashSize.value = material.dashSize;\\n\\t\\t\\tuniforms.totalSize.value = material.dashSize + material.gapSize;\\n\\t\\t\\tuniforms.scale.value = material.scale;\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsPoints( uniforms, material ) {\\n\\n\\t\\t\\tuniforms.diffuse.value = material.color;\\n\\t\\t\\tuniforms.opacity.value = material.opacity;\\n\\t\\t\\tuniforms.size.value = material.size * _pixelRatio;\\n\\t\\t\\tuniforms.scale.value = _height * 0.5;\\n\\n\\t\\t\\tuniforms.map.value = material.map;\\n\\n\\t\\t\\tif ( material.map !== null ) {\\n\\n\\t\\t\\t\\tif ( material.map.matrixAutoUpdate === true ) {\\n\\n\\t\\t\\t\\t\\tvar offset = material.map.offset;\\n\\t\\t\\t\\t\\tvar repeat = material.map.repeat;\\n\\t\\t\\t\\t\\tvar rotation = material.map.rotation;\\n\\t\\t\\t\\t\\tvar center = material.map.center;\\n\\n\\t\\t\\t\\t\\tmaterial.map.matrix.setUvTransform( offset.x, offset.y, repeat.x, repeat.y, rotation, center.x, center.y );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tuniforms.uvTransform.value.copy( material.map.matrix );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsFog( uniforms, fog ) {\\n\\n\\t\\t\\tuniforms.fogColor.value = fog.color;\\n\\n\\t\\t\\tif ( fog.isFog ) {\\n\\n\\t\\t\\t\\tuniforms.fogNear.value = fog.near;\\n\\t\\t\\t\\tuniforms.fogFar.value = fog.far;\\n\\n\\t\\t\\t} else if ( fog.isFogExp2 ) {\\n\\n\\t\\t\\t\\tuniforms.fogDensity.value = fog.density;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsLambert( uniforms, material ) {\\n\\n\\t\\t\\tif ( material.emissiveMap ) {\\n\\n\\t\\t\\t\\tuniforms.emissiveMap.value = material.emissiveMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsPhong( uniforms, material ) {\\n\\n\\t\\t\\tuniforms.specular.value = material.specular;\\n\\t\\t\\tuniforms.shininess.value = Math.max( material.shininess, 1e-4 ); // to prevent pow( 0.0, 0.0 )\\n\\n\\t\\t\\tif ( material.emissiveMap ) {\\n\\n\\t\\t\\t\\tuniforms.emissiveMap.value = material.emissiveMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.bumpMap ) {\\n\\n\\t\\t\\t\\tuniforms.bumpMap.value = material.bumpMap;\\n\\t\\t\\t\\tuniforms.bumpScale.value = material.bumpScale;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.normalMap ) {\\n\\n\\t\\t\\t\\tuniforms.normalMap.value = material.normalMap;\\n\\t\\t\\t\\tuniforms.normalScale.value.copy( material.normalScale );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.displacementMap ) {\\n\\n\\t\\t\\t\\tuniforms.displacementMap.value = material.displacementMap;\\n\\t\\t\\t\\tuniforms.displacementScale.value = material.displacementScale;\\n\\t\\t\\t\\tuniforms.displacementBias.value = material.displacementBias;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsToon( uniforms, material ) {\\n\\n\\t\\t\\trefreshUniformsPhong( uniforms, material );\\n\\n\\t\\t\\tif ( material.gradientMap ) {\\n\\n\\t\\t\\t\\tuniforms.gradientMap.value = material.gradientMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsStandard( uniforms, material ) {\\n\\n\\t\\t\\tuniforms.roughness.value = material.roughness;\\n\\t\\t\\tuniforms.metalness.value = material.metalness;\\n\\n\\t\\t\\tif ( material.roughnessMap ) {\\n\\n\\t\\t\\t\\tuniforms.roughnessMap.value = material.roughnessMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.metalnessMap ) {\\n\\n\\t\\t\\t\\tuniforms.metalnessMap.value = material.metalnessMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.emissiveMap ) {\\n\\n\\t\\t\\t\\tuniforms.emissiveMap.value = material.emissiveMap;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.bumpMap ) {\\n\\n\\t\\t\\t\\tuniforms.bumpMap.value = material.bumpMap;\\n\\t\\t\\t\\tuniforms.bumpScale.value = material.bumpScale;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.normalMap ) {\\n\\n\\t\\t\\t\\tuniforms.normalMap.value = material.normalMap;\\n\\t\\t\\t\\tuniforms.normalScale.value.copy( material.normalScale );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.displacementMap ) {\\n\\n\\t\\t\\t\\tuniforms.displacementMap.value = material.displacementMap;\\n\\t\\t\\t\\tuniforms.displacementScale.value = material.displacementScale;\\n\\t\\t\\t\\tuniforms.displacementBias.value = material.displacementBias;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.envMap ) {\\n\\n\\t\\t\\t\\t//uniforms.envMap.value = material.envMap; // part of uniforms common\\n\\t\\t\\t\\tuniforms.envMapIntensity.value = material.envMapIntensity;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsPhysical( uniforms, material ) {\\n\\n\\t\\t\\tuniforms.clearCoat.value = material.clearCoat;\\n\\t\\t\\tuniforms.clearCoatRoughness.value = material.clearCoatRoughness;\\n\\n\\t\\t\\trefreshUniformsStandard( uniforms, material );\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsDepth( uniforms, material ) {\\n\\n\\t\\t\\tif ( material.displacementMap ) {\\n\\n\\t\\t\\t\\tuniforms.displacementMap.value = material.displacementMap;\\n\\t\\t\\t\\tuniforms.displacementScale.value = material.displacementScale;\\n\\t\\t\\t\\tuniforms.displacementBias.value = material.displacementBias;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsDistance( uniforms, material ) {\\n\\n\\t\\t\\tif ( material.displacementMap ) {\\n\\n\\t\\t\\t\\tuniforms.displacementMap.value = material.displacementMap;\\n\\t\\t\\t\\tuniforms.displacementScale.value = material.displacementScale;\\n\\t\\t\\t\\tuniforms.displacementBias.value = material.displacementBias;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tuniforms.referencePosition.value.copy( material.referencePosition );\\n\\t\\t\\tuniforms.nearDistance.value = material.nearDistance;\\n\\t\\t\\tuniforms.farDistance.value = material.farDistance;\\n\\n\\t\\t}\\n\\n\\t\\tfunction refreshUniformsNormal( uniforms, material ) {\\n\\n\\t\\t\\tif ( material.bumpMap ) {\\n\\n\\t\\t\\t\\tuniforms.bumpMap.value = material.bumpMap;\\n\\t\\t\\t\\tuniforms.bumpScale.value = material.bumpScale;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.normalMap ) {\\n\\n\\t\\t\\t\\tuniforms.normalMap.value = material.normalMap;\\n\\t\\t\\t\\tuniforms.normalScale.value.copy( material.normalScale );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( material.displacementMap ) {\\n\\n\\t\\t\\t\\tuniforms.displacementMap.value = material.displacementMap;\\n\\t\\t\\t\\tuniforms.displacementScale.value = material.displacementScale;\\n\\t\\t\\t\\tuniforms.displacementBias.value = material.displacementBias;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// If uniforms are marked as clean, they don't need to be loaded to the GPU.\\n\\n\\t\\tfunction markUniformsLightsNeedsUpdate( uniforms, value ) {\\n\\n\\t\\t\\tuniforms.ambientLightColor.needsUpdate = value;\\n\\n\\t\\t\\tuniforms.directionalLights.needsUpdate = value;\\n\\t\\t\\tuniforms.pointLights.needsUpdate = value;\\n\\t\\t\\tuniforms.spotLights.needsUpdate = value;\\n\\t\\t\\tuniforms.rectAreaLights.needsUpdate = value;\\n\\t\\t\\tuniforms.hemisphereLights.needsUpdate = value;\\n\\n\\t\\t}\\n\\n\\t\\t// GL state setting\\n\\n\\t\\tthis.setFaceCulling = function ( cullFace, frontFaceDirection ) {\\n\\n\\t\\t\\tstate.setCullFace( cullFace );\\n\\t\\t\\tstate.setFlipSided( frontFaceDirection === FrontFaceDirectionCW );\\n\\n\\t\\t};\\n\\n\\t\\t// Textures\\n\\n\\t\\tfunction allocTextureUnit() {\\n\\n\\t\\t\\tvar textureUnit = _usedTextureUnits;\\n\\n\\t\\t\\tif ( textureUnit >= capabilities.maxTextures ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: Trying to use ' + textureUnit + ' texture units while this GPU supports only ' + capabilities.maxTextures );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t_usedTextureUnits += 1;\\n\\n\\t\\t\\treturn textureUnit;\\n\\n\\t\\t}\\n\\n\\t\\tthis.allocTextureUnit = allocTextureUnit;\\n\\n\\t\\t// this.setTexture2D = setTexture2D;\\n\\t\\tthis.setTexture2D = ( function () {\\n\\n\\t\\t\\tvar warned = false;\\n\\n\\t\\t\\t// backwards compatibility: peel texture.texture\\n\\t\\t\\treturn function setTexture2D( texture, slot ) {\\n\\n\\t\\t\\t\\tif ( texture && texture.isWebGLRenderTarget ) {\\n\\n\\t\\t\\t\\t\\tif ( ! warned ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( \\\"THREE.WebGLRenderer.setTexture2D: don't use render targets as textures. Use their .texture property instead.\\\" );\\n\\t\\t\\t\\t\\t\\twarned = true;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\ttexture = texture.texture;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\ttextures.setTexture2D( texture, slot );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}() );\\n\\n\\t\\tthis.setTexture = ( function () {\\n\\n\\t\\t\\tvar warned = false;\\n\\n\\t\\t\\treturn function setTexture( texture, slot ) {\\n\\n\\t\\t\\t\\tif ( ! warned ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( \\\"THREE.WebGLRenderer: .setTexture is deprecated, use setTexture2D instead.\\\" );\\n\\t\\t\\t\\t\\twarned = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\ttextures.setTexture2D( texture, slot );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}() );\\n\\n\\t\\tthis.setTextureCube = ( function () {\\n\\n\\t\\t\\tvar warned = false;\\n\\n\\t\\t\\treturn function setTextureCube( texture, slot ) {\\n\\n\\t\\t\\t\\t// backwards compatibility: peel texture.texture\\n\\t\\t\\t\\tif ( texture && texture.isWebGLRenderTargetCube ) {\\n\\n\\t\\t\\t\\t\\tif ( ! warned ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( \\\"THREE.WebGLRenderer.setTextureCube: don't use cube render targets as textures. Use their .texture property instead.\\\" );\\n\\t\\t\\t\\t\\t\\twarned = true;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\ttexture = texture.texture;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// currently relying on the fact that WebGLRenderTargetCube.texture is a Texture and NOT a CubeTexture\\n\\t\\t\\t\\t// TODO: unify these code paths\\n\\t\\t\\t\\tif ( ( texture && texture.isCubeTexture ) ||\\n\\t\\t\\t\\t\\t( Array.isArray( texture.image ) && texture.image.length === 6 ) ) {\\n\\n\\t\\t\\t\\t\\t// CompressedTexture can have Array in image :/\\n\\n\\t\\t\\t\\t\\t// this function alone should take care of cube textures\\n\\t\\t\\t\\t\\ttextures.setTextureCube( texture, slot );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// assumed: texture property of THREE.WebGLRenderTargetCube\\n\\n\\t\\t\\t\\t\\ttextures.setTextureCubeDynamic( texture, slot );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}() );\\n\\n\\t\\tthis.getRenderTarget = function () {\\n\\n\\t\\t\\treturn _currentRenderTarget;\\n\\n\\t\\t};\\n\\n\\t\\tthis.setRenderTarget = function ( renderTarget ) {\\n\\n\\t\\t\\t_currentRenderTarget = renderTarget;\\n\\n\\t\\t\\tif ( renderTarget && properties.get( renderTarget ).__webglFramebuffer === undefined ) {\\n\\n\\t\\t\\t\\ttextures.setupRenderTarget( renderTarget );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar framebuffer = null;\\n\\t\\t\\tvar isCube = false;\\n\\n\\t\\t\\tif ( renderTarget ) {\\n\\n\\t\\t\\t\\tvar __webglFramebuffer = properties.get( renderTarget ).__webglFramebuffer;\\n\\n\\t\\t\\t\\tif ( renderTarget.isWebGLRenderTargetCube ) {\\n\\n\\t\\t\\t\\t\\tframebuffer = __webglFramebuffer[ renderTarget.activeCubeFace ];\\n\\t\\t\\t\\t\\tisCube = true;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tframebuffer = __webglFramebuffer;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t_currentViewport.copy( renderTarget.viewport );\\n\\t\\t\\t\\t_currentScissor.copy( renderTarget.scissor );\\n\\t\\t\\t\\t_currentScissorTest = renderTarget.scissorTest;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t_currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio );\\n\\t\\t\\t\\t_currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio );\\n\\t\\t\\t\\t_currentScissorTest = _scissorTest;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( _currentFramebuffer !== framebuffer ) {\\n\\n\\t\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );\\n\\t\\t\\t\\t_currentFramebuffer = framebuffer;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tstate.viewport( _currentViewport );\\n\\t\\t\\tstate.scissor( _currentScissor );\\n\\t\\t\\tstate.setScissorTest( _currentScissorTest );\\n\\n\\t\\t\\tif ( isCube ) {\\n\\n\\t\\t\\t\\tvar textureProperties = properties.get( renderTarget.texture );\\n\\t\\t\\t\\t_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + renderTarget.activeCubeFace, textureProperties.__webglTexture, renderTarget.activeMipMapLevel );\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t\\tthis.readRenderTargetPixels = function ( renderTarget, x, y, width, height, buffer ) {\\n\\n\\t\\t\\tif ( ! ( renderTarget && renderTarget.isWebGLRenderTarget ) ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar framebuffer = properties.get( renderTarget ).__webglFramebuffer;\\n\\n\\t\\t\\tif ( framebuffer ) {\\n\\n\\t\\t\\t\\tvar restore = false;\\n\\n\\t\\t\\t\\tif ( framebuffer !== _currentFramebuffer ) {\\n\\n\\t\\t\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );\\n\\n\\t\\t\\t\\t\\trestore = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\ttry {\\n\\n\\t\\t\\t\\t\\tvar texture = renderTarget.texture;\\n\\t\\t\\t\\t\\tvar textureFormat = texture.format;\\n\\t\\t\\t\\t\\tvar textureType = texture.type;\\n\\n\\t\\t\\t\\t\\tif ( textureFormat !== RGBAFormat && utils.convert( textureFormat ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_FORMAT ) ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.' );\\n\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( textureType !== UnsignedByteType && utils.convert( textureType ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_TYPE ) && // IE11, Edge and Chrome Mac < 52 (#9513)\\n\\t\\t\\t\\t\\t\\t! ( textureType === FloatType && ( extensions.get( 'OES_texture_float' ) || extensions.get( 'WEBGL_color_buffer_float' ) ) ) && // Chrome Mac >= 52 and Firefox\\n\\t\\t\\t\\t\\t\\t! ( textureType === HalfFloatType && extensions.get( 'EXT_color_buffer_half_float' ) ) ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.' );\\n\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( _gl.checkFramebufferStatus( _gl.FRAMEBUFFER ) === _gl.FRAMEBUFFER_COMPLETE ) {\\n\\n\\t\\t\\t\\t\\t\\t// the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604)\\n\\n\\t\\t\\t\\t\\t\\tif ( ( x >= 0 && x <= ( renderTarget.width - width ) ) && ( y >= 0 && y <= ( renderTarget.height - height ) ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t_gl.readPixels( x, y, width, height, utils.convert( textureFormat ), utils.convert( textureType ), buffer );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.' );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} finally {\\n\\n\\t\\t\\t\\t\\tif ( restore ) {\\n\\n\\t\\t\\t\\t\\t\\t_gl.bindFramebuffer( _gl.FRAMEBUFFER, _currentFramebuffer );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction FogExp2( color, density ) {\\n\\n\\t\\tthis.name = '';\\n\\n\\t\\tthis.color = new Color( color );\\n\\t\\tthis.density = ( density !== undefined ) ? density : 0.00025;\\n\\n\\t}\\n\\n\\tFogExp2.prototype.isFogExp2 = true;\\n\\n\\tFogExp2.prototype.clone = function () {\\n\\n\\t\\treturn new FogExp2( this.color.getHex(), this.density );\\n\\n\\t};\\n\\n\\tFogExp2.prototype.toJSON = function ( /* meta */ ) {\\n\\n\\t\\treturn {\\n\\t\\t\\ttype: 'FogExp2',\\n\\t\\t\\tcolor: this.color.getHex(),\\n\\t\\t\\tdensity: this.density\\n\\t\\t};\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction Fog( color, near, far ) {\\n\\n\\t\\tthis.name = '';\\n\\n\\t\\tthis.color = new Color( color );\\n\\n\\t\\tthis.near = ( near !== undefined ) ? near : 1;\\n\\t\\tthis.far = ( far !== undefined ) ? far : 1000;\\n\\n\\t}\\n\\n\\tFog.prototype.isFog = true;\\n\\n\\tFog.prototype.clone = function () {\\n\\n\\t\\treturn new Fog( this.color.getHex(), this.near, this.far );\\n\\n\\t};\\n\\n\\tFog.prototype.toJSON = function ( /* meta */ ) {\\n\\n\\t\\treturn {\\n\\t\\t\\ttype: 'Fog',\\n\\t\\t\\tcolor: this.color.getHex(),\\n\\t\\t\\tnear: this.near,\\n\\t\\t\\tfar: this.far\\n\\t\\t};\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Scene() {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Scene';\\n\\n\\t\\tthis.background = null;\\n\\t\\tthis.fog = null;\\n\\t\\tthis.overrideMaterial = null;\\n\\n\\t\\tthis.autoUpdate = true; // checked by the renderer\\n\\n\\t}\\n\\n\\tScene.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Scene,\\n\\n\\t\\tcopy: function ( source, recursive ) {\\n\\n\\t\\t\\tObject3D.prototype.copy.call( this, source, recursive );\\n\\n\\t\\t\\tif ( source.background !== null ) this.background = source.background.clone();\\n\\t\\t\\tif ( source.fog !== null ) this.fog = source.fog.clone();\\n\\t\\t\\tif ( source.overrideMaterial !== null ) this.overrideMaterial = source.overrideMaterial.clone();\\n\\n\\t\\t\\tthis.autoUpdate = source.autoUpdate;\\n\\t\\t\\tthis.matrixAutoUpdate = source.matrixAutoUpdate;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\tvar data = Object3D.prototype.toJSON.call( this, meta );\\n\\n\\t\\t\\tif ( this.background !== null ) data.object.background = this.background.toJSON( meta );\\n\\t\\t\\tif ( this.fog !== null ) data.object.fog = this.fog.toJSON();\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction LensFlare( texture, size, distance, blending, color ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.lensFlares = [];\\n\\n\\t\\tthis.positionScreen = new Vector3();\\n\\t\\tthis.customUpdateCallback = undefined;\\n\\n\\t\\tif ( texture !== undefined ) {\\n\\n\\t\\t\\tthis.add( texture, size, distance, blending, color );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tLensFlare.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: LensFlare,\\n\\n\\t\\tisLensFlare: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tObject3D.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.positionScreen.copy( source.positionScreen );\\n\\t\\t\\tthis.customUpdateCallback = source.customUpdateCallback;\\n\\n\\t\\t\\tfor ( var i = 0, l = source.lensFlares.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tthis.lensFlares.push( source.lensFlares[ i ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tadd: function ( texture, size, distance, blending, color, opacity ) {\\n\\n\\t\\t\\tif ( size === undefined ) size = - 1;\\n\\t\\t\\tif ( distance === undefined ) distance = 0;\\n\\t\\t\\tif ( opacity === undefined ) opacity = 1;\\n\\t\\t\\tif ( color === undefined ) color = new Color( 0xffffff );\\n\\t\\t\\tif ( blending === undefined ) blending = NormalBlending;\\n\\n\\t\\t\\tdistance = Math.min( distance, Math.max( 0, distance ) );\\n\\n\\t\\t\\tthis.lensFlares.push( {\\n\\t\\t\\t\\ttexture: texture,\\t// THREE.Texture\\n\\t\\t\\t\\tsize: size, \\t\\t// size in pixels (-1 = use texture.width)\\n\\t\\t\\t\\tdistance: distance, \\t// distance (0-1) from light source (0=at light source)\\n\\t\\t\\t\\tx: 0, y: 0, z: 0,\\t// screen position (-1 => 1) z = 0 is in front z = 1 is back\\n\\t\\t\\t\\tscale: 1, \\t\\t// scale\\n\\t\\t\\t\\trotation: 0, \\t\\t// rotation\\n\\t\\t\\t\\topacity: opacity,\\t// opacity\\n\\t\\t\\t\\tcolor: color,\\t\\t// color\\n\\t\\t\\t\\tblending: blending\\t// blending\\n\\t\\t\\t} );\\n\\n\\t\\t},\\n\\n\\t\\t/*\\n\\t\\t * Update lens flares update positions on all flares based on the screen position\\n\\t\\t * Set myLensFlare.customUpdateCallback to alter the flares in your project specific way.\\n\\t\\t */\\n\\n\\t\\tupdateLensFlares: function () {\\n\\n\\t\\t\\tvar f, fl = this.lensFlares.length;\\n\\t\\t\\tvar flare;\\n\\t\\t\\tvar vecX = - this.positionScreen.x * 2;\\n\\t\\t\\tvar vecY = - this.positionScreen.y * 2;\\n\\n\\t\\t\\tfor ( f = 0; f < fl; f ++ ) {\\n\\n\\t\\t\\t\\tflare = this.lensFlares[ f ];\\n\\n\\t\\t\\t\\tflare.x = this.positionScreen.x + vecX * flare.distance;\\n\\t\\t\\t\\tflare.y = this.positionScreen.y + vecY * flare.distance;\\n\\n\\t\\t\\t\\tflare.wantedRotation = flare.x * Math.PI * 0.25;\\n\\t\\t\\t\\tflare.rotation += ( flare.wantedRotation - flare.rotation ) * 0.25;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * parameters = {\\n\\t *  color: <hex>,\\n\\t *  opacity: <float>,\\n\\t *  map: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *\\tuvOffset: new THREE.Vector2(),\\n\\t *\\tuvScale: new THREE.Vector2()\\n\\t * }\\n\\t */\\n\\n\\tfunction SpriteMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'SpriteMaterial';\\n\\n\\t\\tthis.color = new Color( 0xffffff );\\n\\t\\tthis.map = null;\\n\\n\\t\\tthis.rotation = 0;\\n\\n\\t\\tthis.fog = false;\\n\\t\\tthis.lights = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tSpriteMaterial.prototype = Object.create( Material.prototype );\\n\\tSpriteMaterial.prototype.constructor = SpriteMaterial;\\n\\tSpriteMaterial.prototype.isSpriteMaterial = true;\\n\\n\\tSpriteMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.color.copy( source.color );\\n\\t\\tthis.map = source.map;\\n\\n\\t\\tthis.rotation = source.rotation;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction Sprite( material ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Sprite';\\n\\n\\t\\tthis.material = ( material !== undefined ) ? material : new SpriteMaterial();\\n\\n\\t}\\n\\n\\tSprite.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Sprite,\\n\\n\\t\\tisSprite: true,\\n\\n\\t\\traycast: ( function () {\\n\\n\\t\\t\\tvar intersectPoint = new Vector3();\\n\\t\\t\\tvar worldPosition = new Vector3();\\n\\t\\t\\tvar worldScale = new Vector3();\\n\\n\\t\\t\\treturn function raycast( raycaster, intersects ) {\\n\\n\\t\\t\\t\\tworldPosition.setFromMatrixPosition( this.matrixWorld );\\n\\t\\t\\t\\traycaster.ray.closestPointToPoint( worldPosition, intersectPoint );\\n\\n\\t\\t\\t\\tworldScale.setFromMatrixScale( this.matrixWorld );\\n\\t\\t\\t\\tvar guessSizeSq = worldScale.x * worldScale.y / 4;\\n\\n\\t\\t\\t\\tif ( worldPosition.distanceToSquared( intersectPoint ) > guessSizeSq ) return;\\n\\n\\t\\t\\t\\tvar distance = raycaster.ray.origin.distanceTo( intersectPoint );\\n\\n\\t\\t\\t\\tif ( distance < raycaster.near || distance > raycaster.far ) return;\\n\\n\\t\\t\\t\\tintersects.push( {\\n\\n\\t\\t\\t\\t\\tdistance: distance,\\n\\t\\t\\t\\t\\tpoint: intersectPoint.clone(),\\n\\t\\t\\t\\t\\tface: null,\\n\\t\\t\\t\\t\\tobject: this\\n\\n\\t\\t\\t\\t} );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}() ),\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.material ).copy( this );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction LOD() {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'LOD';\\n\\n\\t\\tObject.defineProperties( this, {\\n\\t\\t\\tlevels: {\\n\\t\\t\\t\\tenumerable: true,\\n\\t\\t\\t\\tvalue: []\\n\\t\\t\\t}\\n\\t\\t} );\\n\\n\\t}\\n\\n\\tLOD.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: LOD,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tObject3D.prototype.copy.call( this, source, false );\\n\\n\\t\\t\\tvar levels = source.levels;\\n\\n\\t\\t\\tfor ( var i = 0, l = levels.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar level = levels[ i ];\\n\\n\\t\\t\\t\\tthis.addLevel( level.object.clone(), level.distance );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\taddLevel: function ( object, distance ) {\\n\\n\\t\\t\\tif ( distance === undefined ) distance = 0;\\n\\n\\t\\t\\tdistance = Math.abs( distance );\\n\\n\\t\\t\\tvar levels = this.levels;\\n\\n\\t\\t\\tfor ( var l = 0; l < levels.length; l ++ ) {\\n\\n\\t\\t\\t\\tif ( distance < levels[ l ].distance ) {\\n\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tlevels.splice( l, 0, { distance: distance, object: object } );\\n\\n\\t\\t\\tthis.add( object );\\n\\n\\t\\t},\\n\\n\\t\\tgetObjectForDistance: function ( distance ) {\\n\\n\\t\\t\\tvar levels = this.levels;\\n\\n\\t\\t\\tfor ( var i = 1, l = levels.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tif ( distance < levels[ i ].distance ) {\\n\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn levels[ i - 1 ].object;\\n\\n\\t\\t},\\n\\n\\t\\traycast: ( function () {\\n\\n\\t\\t\\tvar matrixPosition = new Vector3();\\n\\n\\t\\t\\treturn function raycast( raycaster, intersects ) {\\n\\n\\t\\t\\t\\tmatrixPosition.setFromMatrixPosition( this.matrixWorld );\\n\\n\\t\\t\\t\\tvar distance = raycaster.ray.origin.distanceTo( matrixPosition );\\n\\n\\t\\t\\t\\tthis.getObjectForDistance( distance ).raycast( raycaster, intersects );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}() ),\\n\\n\\t\\tupdate: function () {\\n\\n\\t\\t\\tvar v1 = new Vector3();\\n\\t\\t\\tvar v2 = new Vector3();\\n\\n\\t\\t\\treturn function update( camera ) {\\n\\n\\t\\t\\t\\tvar levels = this.levels;\\n\\n\\t\\t\\t\\tif ( levels.length > 1 ) {\\n\\n\\t\\t\\t\\t\\tv1.setFromMatrixPosition( camera.matrixWorld );\\n\\t\\t\\t\\t\\tv2.setFromMatrixPosition( this.matrixWorld );\\n\\n\\t\\t\\t\\t\\tvar distance = v1.distanceTo( v2 );\\n\\n\\t\\t\\t\\t\\tlevels[ 0 ].object.visible = true;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 1, l = levels.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( distance >= levels[ i ].distance ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tlevels[ i - 1 ].object.visible = false;\\n\\t\\t\\t\\t\\t\\t\\tlevels[ i ].object.visible = true;\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tfor ( ; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tlevels[ i ].object.visible = false;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\tvar data = Object3D.prototype.toJSON.call( this, meta );\\n\\n\\t\\t\\tdata.object.levels = [];\\n\\n\\t\\t\\tvar levels = this.levels;\\n\\n\\t\\t\\tfor ( var i = 0, l = levels.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar level = levels[ i ];\\n\\n\\t\\t\\t\\tdata.object.levels.push( {\\n\\t\\t\\t\\t\\tobject: level.object.uuid,\\n\\t\\t\\t\\t\\tdistance: level.distance\\n\\t\\t\\t\\t} );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author michael guerrero / http://realitymeltdown.com\\n\\t * @author ikerr / http://verold.com\\n\\t */\\n\\n\\tfunction Skeleton( bones, boneInverses ) {\\n\\n\\t\\t// copy the bone array\\n\\n\\t\\tbones = bones || [];\\n\\n\\t\\tthis.bones = bones.slice( 0 );\\n\\t\\tthis.boneMatrices = new Float32Array( this.bones.length * 16 );\\n\\n\\t\\t// use the supplied bone inverses or calculate the inverses\\n\\n\\t\\tif ( boneInverses === undefined ) {\\n\\n\\t\\t\\tthis.calculateInverses();\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tif ( this.bones.length === boneInverses.length ) {\\n\\n\\t\\t\\t\\tthis.boneInverses = boneInverses.slice( 0 );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Skeleton boneInverses is the wrong length.' );\\n\\n\\t\\t\\t\\tthis.boneInverses = [];\\n\\n\\t\\t\\t\\tfor ( var i = 0, il = this.bones.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tthis.boneInverses.push( new Matrix4() );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tObject.assign( Skeleton.prototype, {\\n\\n\\t\\tcalculateInverses: function () {\\n\\n\\t\\t\\tthis.boneInverses = [];\\n\\n\\t\\t\\tfor ( var i = 0, il = this.bones.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar inverse = new Matrix4();\\n\\n\\t\\t\\t\\tif ( this.bones[ i ] ) {\\n\\n\\t\\t\\t\\t\\tinverse.getInverse( this.bones[ i ].matrixWorld );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.boneInverses.push( inverse );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tpose: function () {\\n\\n\\t\\t\\tvar bone, i, il;\\n\\n\\t\\t\\t// recover the bind-time world matrices\\n\\n\\t\\t\\tfor ( i = 0, il = this.bones.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tbone = this.bones[ i ];\\n\\n\\t\\t\\t\\tif ( bone ) {\\n\\n\\t\\t\\t\\t\\tbone.matrixWorld.getInverse( this.boneInverses[ i ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// compute the local matrices, positions, rotations and scales\\n\\n\\t\\t\\tfor ( i = 0, il = this.bones.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tbone = this.bones[ i ];\\n\\n\\t\\t\\t\\tif ( bone ) {\\n\\n\\t\\t\\t\\t\\tif ( bone.parent && bone.parent.isBone ) {\\n\\n\\t\\t\\t\\t\\t\\tbone.matrix.getInverse( bone.parent.matrixWorld );\\n\\t\\t\\t\\t\\t\\tbone.matrix.multiply( bone.matrixWorld );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tbone.matrix.copy( bone.matrixWorld );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tbone.matrix.decompose( bone.position, bone.quaternion, bone.scale );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tupdate: ( function () {\\n\\n\\t\\t\\tvar offsetMatrix = new Matrix4();\\n\\t\\t\\tvar identityMatrix = new Matrix4();\\n\\n\\t\\t\\treturn function update() {\\n\\n\\t\\t\\t\\tvar bones = this.bones;\\n\\t\\t\\t\\tvar boneInverses = this.boneInverses;\\n\\t\\t\\t\\tvar boneMatrices = this.boneMatrices;\\n\\t\\t\\t\\tvar boneTexture = this.boneTexture;\\n\\n\\t\\t\\t\\t// flatten bone matrices to array\\n\\n\\t\\t\\t\\tfor ( var i = 0, il = bones.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t// compute the offset between the current and the original transform\\n\\n\\t\\t\\t\\t\\tvar matrix = bones[ i ] ? bones[ i ].matrixWorld : identityMatrix;\\n\\n\\t\\t\\t\\t\\toffsetMatrix.multiplyMatrices( matrix, boneInverses[ i ] );\\n\\t\\t\\t\\t\\toffsetMatrix.toArray( boneMatrices, i * 16 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( boneTexture !== undefined ) {\\n\\n\\t\\t\\t\\t\\tboneTexture.needsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )(),\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new Skeleton( this.bones, this.boneInverses );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author ikerr / http://verold.com\\n\\t */\\n\\n\\tfunction Bone() {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Bone';\\n\\n\\t}\\n\\n\\tBone.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Bone,\\n\\n\\t\\tisBone: true\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mikael emtinger / http://gomo.se/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author ikerr / http://verold.com\\n\\t */\\n\\n\\tfunction SkinnedMesh( geometry, material ) {\\n\\n\\t\\tMesh.call( this, geometry, material );\\n\\n\\t\\tthis.type = 'SkinnedMesh';\\n\\n\\t\\tthis.bindMode = 'attached';\\n\\t\\tthis.bindMatrix = new Matrix4();\\n\\t\\tthis.bindMatrixInverse = new Matrix4();\\n\\n\\t\\tvar bones = this.initBones();\\n\\t\\tvar skeleton = new Skeleton( bones );\\n\\n\\t\\tthis.bind( skeleton, this.matrixWorld );\\n\\n\\t\\tthis.normalizeSkinWeights();\\n\\n\\t}\\n\\n\\tSkinnedMesh.prototype = Object.assign( Object.create( Mesh.prototype ), {\\n\\n\\t\\tconstructor: SkinnedMesh,\\n\\n\\t\\tisSkinnedMesh: true,\\n\\n\\t\\tinitBones: function () {\\n\\n\\t\\t\\tvar bones = [], bone, gbone;\\n\\t\\t\\tvar i, il;\\n\\n\\t\\t\\tif ( this.geometry && this.geometry.bones !== undefined ) {\\n\\n\\t\\t\\t\\t// first, create array of 'Bone' objects from geometry data\\n\\n\\t\\t\\t\\tfor ( i = 0, il = this.geometry.bones.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tgbone = this.geometry.bones[ i ];\\n\\n\\t\\t\\t\\t\\t// create new 'Bone' object\\n\\n\\t\\t\\t\\t\\tbone = new Bone();\\n\\t\\t\\t\\t\\tbones.push( bone );\\n\\n\\t\\t\\t\\t\\t// apply values\\n\\n\\t\\t\\t\\t\\tbone.name = gbone.name;\\n\\t\\t\\t\\t\\tbone.position.fromArray( gbone.pos );\\n\\t\\t\\t\\t\\tbone.quaternion.fromArray( gbone.rotq );\\n\\t\\t\\t\\t\\tif ( gbone.scl !== undefined ) bone.scale.fromArray( gbone.scl );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// second, create bone hierarchy\\n\\n\\t\\t\\t\\tfor ( i = 0, il = this.geometry.bones.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tgbone = this.geometry.bones[ i ];\\n\\n\\t\\t\\t\\t\\tif ( ( gbone.parent !== - 1 ) && ( gbone.parent !== null ) && ( bones[ gbone.parent ] !== undefined ) ) {\\n\\n\\t\\t\\t\\t\\t\\t// subsequent bones in the hierarchy\\n\\n\\t\\t\\t\\t\\t\\tbones[ gbone.parent ].add( bones[ i ] );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t// topmost bone, immediate child of the skinned mesh\\n\\n\\t\\t\\t\\t\\t\\tthis.add( bones[ i ] );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// now the bones are part of the scene graph and children of the skinned mesh.\\n\\t\\t\\t// let's update the corresponding matrices\\n\\n\\t\\t\\tthis.updateMatrixWorld( true );\\n\\n\\t\\t\\treturn bones;\\n\\n\\t\\t},\\n\\n\\t\\tbind: function ( skeleton, bindMatrix ) {\\n\\n\\t\\t\\tthis.skeleton = skeleton;\\n\\n\\t\\t\\tif ( bindMatrix === undefined ) {\\n\\n\\t\\t\\t\\tthis.updateMatrixWorld( true );\\n\\n\\t\\t\\t\\tthis.skeleton.calculateInverses();\\n\\n\\t\\t\\t\\tbindMatrix = this.matrixWorld;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.bindMatrix.copy( bindMatrix );\\n\\t\\t\\tthis.bindMatrixInverse.getInverse( bindMatrix );\\n\\n\\t\\t},\\n\\n\\t\\tpose: function () {\\n\\n\\t\\t\\tthis.skeleton.pose();\\n\\n\\t\\t},\\n\\n\\t\\tnormalizeSkinWeights: function () {\\n\\n\\t\\t\\tvar scale, i;\\n\\n\\t\\t\\tif ( this.geometry && this.geometry.isGeometry ) {\\n\\n\\t\\t\\t\\tfor ( i = 0; i < this.geometry.skinWeights.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar sw = this.geometry.skinWeights[ i ];\\n\\n\\t\\t\\t\\t\\tscale = 1.0 / sw.manhattanLength();\\n\\n\\t\\t\\t\\t\\tif ( scale !== Infinity ) {\\n\\n\\t\\t\\t\\t\\t\\tsw.multiplyScalar( scale );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tsw.set( 1, 0, 0, 0 ); // do something reasonable\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( this.geometry && this.geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\tvar vec = new Vector4();\\n\\n\\t\\t\\t\\tvar skinWeight = this.geometry.attributes.skinWeight;\\n\\n\\t\\t\\t\\tfor ( i = 0; i < skinWeight.count; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvec.x = skinWeight.getX( i );\\n\\t\\t\\t\\t\\tvec.y = skinWeight.getY( i );\\n\\t\\t\\t\\t\\tvec.z = skinWeight.getZ( i );\\n\\t\\t\\t\\t\\tvec.w = skinWeight.getW( i );\\n\\n\\t\\t\\t\\t\\tscale = 1.0 / vec.manhattanLength();\\n\\n\\t\\t\\t\\t\\tif ( scale !== Infinity ) {\\n\\n\\t\\t\\t\\t\\t\\tvec.multiplyScalar( scale );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tvec.set( 1, 0, 0, 0 ); // do something reasonable\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tskinWeight.setXYZW( i, vec.x, vec.y, vec.z, vec.w );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tupdateMatrixWorld: function ( force ) {\\n\\n\\t\\t\\tMesh.prototype.updateMatrixWorld.call( this, force );\\n\\n\\t\\t\\tif ( this.bindMode === 'attached' ) {\\n\\n\\t\\t\\t\\tthis.bindMatrixInverse.getInverse( this.matrixWorld );\\n\\n\\t\\t\\t} else if ( this.bindMode === 'detached' ) {\\n\\n\\t\\t\\t\\tthis.bindMatrixInverse.getInverse( this.bindMatrix );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.SkinnedMesh: Unrecognized bindMode: ' + this.bindMode );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.geometry, this.material ).copy( this );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * parameters = {\\n\\t *  color: <hex>,\\n\\t *  opacity: <float>,\\n\\t *\\n\\t *  linewidth: <float>,\\n\\t *  linecap: \\\"round\\\",\\n\\t *  linejoin: \\\"round\\\"\\n\\t * }\\n\\t */\\n\\n\\tfunction LineBasicMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'LineBasicMaterial';\\n\\n\\t\\tthis.color = new Color( 0xffffff );\\n\\n\\t\\tthis.linewidth = 1;\\n\\t\\tthis.linecap = 'round';\\n\\t\\tthis.linejoin = 'round';\\n\\n\\t\\tthis.lights = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tLineBasicMaterial.prototype = Object.create( Material.prototype );\\n\\tLineBasicMaterial.prototype.constructor = LineBasicMaterial;\\n\\n\\tLineBasicMaterial.prototype.isLineBasicMaterial = true;\\n\\n\\tLineBasicMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.color.copy( source.color );\\n\\n\\t\\tthis.linewidth = source.linewidth;\\n\\t\\tthis.linecap = source.linecap;\\n\\t\\tthis.linejoin = source.linejoin;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Line( geometry, material, mode ) {\\n\\n\\t\\tif ( mode === 1 ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Line: parameter THREE.LinePieces no longer supported. Created THREE.LineSegments instead.' );\\n\\t\\t\\treturn new LineSegments( geometry, material );\\n\\n\\t\\t}\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Line';\\n\\n\\t\\tthis.geometry = geometry !== undefined ? geometry : new BufferGeometry();\\n\\t\\tthis.material = material !== undefined ? material : new LineBasicMaterial( { color: Math.random() * 0xffffff } );\\n\\n\\t}\\n\\n\\tLine.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Line,\\n\\n\\t\\tisLine: true,\\n\\n\\t\\traycast: ( function () {\\n\\n\\t\\t\\tvar inverseMatrix = new Matrix4();\\n\\t\\t\\tvar ray = new Ray();\\n\\t\\t\\tvar sphere = new Sphere();\\n\\n\\t\\t\\treturn function raycast( raycaster, intersects ) {\\n\\n\\t\\t\\t\\tvar precision = raycaster.linePrecision;\\n\\t\\t\\t\\tvar precisionSq = precision * precision;\\n\\n\\t\\t\\t\\tvar geometry = this.geometry;\\n\\t\\t\\t\\tvar matrixWorld = this.matrixWorld;\\n\\n\\t\\t\\t\\t// Checking boundingSphere distance to ray\\n\\n\\t\\t\\t\\tif ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();\\n\\n\\t\\t\\t\\tsphere.copy( geometry.boundingSphere );\\n\\t\\t\\t\\tsphere.applyMatrix4( matrixWorld );\\n\\n\\t\\t\\t\\tif ( raycaster.ray.intersectsSphere( sphere ) === false ) return;\\n\\n\\t\\t\\t\\t//\\n\\n\\t\\t\\t\\tinverseMatrix.getInverse( matrixWorld );\\n\\t\\t\\t\\tray.copy( raycaster.ray ).applyMatrix4( inverseMatrix );\\n\\n\\t\\t\\t\\tvar vStart = new Vector3();\\n\\t\\t\\t\\tvar vEnd = new Vector3();\\n\\t\\t\\t\\tvar interSegment = new Vector3();\\n\\t\\t\\t\\tvar interRay = new Vector3();\\n\\t\\t\\t\\tvar step = ( this && this.isLineSegments ) ? 2 : 1;\\n\\n\\t\\t\\t\\tif ( geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\t\\tvar index = geometry.index;\\n\\t\\t\\t\\t\\tvar attributes = geometry.attributes;\\n\\t\\t\\t\\t\\tvar positions = attributes.position.array;\\n\\n\\t\\t\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\t\\t\\tvar indices = index.array;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, l = indices.length - 1; i < l; i += step ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar a = indices[ i ];\\n\\t\\t\\t\\t\\t\\t\\tvar b = indices[ i + 1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\tvStart.fromArray( positions, a * 3 );\\n\\t\\t\\t\\t\\t\\t\\tvEnd.fromArray( positions, b * 3 );\\n\\n\\t\\t\\t\\t\\t\\t\\tvar distSq = ray.distanceSqToSegment( vStart, vEnd, interRay, interSegment );\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( distSq > precisionSq ) continue;\\n\\n\\t\\t\\t\\t\\t\\t\\tinterRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation\\n\\n\\t\\t\\t\\t\\t\\t\\tvar distance = raycaster.ray.origin.distanceTo( interRay );\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( distance < raycaster.near || distance > raycaster.far ) continue;\\n\\n\\t\\t\\t\\t\\t\\t\\tintersects.push( {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tdistance: distance,\\n\\t\\t\\t\\t\\t\\t\\t\\t// What do we want? intersection point on the ray or on the segment??\\n\\t\\t\\t\\t\\t\\t\\t\\t// point: raycaster.ray.at( distance ),\\n\\t\\t\\t\\t\\t\\t\\t\\tpoint: interSegment.clone().applyMatrix4( this.matrixWorld ),\\n\\t\\t\\t\\t\\t\\t\\t\\tindex: i,\\n\\t\\t\\t\\t\\t\\t\\t\\tface: null,\\n\\t\\t\\t\\t\\t\\t\\t\\tfaceIndex: null,\\n\\t\\t\\t\\t\\t\\t\\t\\tobject: this\\n\\n\\t\\t\\t\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, l = positions.length / 3 - 1; i < l; i += step ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvStart.fromArray( positions, 3 * i );\\n\\t\\t\\t\\t\\t\\t\\tvEnd.fromArray( positions, 3 * i + 3 );\\n\\n\\t\\t\\t\\t\\t\\t\\tvar distSq = ray.distanceSqToSegment( vStart, vEnd, interRay, interSegment );\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( distSq > precisionSq ) continue;\\n\\n\\t\\t\\t\\t\\t\\t\\tinterRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation\\n\\n\\t\\t\\t\\t\\t\\t\\tvar distance = raycaster.ray.origin.distanceTo( interRay );\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( distance < raycaster.near || distance > raycaster.far ) continue;\\n\\n\\t\\t\\t\\t\\t\\t\\tintersects.push( {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tdistance: distance,\\n\\t\\t\\t\\t\\t\\t\\t\\t// What do we want? intersection point on the ray or on the segment??\\n\\t\\t\\t\\t\\t\\t\\t\\t// point: raycaster.ray.at( distance ),\\n\\t\\t\\t\\t\\t\\t\\t\\tpoint: interSegment.clone().applyMatrix4( this.matrixWorld ),\\n\\t\\t\\t\\t\\t\\t\\t\\tindex: i,\\n\\t\\t\\t\\t\\t\\t\\t\\tface: null,\\n\\t\\t\\t\\t\\t\\t\\t\\tfaceIndex: null,\\n\\t\\t\\t\\t\\t\\t\\t\\tobject: this\\n\\n\\t\\t\\t\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( geometry.isGeometry ) {\\n\\n\\t\\t\\t\\t\\tvar vertices = geometry.vertices;\\n\\t\\t\\t\\t\\tvar nbVertices = vertices.length;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < nbVertices - 1; i += step ) {\\n\\n\\t\\t\\t\\t\\t\\tvar distSq = ray.distanceSqToSegment( vertices[ i ], vertices[ i + 1 ], interRay, interSegment );\\n\\n\\t\\t\\t\\t\\t\\tif ( distSq > precisionSq ) continue;\\n\\n\\t\\t\\t\\t\\t\\tinterRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation\\n\\n\\t\\t\\t\\t\\t\\tvar distance = raycaster.ray.origin.distanceTo( interRay );\\n\\n\\t\\t\\t\\t\\t\\tif ( distance < raycaster.near || distance > raycaster.far ) continue;\\n\\n\\t\\t\\t\\t\\t\\tintersects.push( {\\n\\n\\t\\t\\t\\t\\t\\t\\tdistance: distance,\\n\\t\\t\\t\\t\\t\\t\\t// What do we want? intersection point on the ray or on the segment??\\n\\t\\t\\t\\t\\t\\t\\t// point: raycaster.ray.at( distance ),\\n\\t\\t\\t\\t\\t\\t\\tpoint: interSegment.clone().applyMatrix4( this.matrixWorld ),\\n\\t\\t\\t\\t\\t\\t\\tindex: i,\\n\\t\\t\\t\\t\\t\\t\\tface: null,\\n\\t\\t\\t\\t\\t\\t\\tfaceIndex: null,\\n\\t\\t\\t\\t\\t\\t\\tobject: this\\n\\n\\t\\t\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}() ),\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.geometry, this.material ).copy( this );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction LineSegments( geometry, material ) {\\n\\n\\t\\tLine.call( this, geometry, material );\\n\\n\\t\\tthis.type = 'LineSegments';\\n\\n\\t}\\n\\n\\tLineSegments.prototype = Object.assign( Object.create( Line.prototype ), {\\n\\n\\t\\tconstructor: LineSegments,\\n\\n\\t\\tisLineSegments: true\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mgreter / http://github.com/mgreter\\n\\t */\\n\\n\\tfunction LineLoop( geometry, material ) {\\n\\n\\t\\tLine.call( this, geometry, material );\\n\\n\\t\\tthis.type = 'LineLoop';\\n\\n\\t}\\n\\n\\tLineLoop.prototype = Object.assign( Object.create( Line.prototype ), {\\n\\n\\t\\tconstructor: LineLoop,\\n\\n\\t\\tisLineLoop: true,\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * parameters = {\\n\\t *  color: <hex>,\\n\\t *  opacity: <float>,\\n\\t *  map: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  size: <float>,\\n\\t *  sizeAttenuation: <bool>\\n\\t * }\\n\\t */\\n\\n\\tfunction PointsMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'PointsMaterial';\\n\\n\\t\\tthis.color = new Color( 0xffffff );\\n\\n\\t\\tthis.map = null;\\n\\n\\t\\tthis.size = 1;\\n\\t\\tthis.sizeAttenuation = true;\\n\\n\\t\\tthis.lights = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tPointsMaterial.prototype = Object.create( Material.prototype );\\n\\tPointsMaterial.prototype.constructor = PointsMaterial;\\n\\n\\tPointsMaterial.prototype.isPointsMaterial = true;\\n\\n\\tPointsMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.color.copy( source.color );\\n\\n\\t\\tthis.map = source.map;\\n\\n\\t\\tthis.size = source.size;\\n\\t\\tthis.sizeAttenuation = source.sizeAttenuation;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction Points( geometry, material ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Points';\\n\\n\\t\\tthis.geometry = geometry !== undefined ? geometry : new BufferGeometry();\\n\\t\\tthis.material = material !== undefined ? material : new PointsMaterial( { color: Math.random() * 0xffffff } );\\n\\n\\t}\\n\\n\\tPoints.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Points,\\n\\n\\t\\tisPoints: true,\\n\\n\\t\\traycast: ( function () {\\n\\n\\t\\t\\tvar inverseMatrix = new Matrix4();\\n\\t\\t\\tvar ray = new Ray();\\n\\t\\t\\tvar sphere = new Sphere();\\n\\n\\t\\t\\treturn function raycast( raycaster, intersects ) {\\n\\n\\t\\t\\t\\tvar object = this;\\n\\t\\t\\t\\tvar geometry = this.geometry;\\n\\t\\t\\t\\tvar matrixWorld = this.matrixWorld;\\n\\t\\t\\t\\tvar threshold = raycaster.params.Points.threshold;\\n\\n\\t\\t\\t\\t// Checking boundingSphere distance to ray\\n\\n\\t\\t\\t\\tif ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();\\n\\n\\t\\t\\t\\tsphere.copy( geometry.boundingSphere );\\n\\t\\t\\t\\tsphere.applyMatrix4( matrixWorld );\\n\\t\\t\\t\\tsphere.radius += threshold;\\n\\n\\t\\t\\t\\tif ( raycaster.ray.intersectsSphere( sphere ) === false ) return;\\n\\n\\t\\t\\t\\t//\\n\\n\\t\\t\\t\\tinverseMatrix.getInverse( matrixWorld );\\n\\t\\t\\t\\tray.copy( raycaster.ray ).applyMatrix4( inverseMatrix );\\n\\n\\t\\t\\t\\tvar localThreshold = threshold / ( ( this.scale.x + this.scale.y + this.scale.z ) / 3 );\\n\\t\\t\\t\\tvar localThresholdSq = localThreshold * localThreshold;\\n\\t\\t\\t\\tvar position = new Vector3();\\n\\n\\t\\t\\t\\tfunction testPoint( point, index ) {\\n\\n\\t\\t\\t\\t\\tvar rayPointDistanceSq = ray.distanceSqToPoint( point );\\n\\n\\t\\t\\t\\t\\tif ( rayPointDistanceSq < localThresholdSq ) {\\n\\n\\t\\t\\t\\t\\t\\tvar intersectPoint = ray.closestPointToPoint( point );\\n\\t\\t\\t\\t\\t\\tintersectPoint.applyMatrix4( matrixWorld );\\n\\n\\t\\t\\t\\t\\t\\tvar distance = raycaster.ray.origin.distanceTo( intersectPoint );\\n\\n\\t\\t\\t\\t\\t\\tif ( distance < raycaster.near || distance > raycaster.far ) return;\\n\\n\\t\\t\\t\\t\\t\\tintersects.push( {\\n\\n\\t\\t\\t\\t\\t\\t\\tdistance: distance,\\n\\t\\t\\t\\t\\t\\t\\tdistanceToRay: Math.sqrt( rayPointDistanceSq ),\\n\\t\\t\\t\\t\\t\\t\\tpoint: intersectPoint.clone(),\\n\\t\\t\\t\\t\\t\\t\\tindex: index,\\n\\t\\t\\t\\t\\t\\t\\tface: null,\\n\\t\\t\\t\\t\\t\\t\\tobject: object\\n\\n\\t\\t\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\t\\tvar index = geometry.index;\\n\\t\\t\\t\\t\\tvar attributes = geometry.attributes;\\n\\t\\t\\t\\t\\tvar positions = attributes.position.array;\\n\\n\\t\\t\\t\\t\\tif ( index !== null ) {\\n\\n\\t\\t\\t\\t\\t\\tvar indices = index.array;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, il = indices.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar a = indices[ i ];\\n\\n\\t\\t\\t\\t\\t\\t\\tposition.fromArray( positions, a * 3 );\\n\\n\\t\\t\\t\\t\\t\\t\\ttestPoint( position, a );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, l = positions.length / 3; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tposition.fromArray( positions, i * 3 );\\n\\n\\t\\t\\t\\t\\t\\t\\ttestPoint( position, i );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tvar vertices = geometry.vertices;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, l = vertices.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\ttestPoint( vertices[ i ], i );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t}() ),\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor( this.geometry, this.material ).copy( this );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Group() {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Group';\\n\\n\\t}\\n\\n\\tGroup.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Group,\\n\\n\\t\\tisGroup: true\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction VideoTexture( video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) {\\n\\n\\t\\tTexture.call( this, video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );\\n\\n\\t\\tthis.generateMipmaps = false;\\n\\n\\t\\t// Set needsUpdate when first frame is ready\\n\\n\\t\\tvar scope = this;\\n\\n\\t\\tfunction onLoaded() {\\n\\n\\t\\t\\tvideo.removeEventListener( 'loadeddata', onLoaded, false );\\n\\t\\t\\tscope.needsUpdate = true;\\n\\n\\t\\t}\\n\\n\\t\\tvideo.addEventListener( 'loadeddata', onLoaded, false );\\n\\n\\t}\\n\\n\\tVideoTexture.prototype = Object.assign( Object.create( Texture.prototype ), {\\n\\n\\t\\tconstructor: VideoTexture,\\n\\n\\t\\tisVideoTexture: true,\\n\\n\\t\\tupdate: function () {\\n\\n\\t\\t\\tvar video = this.image;\\n\\n\\t\\t\\tif ( video.readyState >= video.HAVE_CURRENT_DATA ) {\\n\\n\\t\\t\\t\\tthis.needsUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction CompressedTexture( mipmaps, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, encoding ) {\\n\\n\\t\\tTexture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding );\\n\\n\\t\\tthis.image = { width: width, height: height };\\n\\t\\tthis.mipmaps = mipmaps;\\n\\n\\t\\t// no flipping for cube textures\\n\\t\\t// (also flipping doesn't work for compressed textures )\\n\\n\\t\\tthis.flipY = false;\\n\\n\\t\\t// can't generate mipmaps for compressed textures\\n\\t\\t// mips must be embedded in DDS files\\n\\n\\t\\tthis.generateMipmaps = false;\\n\\n\\t}\\n\\n\\tCompressedTexture.prototype = Object.create( Texture.prototype );\\n\\tCompressedTexture.prototype.constructor = CompressedTexture;\\n\\n\\tCompressedTexture.prototype.isCompressedTexture = true;\\n\\n\\t/**\\n\\t * @author Matt DesLauriers / @mattdesl\\n\\t * @author atix / arthursilber.de\\n\\t */\\n\\n\\tfunction DepthTexture( width, height, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, format ) {\\n\\n\\t\\tformat = format !== undefined ? format : DepthFormat;\\n\\n\\t\\tif ( format !== DepthFormat && format !== DepthStencilFormat ) {\\n\\n\\t\\t\\tthrow new Error( 'DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat' );\\n\\n\\t\\t}\\n\\n\\t\\tif ( type === undefined && format === DepthFormat ) type = UnsignedShortType;\\n\\t\\tif ( type === undefined && format === DepthStencilFormat ) type = UnsignedInt248Type;\\n\\n\\t\\tTexture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );\\n\\n\\t\\tthis.image = { width: width, height: height };\\n\\n\\t\\tthis.magFilter = magFilter !== undefined ? magFilter : NearestFilter;\\n\\t\\tthis.minFilter = minFilter !== undefined ? minFilter : NearestFilter;\\n\\n\\t\\tthis.flipY = false;\\n\\t\\tthis.generateMipmaps\\t= false;\\n\\n\\t}\\n\\n\\tDepthTexture.prototype = Object.create( Texture.prototype );\\n\\tDepthTexture.prototype.constructor = DepthTexture;\\n\\tDepthTexture.prototype.isDepthTexture = true;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\tfunction WireframeGeometry( geometry ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'WireframeGeometry';\\n\\n\\t\\t// buffer\\n\\n\\t\\tvar vertices = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar i, j, l, o, ol;\\n\\t\\tvar edge = [ 0, 0 ], edges = {}, e, edge1, edge2;\\n\\t\\tvar key, keys = [ 'a', 'b', 'c' ];\\n\\t\\tvar vertex;\\n\\n\\t\\t// different logic for Geometry and BufferGeometry\\n\\n\\t\\tif ( geometry && geometry.isGeometry ) {\\n\\n\\t\\t\\t// create a data structure that contains all edges without duplicates\\n\\n\\t\\t\\tvar faces = geometry.faces;\\n\\n\\t\\t\\tfor ( i = 0, l = faces.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar face = faces[ i ];\\n\\n\\t\\t\\t\\tfor ( j = 0; j < 3; j ++ ) {\\n\\n\\t\\t\\t\\t\\tedge1 = face[ keys[ j ] ];\\n\\t\\t\\t\\t\\tedge2 = face[ keys[ ( j + 1 ) % 3 ] ];\\n\\t\\t\\t\\t\\tedge[ 0 ] = Math.min( edge1, edge2 ); // sorting prevents duplicates\\n\\t\\t\\t\\t\\tedge[ 1 ] = Math.max( edge1, edge2 );\\n\\n\\t\\t\\t\\t\\tkey = edge[ 0 ] + ',' + edge[ 1 ];\\n\\n\\t\\t\\t\\t\\tif ( edges[ key ] === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tedges[ key ] = { index1: edge[ 0 ], index2: edge[ 1 ] };\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// generate vertices\\n\\n\\t\\t\\tfor ( key in edges ) {\\n\\n\\t\\t\\t\\te = edges[ key ];\\n\\n\\t\\t\\t\\tvertex = geometry.vertices[ e.index1 ];\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\tvertex = geometry.vertices[ e.index2 ];\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t}\\n\\n\\t\\t} else if ( geometry && geometry.isBufferGeometry ) {\\n\\n\\t\\t\\tvar position, indices, groups;\\n\\t\\t\\tvar group, start, count;\\n\\t\\t\\tvar index1, index2;\\n\\n\\t\\t\\tvertex = new Vector3();\\n\\n\\t\\t\\tif ( geometry.index !== null ) {\\n\\n\\t\\t\\t\\t// indexed BufferGeometry\\n\\n\\t\\t\\t\\tposition = geometry.attributes.position;\\n\\t\\t\\t\\tindices = geometry.index;\\n\\t\\t\\t\\tgroups = geometry.groups;\\n\\n\\t\\t\\t\\tif ( groups.length === 0 ) {\\n\\n\\t\\t\\t\\t\\tgroups = [ { start: 0, count: indices.count, materialIndex: 0 } ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// create a data structure that contains all eges without duplicates\\n\\n\\t\\t\\t\\tfor ( o = 0, ol = groups.length; o < ol; ++ o ) {\\n\\n\\t\\t\\t\\t\\tgroup = groups[ o ];\\n\\n\\t\\t\\t\\t\\tstart = group.start;\\n\\t\\t\\t\\t\\tcount = group.count;\\n\\n\\t\\t\\t\\t\\tfor ( i = start, l = ( start + count ); i < l; i += 3 ) {\\n\\n\\t\\t\\t\\t\\t\\tfor ( j = 0; j < 3; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tedge1 = indices.getX( i + j );\\n\\t\\t\\t\\t\\t\\t\\tedge2 = indices.getX( i + ( j + 1 ) % 3 );\\n\\t\\t\\t\\t\\t\\t\\tedge[ 0 ] = Math.min( edge1, edge2 ); // sorting prevents duplicates\\n\\t\\t\\t\\t\\t\\t\\tedge[ 1 ] = Math.max( edge1, edge2 );\\n\\n\\t\\t\\t\\t\\t\\t\\tkey = edge[ 0 ] + ',' + edge[ 1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( edges[ key ] === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tedges[ key ] = { index1: edge[ 0 ], index2: edge[ 1 ] };\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// generate vertices\\n\\n\\t\\t\\t\\tfor ( key in edges ) {\\n\\n\\t\\t\\t\\t\\te = edges[ key ];\\n\\n\\t\\t\\t\\t\\tvertex.fromBufferAttribute( position, e.index1 );\\n\\t\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t\\tvertex.fromBufferAttribute( position, e.index2 );\\n\\t\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// non-indexed BufferGeometry\\n\\n\\t\\t\\t\\tposition = geometry.attributes.position;\\n\\n\\t\\t\\t\\tfor ( i = 0, l = ( position.count / 3 ); i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tfor ( j = 0; j < 3; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t// three edges per triangle, an edge is represented as (index1, index2)\\n\\t\\t\\t\\t\\t\\t// e.g. the first triangle has the following edges: (0,1),(1,2),(2,0)\\n\\n\\t\\t\\t\\t\\t\\tindex1 = 3 * i + j;\\n\\t\\t\\t\\t\\t\\tvertex.fromBufferAttribute( position, index1 );\\n\\t\\t\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t\\t\\tindex2 = 3 * i + ( ( j + 1 ) % 3 );\\n\\t\\t\\t\\t\\t\\tvertex.fromBufferAttribute( position, index2 );\\n\\t\\t\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\n\\t}\\n\\n\\tWireframeGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tWireframeGeometry.prototype.constructor = WireframeGeometry;\\n\\n\\t/**\\n\\t * @author zz85 / https://github.com/zz85\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t *\\n\\t * Parametric Surfaces Geometry\\n\\t * based on the brilliant article by @prideout http://prideout.net/blog/?p=44\\n\\t */\\n\\n\\t// ParametricGeometry\\n\\n\\tfunction ParametricGeometry( func, slices, stacks ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'ParametricGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tfunc: func,\\n\\t\\t\\tslices: slices,\\n\\t\\t\\tstacks: stacks\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new ParametricBufferGeometry( func, slices, stacks ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tParametricGeometry.prototype = Object.create( Geometry.prototype );\\n\\tParametricGeometry.prototype.constructor = ParametricGeometry;\\n\\n\\t// ParametricBufferGeometry\\n\\n\\tfunction ParametricBufferGeometry( func, slices, stacks ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'ParametricBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tfunc: func,\\n\\t\\t\\tslices: slices,\\n\\t\\t\\tstacks: stacks\\n\\t\\t};\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\tvar EPS = 0.00001;\\n\\n\\t\\tvar normal = new Vector3();\\n\\n\\t\\tvar p0 = new Vector3(), p1 = new Vector3();\\n\\t\\tvar pu = new Vector3(), pv = new Vector3();\\n\\n\\t\\tvar i, j;\\n\\n\\t\\t// generate vertices, normals and uvs\\n\\n\\t\\tvar sliceCount = slices + 1;\\n\\n\\t\\tfor ( i = 0; i <= stacks; i ++ ) {\\n\\n\\t\\t\\tvar v = i / stacks;\\n\\n\\t\\t\\tfor ( j = 0; j <= slices; j ++ ) {\\n\\n\\t\\t\\t\\tvar u = j / slices;\\n\\n\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\tp0 = func( u, v, p0 );\\n\\t\\t\\t\\tvertices.push( p0.x, p0.y, p0.z );\\n\\n\\t\\t\\t\\t// normal\\n\\n\\t\\t\\t\\t// approximate tangent vectors via finite differences\\n\\n\\t\\t\\t\\tif ( u - EPS >= 0 ) {\\n\\n\\t\\t\\t\\t\\tp1 = func( u - EPS, v, p1 );\\n\\t\\t\\t\\t\\tpu.subVectors( p0, p1 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tp1 = func( u + EPS, v, p1 );\\n\\t\\t\\t\\t\\tpu.subVectors( p1, p0 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( v - EPS >= 0 ) {\\n\\n\\t\\t\\t\\t\\tp1 = func( u, v - EPS, p1 );\\n\\t\\t\\t\\t\\tpv.subVectors( p0, p1 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tp1 = func( u, v + EPS, p1 );\\n\\t\\t\\t\\t\\tpv.subVectors( p1, p0 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// cross product of tangent vectors returns surface normal\\n\\n\\t\\t\\t\\tnormal.crossVectors( pu, pv ).normalize();\\n\\t\\t\\t\\tnormals.push( normal.x, normal.y, normal.z );\\n\\n\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\tuvs.push( u, v );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// generate indices\\n\\n\\t\\tfor ( i = 0; i < stacks; i ++ ) {\\n\\n\\t\\t\\tfor ( j = 0; j < slices; j ++ ) {\\n\\n\\t\\t\\t\\tvar a = i * sliceCount + j;\\n\\t\\t\\t\\tvar b = i * sliceCount + j + 1;\\n\\t\\t\\t\\tvar c = ( i + 1 ) * sliceCount + j + 1;\\n\\t\\t\\t\\tvar d = ( i + 1 ) * sliceCount + j;\\n\\n\\t\\t\\t\\t// faces one and two\\n\\n\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t}\\n\\n\\tParametricBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tParametricBufferGeometry.prototype.constructor = ParametricBufferGeometry;\\n\\n\\t/**\\n\\t * @author clockworkgeek / https://github.com/clockworkgeek\\n\\t * @author timothypratley / https://github.com/timothypratley\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// PolyhedronGeometry\\n\\n\\tfunction PolyhedronGeometry( vertices, indices, radius, detail ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'PolyhedronGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tvertices: vertices,\\n\\t\\t\\tindices: indices,\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new PolyhedronBufferGeometry( vertices, indices, radius, detail ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tPolyhedronGeometry.prototype = Object.create( Geometry.prototype );\\n\\tPolyhedronGeometry.prototype.constructor = PolyhedronGeometry;\\n\\n\\t// PolyhedronBufferGeometry\\n\\n\\tfunction PolyhedronBufferGeometry( vertices, indices, radius, detail ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'PolyhedronBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tvertices: vertices,\\n\\t\\t\\tindices: indices,\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t\\tradius = radius || 1;\\n\\t\\tdetail = detail || 0;\\n\\n\\t\\t// default buffer data\\n\\n\\t\\tvar vertexBuffer = [];\\n\\t\\tvar uvBuffer = [];\\n\\n\\t\\t// the subdivision creates the vertex buffer data\\n\\n\\t\\tsubdivide( detail );\\n\\n\\t\\t// all vertices should lie on a conceptual sphere with a given radius\\n\\n\\t\\tappplyRadius( radius );\\n\\n\\t\\t// finally, create the uv data\\n\\n\\t\\tgenerateUVs();\\n\\n\\t\\t// build non-indexed geometry\\n\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertexBuffer, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( vertexBuffer.slice(), 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvBuffer, 2 ) );\\n\\n\\t\\tif ( detail === 0 ) {\\n\\n\\t\\t\\tthis.computeVertexNormals(); // flat normals\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tthis.normalizeNormals(); // smooth normals\\n\\n\\t\\t}\\n\\n\\t\\t// helper functions\\n\\n\\t\\tfunction subdivide( detail ) {\\n\\n\\t\\t\\tvar a = new Vector3();\\n\\t\\t\\tvar b = new Vector3();\\n\\t\\t\\tvar c = new Vector3();\\n\\n\\t\\t\\t// iterate over all faces and apply a subdivison with the given detail value\\n\\n\\t\\t\\tfor ( var i = 0; i < indices.length; i += 3 ) {\\n\\n\\t\\t\\t\\t// get the vertices of the face\\n\\n\\t\\t\\t\\tgetVertexByIndex( indices[ i + 0 ], a );\\n\\t\\t\\t\\tgetVertexByIndex( indices[ i + 1 ], b );\\n\\t\\t\\t\\tgetVertexByIndex( indices[ i + 2 ], c );\\n\\n\\t\\t\\t\\t// perform subdivision\\n\\n\\t\\t\\t\\tsubdivideFace( a, b, c, detail );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction subdivideFace( a, b, c, detail ) {\\n\\n\\t\\t\\tvar cols = Math.pow( 2, detail );\\n\\n\\t\\t\\t// we use this multidimensional array as a data structure for creating the subdivision\\n\\n\\t\\t\\tvar v = [];\\n\\n\\t\\t\\tvar i, j;\\n\\n\\t\\t\\t// construct all of the vertices for this subdivision\\n\\n\\t\\t\\tfor ( i = 0; i <= cols; i ++ ) {\\n\\n\\t\\t\\t\\tv[ i ] = [];\\n\\n\\t\\t\\t\\tvar aj = a.clone().lerp( c, i / cols );\\n\\t\\t\\t\\tvar bj = b.clone().lerp( c, i / cols );\\n\\n\\t\\t\\t\\tvar rows = cols - i;\\n\\n\\t\\t\\t\\tfor ( j = 0; j <= rows; j ++ ) {\\n\\n\\t\\t\\t\\t\\tif ( j === 0 && i === cols ) {\\n\\n\\t\\t\\t\\t\\t\\tv[ i ][ j ] = aj;\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tv[ i ][ j ] = aj.clone().lerp( bj, j / rows );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// construct all of the faces\\n\\n\\t\\t\\tfor ( i = 0; i < cols; i ++ ) {\\n\\n\\t\\t\\t\\tfor ( j = 0; j < 2 * ( cols - i ) - 1; j ++ ) {\\n\\n\\t\\t\\t\\t\\tvar k = Math.floor( j / 2 );\\n\\n\\t\\t\\t\\t\\tif ( j % 2 === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tpushVertex( v[ i ][ k + 1 ] );\\n\\t\\t\\t\\t\\t\\tpushVertex( v[ i + 1 ][ k ] );\\n\\t\\t\\t\\t\\t\\tpushVertex( v[ i ][ k ] );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tpushVertex( v[ i ][ k + 1 ] );\\n\\t\\t\\t\\t\\t\\tpushVertex( v[ i + 1 ][ k + 1 ] );\\n\\t\\t\\t\\t\\t\\tpushVertex( v[ i + 1 ][ k ] );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction appplyRadius( radius ) {\\n\\n\\t\\t\\tvar vertex = new Vector3();\\n\\n\\t\\t\\t// iterate over the entire buffer and apply the radius to each vertex\\n\\n\\t\\t\\tfor ( var i = 0; i < vertexBuffer.length; i += 3 ) {\\n\\n\\t\\t\\t\\tvertex.x = vertexBuffer[ i + 0 ];\\n\\t\\t\\t\\tvertex.y = vertexBuffer[ i + 1 ];\\n\\t\\t\\t\\tvertex.z = vertexBuffer[ i + 2 ];\\n\\n\\t\\t\\t\\tvertex.normalize().multiplyScalar( radius );\\n\\n\\t\\t\\t\\tvertexBuffer[ i + 0 ] = vertex.x;\\n\\t\\t\\t\\tvertexBuffer[ i + 1 ] = vertex.y;\\n\\t\\t\\t\\tvertexBuffer[ i + 2 ] = vertex.z;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction generateUVs() {\\n\\n\\t\\t\\tvar vertex = new Vector3();\\n\\n\\t\\t\\tfor ( var i = 0; i < vertexBuffer.length; i += 3 ) {\\n\\n\\t\\t\\t\\tvertex.x = vertexBuffer[ i + 0 ];\\n\\t\\t\\t\\tvertex.y = vertexBuffer[ i + 1 ];\\n\\t\\t\\t\\tvertex.z = vertexBuffer[ i + 2 ];\\n\\n\\t\\t\\t\\tvar u = azimuth( vertex ) / 2 / Math.PI + 0.5;\\n\\t\\t\\t\\tvar v = inclination( vertex ) / Math.PI + 0.5;\\n\\t\\t\\t\\tuvBuffer.push( u, 1 - v );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tcorrectUVs();\\n\\n\\t\\t\\tcorrectSeam();\\n\\n\\t\\t}\\n\\n\\t\\tfunction correctSeam() {\\n\\n\\t\\t\\t// handle case when face straddles the seam, see #3269\\n\\n\\t\\t\\tfor ( var i = 0; i < uvBuffer.length; i += 6 ) {\\n\\n\\t\\t\\t\\t// uv data of a single face\\n\\n\\t\\t\\t\\tvar x0 = uvBuffer[ i + 0 ];\\n\\t\\t\\t\\tvar x1 = uvBuffer[ i + 2 ];\\n\\t\\t\\t\\tvar x2 = uvBuffer[ i + 4 ];\\n\\n\\t\\t\\t\\tvar max = Math.max( x0, x1, x2 );\\n\\t\\t\\t\\tvar min = Math.min( x0, x1, x2 );\\n\\n\\t\\t\\t\\t// 0.9 is somewhat arbitrary\\n\\n\\t\\t\\t\\tif ( max > 0.9 && min < 0.1 ) {\\n\\n\\t\\t\\t\\t\\tif ( x0 < 0.2 ) uvBuffer[ i + 0 ] += 1;\\n\\t\\t\\t\\t\\tif ( x1 < 0.2 ) uvBuffer[ i + 2 ] += 1;\\n\\t\\t\\t\\t\\tif ( x2 < 0.2 ) uvBuffer[ i + 4 ] += 1;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction pushVertex( vertex ) {\\n\\n\\t\\t\\tvertexBuffer.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t}\\n\\n\\t\\tfunction getVertexByIndex( index, vertex ) {\\n\\n\\t\\t\\tvar stride = index * 3;\\n\\n\\t\\t\\tvertex.x = vertices[ stride + 0 ];\\n\\t\\t\\tvertex.y = vertices[ stride + 1 ];\\n\\t\\t\\tvertex.z = vertices[ stride + 2 ];\\n\\n\\t\\t}\\n\\n\\t\\tfunction correctUVs() {\\n\\n\\t\\t\\tvar a = new Vector3();\\n\\t\\t\\tvar b = new Vector3();\\n\\t\\t\\tvar c = new Vector3();\\n\\n\\t\\t\\tvar centroid = new Vector3();\\n\\n\\t\\t\\tvar uvA = new Vector2();\\n\\t\\t\\tvar uvB = new Vector2();\\n\\t\\t\\tvar uvC = new Vector2();\\n\\n\\t\\t\\tfor ( var i = 0, j = 0; i < vertexBuffer.length; i += 9, j += 6 ) {\\n\\n\\t\\t\\t\\ta.set( vertexBuffer[ i + 0 ], vertexBuffer[ i + 1 ], vertexBuffer[ i + 2 ] );\\n\\t\\t\\t\\tb.set( vertexBuffer[ i + 3 ], vertexBuffer[ i + 4 ], vertexBuffer[ i + 5 ] );\\n\\t\\t\\t\\tc.set( vertexBuffer[ i + 6 ], vertexBuffer[ i + 7 ], vertexBuffer[ i + 8 ] );\\n\\n\\t\\t\\t\\tuvA.set( uvBuffer[ j + 0 ], uvBuffer[ j + 1 ] );\\n\\t\\t\\t\\tuvB.set( uvBuffer[ j + 2 ], uvBuffer[ j + 3 ] );\\n\\t\\t\\t\\tuvC.set( uvBuffer[ j + 4 ], uvBuffer[ j + 5 ] );\\n\\n\\t\\t\\t\\tcentroid.copy( a ).add( b ).add( c ).divideScalar( 3 );\\n\\n\\t\\t\\t\\tvar azi = azimuth( centroid );\\n\\n\\t\\t\\t\\tcorrectUV( uvA, j + 0, a, azi );\\n\\t\\t\\t\\tcorrectUV( uvB, j + 2, b, azi );\\n\\t\\t\\t\\tcorrectUV( uvC, j + 4, c, azi );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction correctUV( uv, stride, vector, azimuth ) {\\n\\n\\t\\t\\tif ( ( azimuth < 0 ) && ( uv.x === 1 ) ) {\\n\\n\\t\\t\\t\\tuvBuffer[ stride ] = uv.x - 1;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( ( vector.x === 0 ) && ( vector.z === 0 ) ) {\\n\\n\\t\\t\\t\\tuvBuffer[ stride ] = azimuth / 2 / Math.PI + 0.5;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// Angle around the Y axis, counter-clockwise when looking from above.\\n\\n\\t\\tfunction azimuth( vector ) {\\n\\n\\t\\t\\treturn Math.atan2( vector.z, - vector.x );\\n\\n\\t\\t}\\n\\n\\n\\t\\t// Angle above the XZ plane.\\n\\n\\t\\tfunction inclination( vector ) {\\n\\n\\t\\t\\treturn Math.atan2( - vector.y, Math.sqrt( ( vector.x * vector.x ) + ( vector.z * vector.z ) ) );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tPolyhedronBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tPolyhedronBufferGeometry.prototype.constructor = PolyhedronBufferGeometry;\\n\\n\\t/**\\n\\t * @author timothypratley / https://github.com/timothypratley\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// TetrahedronGeometry\\n\\n\\tfunction TetrahedronGeometry( radius, detail ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'TetrahedronGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new TetrahedronBufferGeometry( radius, detail ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tTetrahedronGeometry.prototype = Object.create( Geometry.prototype );\\n\\tTetrahedronGeometry.prototype.constructor = TetrahedronGeometry;\\n\\n\\t// TetrahedronBufferGeometry\\n\\n\\tfunction TetrahedronBufferGeometry( radius, detail ) {\\n\\n\\t\\tvar vertices = [\\n\\t\\t\\t1, 1, 1, \\t- 1, - 1, 1, \\t- 1, 1, - 1, \\t1, - 1, - 1\\n\\t\\t];\\n\\n\\t\\tvar indices = [\\n\\t\\t\\t2, 1, 0, \\t0, 3, 2,\\t1, 3, 0,\\t2, 3, 1\\n\\t\\t];\\n\\n\\t\\tPolyhedronBufferGeometry.call( this, vertices, indices, radius, detail );\\n\\n\\t\\tthis.type = 'TetrahedronBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t}\\n\\n\\tTetrahedronBufferGeometry.prototype = Object.create( PolyhedronBufferGeometry.prototype );\\n\\tTetrahedronBufferGeometry.prototype.constructor = TetrahedronBufferGeometry;\\n\\n\\t/**\\n\\t * @author timothypratley / https://github.com/timothypratley\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// OctahedronGeometry\\n\\n\\tfunction OctahedronGeometry( radius, detail ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'OctahedronGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new OctahedronBufferGeometry( radius, detail ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tOctahedronGeometry.prototype = Object.create( Geometry.prototype );\\n\\tOctahedronGeometry.prototype.constructor = OctahedronGeometry;\\n\\n\\t// OctahedronBufferGeometry\\n\\n\\tfunction OctahedronBufferGeometry( radius, detail ) {\\n\\n\\t\\tvar vertices = [\\n\\t\\t\\t1, 0, 0, \\t- 1, 0, 0,\\t0, 1, 0,\\n\\t\\t\\t0, - 1, 0, \\t0, 0, 1,\\t0, 0, - 1\\n\\t\\t];\\n\\n\\t\\tvar indices = [\\n\\t\\t\\t0, 2, 4,\\t0, 4, 3,\\t0, 3, 5,\\n\\t\\t\\t0, 5, 2,\\t1, 2, 5,\\t1, 5, 3,\\n\\t\\t\\t1, 3, 4,\\t1, 4, 2\\n\\t\\t];\\n\\n\\t\\tPolyhedronBufferGeometry.call( this, vertices, indices, radius, detail );\\n\\n\\t\\tthis.type = 'OctahedronBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t}\\n\\n\\tOctahedronBufferGeometry.prototype = Object.create( PolyhedronBufferGeometry.prototype );\\n\\tOctahedronBufferGeometry.prototype.constructor = OctahedronBufferGeometry;\\n\\n\\t/**\\n\\t * @author timothypratley / https://github.com/timothypratley\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// IcosahedronGeometry\\n\\n\\tfunction IcosahedronGeometry( radius, detail ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'IcosahedronGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new IcosahedronBufferGeometry( radius, detail ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tIcosahedronGeometry.prototype = Object.create( Geometry.prototype );\\n\\tIcosahedronGeometry.prototype.constructor = IcosahedronGeometry;\\n\\n\\t// IcosahedronBufferGeometry\\n\\n\\tfunction IcosahedronBufferGeometry( radius, detail ) {\\n\\n\\t\\tvar t = ( 1 + Math.sqrt( 5 ) ) / 2;\\n\\n\\t\\tvar vertices = [\\n\\t\\t\\t- 1, t, 0, \\t1, t, 0, \\t- 1, - t, 0, \\t1, - t, 0,\\n\\t\\t\\t 0, - 1, t, \\t0, 1, t,\\t0, - 1, - t, \\t0, 1, - t,\\n\\t\\t\\t t, 0, - 1, \\tt, 0, 1, \\t- t, 0, - 1, \\t- t, 0, 1\\n\\t\\t];\\n\\n\\t\\tvar indices = [\\n\\t\\t\\t 0, 11, 5, \\t0, 5, 1, \\t0, 1, 7, \\t0, 7, 10, \\t0, 10, 11,\\n\\t\\t\\t 1, 5, 9, \\t5, 11, 4,\\t11, 10, 2,\\t10, 7, 6,\\t7, 1, 8,\\n\\t\\t\\t 3, 9, 4, \\t3, 4, 2,\\t3, 2, 6,\\t3, 6, 8,\\t3, 8, 9,\\n\\t\\t\\t 4, 9, 5, \\t2, 4, 11,\\t6, 2, 10,\\t8, 6, 7,\\t9, 8, 1\\n\\t\\t];\\n\\n\\t\\tPolyhedronBufferGeometry.call( this, vertices, indices, radius, detail );\\n\\n\\t\\tthis.type = 'IcosahedronBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t}\\n\\n\\tIcosahedronBufferGeometry.prototype = Object.create( PolyhedronBufferGeometry.prototype );\\n\\tIcosahedronBufferGeometry.prototype.constructor = IcosahedronBufferGeometry;\\n\\n\\t/**\\n\\t * @author Abe Pazos / https://hamoid.com\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// DodecahedronGeometry\\n\\n\\tfunction DodecahedronGeometry( radius, detail ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'DodecahedronGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new DodecahedronBufferGeometry( radius, detail ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tDodecahedronGeometry.prototype = Object.create( Geometry.prototype );\\n\\tDodecahedronGeometry.prototype.constructor = DodecahedronGeometry;\\n\\n\\t// DodecahedronBufferGeometry\\n\\n\\tfunction DodecahedronBufferGeometry( radius, detail ) {\\n\\n\\t\\tvar t = ( 1 + Math.sqrt( 5 ) ) / 2;\\n\\t\\tvar r = 1 / t;\\n\\n\\t\\tvar vertices = [\\n\\n\\t\\t\\t// (±1, ±1, ±1)\\n\\t\\t\\t- 1, - 1, - 1,\\t- 1, - 1, 1,\\n\\t\\t\\t- 1, 1, - 1, - 1, 1, 1,\\n\\t\\t\\t1, - 1, - 1, 1, - 1, 1,\\n\\t\\t\\t1, 1, - 1, 1, 1, 1,\\n\\n\\t\\t\\t// (0, ±1/φ, ±φ)\\n\\t\\t\\t 0, - r, - t, 0, - r, t,\\n\\t\\t\\t 0, r, - t, 0, r, t,\\n\\n\\t\\t\\t// (±1/φ, ±φ, 0)\\n\\t\\t\\t- r, - t, 0, - r, t, 0,\\n\\t\\t\\t r, - t, 0, r, t, 0,\\n\\n\\t\\t\\t// (±φ, 0, ±1/φ)\\n\\t\\t\\t- t, 0, - r, t, 0, - r,\\n\\t\\t\\t- t, 0, r, t, 0, r\\n\\t\\t];\\n\\n\\t\\tvar indices = [\\n\\t\\t\\t3, 11, 7, \\t3, 7, 15, \\t3, 15, 13,\\n\\t\\t\\t7, 19, 17, \\t7, 17, 6, \\t7, 6, 15,\\n\\t\\t\\t17, 4, 8, \\t17, 8, 10, \\t17, 10, 6,\\n\\t\\t\\t8, 0, 16, \\t8, 16, 2, \\t8, 2, 10,\\n\\t\\t\\t0, 12, 1, \\t0, 1, 18, \\t0, 18, 16,\\n\\t\\t\\t6, 10, 2, \\t6, 2, 13, \\t6, 13, 15,\\n\\t\\t\\t2, 16, 18, \\t2, 18, 3, \\t2, 3, 13,\\n\\t\\t\\t18, 1, 9, \\t18, 9, 11, \\t18, 11, 3,\\n\\t\\t\\t4, 14, 12, \\t4, 12, 0, \\t4, 0, 8,\\n\\t\\t\\t11, 9, 5, \\t11, 5, 19, \\t11, 19, 7,\\n\\t\\t\\t19, 5, 14, \\t19, 14, 4, \\t19, 4, 17,\\n\\t\\t\\t1, 12, 14, \\t1, 14, 5, \\t1, 5, 9\\n\\t\\t];\\n\\n\\t\\tPolyhedronBufferGeometry.call( this, vertices, indices, radius, detail );\\n\\n\\t\\tthis.type = 'DodecahedronBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tdetail: detail\\n\\t\\t};\\n\\n\\t}\\n\\n\\tDodecahedronBufferGeometry.prototype = Object.create( PolyhedronBufferGeometry.prototype );\\n\\tDodecahedronBufferGeometry.prototype.constructor = DodecahedronBufferGeometry;\\n\\n\\t/**\\n\\t * @author oosmoxiecode / https://github.com/oosmoxiecode\\n\\t * @author WestLangley / https://github.com/WestLangley\\n\\t * @author zz85 / https://github.com/zz85\\n\\t * @author miningold / https://github.com/miningold\\n\\t * @author jonobr1 / https://github.com/jonobr1\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t *\\n\\t */\\n\\n\\t// TubeGeometry\\n\\n\\tfunction TubeGeometry( path, tubularSegments, radius, radialSegments, closed, taper ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'TubeGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tpath: path,\\n\\t\\t\\ttubularSegments: tubularSegments,\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\tclosed: closed\\n\\t\\t};\\n\\n\\t\\tif ( taper !== undefined ) console.warn( 'THREE.TubeGeometry: taper has been removed.' );\\n\\n\\t\\tvar bufferGeometry = new TubeBufferGeometry( path, tubularSegments, radius, radialSegments, closed );\\n\\n\\t\\t// expose internals\\n\\n\\t\\tthis.tangents = bufferGeometry.tangents;\\n\\t\\tthis.normals = bufferGeometry.normals;\\n\\t\\tthis.binormals = bufferGeometry.binormals;\\n\\n\\t\\t// create geometry\\n\\n\\t\\tthis.fromBufferGeometry( bufferGeometry );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tTubeGeometry.prototype = Object.create( Geometry.prototype );\\n\\tTubeGeometry.prototype.constructor = TubeGeometry;\\n\\n\\t// TubeBufferGeometry\\n\\n\\tfunction TubeBufferGeometry( path, tubularSegments, radius, radialSegments, closed ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'TubeBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tpath: path,\\n\\t\\t\\ttubularSegments: tubularSegments,\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\tclosed: closed\\n\\t\\t};\\n\\n\\t\\ttubularSegments = tubularSegments || 64;\\n\\t\\tradius = radius || 1;\\n\\t\\tradialSegments = radialSegments || 8;\\n\\t\\tclosed = closed || false;\\n\\n\\t\\tvar frames = path.computeFrenetFrames( tubularSegments, closed );\\n\\n\\t\\t// expose internals\\n\\n\\t\\tthis.tangents = frames.tangents;\\n\\t\\tthis.normals = frames.normals;\\n\\t\\tthis.binormals = frames.binormals;\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar vertex = new Vector3();\\n\\t\\tvar normal = new Vector3();\\n\\t\\tvar uv = new Vector2();\\n\\t\\tvar P = new Vector3();\\n\\n\\t\\tvar i, j;\\n\\n\\t\\t// buffer\\n\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\t\\tvar indices = [];\\n\\n\\t\\t// create buffer data\\n\\n\\t\\tgenerateBufferData();\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t\\t// functions\\n\\n\\t\\tfunction generateBufferData() {\\n\\n\\t\\t\\tfor ( i = 0; i < tubularSegments; i ++ ) {\\n\\n\\t\\t\\t\\tgenerateSegment( i );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// if the geometry is not closed, generate the last row of vertices and normals\\n\\t\\t\\t// at the regular position on the given path\\n\\t\\t\\t//\\n\\t\\t\\t// if the geometry is closed, duplicate the first row of vertices and normals (uvs will differ)\\n\\n\\t\\t\\tgenerateSegment( ( closed === false ) ? tubularSegments : 0 );\\n\\n\\t\\t\\t// uvs are generated in a separate function.\\n\\t\\t\\t// this makes it easy compute correct values for closed geometries\\n\\n\\t\\t\\tgenerateUVs();\\n\\n\\t\\t\\t// finally create faces\\n\\n\\t\\t\\tgenerateIndices();\\n\\n\\t\\t}\\n\\n\\t\\tfunction generateSegment( i ) {\\n\\n\\t\\t\\t// we use getPointAt to sample evenly distributed points from the given path\\n\\n\\t\\t\\tP = path.getPointAt( i / tubularSegments, P );\\n\\n\\t\\t\\t// retrieve corresponding normal and binormal\\n\\n\\t\\t\\tvar N = frames.normals[ i ];\\n\\t\\t\\tvar B = frames.binormals[ i ];\\n\\n\\t\\t\\t// generate normals and vertices for the current segment\\n\\n\\t\\t\\tfor ( j = 0; j <= radialSegments; j ++ ) {\\n\\n\\t\\t\\t\\tvar v = j / radialSegments * Math.PI * 2;\\n\\n\\t\\t\\t\\tvar sin = Math.sin( v );\\n\\t\\t\\t\\tvar cos = - Math.cos( v );\\n\\n\\t\\t\\t\\t// normal\\n\\n\\t\\t\\t\\tnormal.x = ( cos * N.x + sin * B.x );\\n\\t\\t\\t\\tnormal.y = ( cos * N.y + sin * B.y );\\n\\t\\t\\t\\tnormal.z = ( cos * N.z + sin * B.z );\\n\\t\\t\\t\\tnormal.normalize();\\n\\n\\t\\t\\t\\tnormals.push( normal.x, normal.y, normal.z );\\n\\n\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\tvertex.x = P.x + radius * normal.x;\\n\\t\\t\\t\\tvertex.y = P.y + radius * normal.y;\\n\\t\\t\\t\\tvertex.z = P.z + radius * normal.z;\\n\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction generateIndices() {\\n\\n\\t\\t\\tfor ( j = 1; j <= tubularSegments; j ++ ) {\\n\\n\\t\\t\\t\\tfor ( i = 1; i <= radialSegments; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar a = ( radialSegments + 1 ) * ( j - 1 ) + ( i - 1 );\\n\\t\\t\\t\\t\\tvar b = ( radialSegments + 1 ) * j + ( i - 1 );\\n\\t\\t\\t\\t\\tvar c = ( radialSegments + 1 ) * j + i;\\n\\t\\t\\t\\t\\tvar d = ( radialSegments + 1 ) * ( j - 1 ) + i;\\n\\n\\t\\t\\t\\t\\t// faces\\n\\n\\t\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction generateUVs() {\\n\\n\\t\\t\\tfor ( i = 0; i <= tubularSegments; i ++ ) {\\n\\n\\t\\t\\t\\tfor ( j = 0; j <= radialSegments; j ++ ) {\\n\\n\\t\\t\\t\\t\\tuv.x = i / tubularSegments;\\n\\t\\t\\t\\t\\tuv.y = j / radialSegments;\\n\\n\\t\\t\\t\\t\\tuvs.push( uv.x, uv.y );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tTubeBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tTubeBufferGeometry.prototype.constructor = TubeBufferGeometry;\\n\\n\\t/**\\n\\t * @author oosmoxiecode\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t *\\n\\t * based on http://www.blackpawn.com/texts/pqtorus/\\n\\t */\\n\\n\\t// TorusKnotGeometry\\n\\n\\tfunction TorusKnotGeometry( radius, tube, tubularSegments, radialSegments, p, q, heightScale ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'TorusKnotGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\ttube: tube,\\n\\t\\t\\ttubularSegments: tubularSegments,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\tp: p,\\n\\t\\t\\tq: q\\n\\t\\t};\\n\\n\\t\\tif ( heightScale !== undefined ) console.warn( 'THREE.TorusKnotGeometry: heightScale has been deprecated. Use .scale( x, y, z ) instead.' );\\n\\n\\t\\tthis.fromBufferGeometry( new TorusKnotBufferGeometry( radius, tube, tubularSegments, radialSegments, p, q ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tTorusKnotGeometry.prototype = Object.create( Geometry.prototype );\\n\\tTorusKnotGeometry.prototype.constructor = TorusKnotGeometry;\\n\\n\\t// TorusKnotBufferGeometry\\n\\n\\tfunction TorusKnotBufferGeometry( radius, tube, tubularSegments, radialSegments, p, q ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'TorusKnotBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\ttube: tube,\\n\\t\\t\\ttubularSegments: tubularSegments,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\tp: p,\\n\\t\\t\\tq: q\\n\\t\\t};\\n\\n\\t\\tradius = radius || 1;\\n\\t\\ttube = tube || 0.4;\\n\\t\\ttubularSegments = Math.floor( tubularSegments ) || 64;\\n\\t\\tradialSegments = Math.floor( radialSegments ) || 8;\\n\\t\\tp = p || 2;\\n\\t\\tq = q || 3;\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar i, j;\\n\\n\\t\\tvar vertex = new Vector3();\\n\\t\\tvar normal = new Vector3();\\n\\n\\t\\tvar P1 = new Vector3();\\n\\t\\tvar P2 = new Vector3();\\n\\n\\t\\tvar B = new Vector3();\\n\\t\\tvar T = new Vector3();\\n\\t\\tvar N = new Vector3();\\n\\n\\t\\t// generate vertices, normals and uvs\\n\\n\\t\\tfor ( i = 0; i <= tubularSegments; ++ i ) {\\n\\n\\t\\t\\t// the radian \\\"u\\\" is used to calculate the position on the torus curve of the current tubular segement\\n\\n\\t\\t\\tvar u = i / tubularSegments * p * Math.PI * 2;\\n\\n\\t\\t\\t// now we calculate two points. P1 is our current position on the curve, P2 is a little farther ahead.\\n\\t\\t\\t// these points are used to create a special \\\"coordinate space\\\", which is necessary to calculate the correct vertex positions\\n\\n\\t\\t\\tcalculatePositionOnCurve( u, p, q, radius, P1 );\\n\\t\\t\\tcalculatePositionOnCurve( u + 0.01, p, q, radius, P2 );\\n\\n\\t\\t\\t// calculate orthonormal basis\\n\\n\\t\\t\\tT.subVectors( P2, P1 );\\n\\t\\t\\tN.addVectors( P2, P1 );\\n\\t\\t\\tB.crossVectors( T, N );\\n\\t\\t\\tN.crossVectors( B, T );\\n\\n\\t\\t\\t// normalize B, N. T can be ignored, we don't use it\\n\\n\\t\\t\\tB.normalize();\\n\\t\\t\\tN.normalize();\\n\\n\\t\\t\\tfor ( j = 0; j <= radialSegments; ++ j ) {\\n\\n\\t\\t\\t\\t// now calculate the vertices. they are nothing more than an extrusion of the torus curve.\\n\\t\\t\\t\\t// because we extrude a shape in the xy-plane, there is no need to calculate a z-value.\\n\\n\\t\\t\\t\\tvar v = j / radialSegments * Math.PI * 2;\\n\\t\\t\\t\\tvar cx = - tube * Math.cos( v );\\n\\t\\t\\t\\tvar cy = tube * Math.sin( v );\\n\\n\\t\\t\\t\\t// now calculate the final vertex position.\\n\\t\\t\\t\\t// first we orient the extrusion with our basis vectos, then we add it to the current position on the curve\\n\\n\\t\\t\\t\\tvertex.x = P1.x + ( cx * N.x + cy * B.x );\\n\\t\\t\\t\\tvertex.y = P1.y + ( cx * N.y + cy * B.y );\\n\\t\\t\\t\\tvertex.z = P1.z + ( cx * N.z + cy * B.z );\\n\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t// normal (P1 is always the center/origin of the extrusion, thus we can use it to calculate the normal)\\n\\n\\t\\t\\t\\tnormal.subVectors( vertex, P1 ).normalize();\\n\\n\\t\\t\\t\\tnormals.push( normal.x, normal.y, normal.z );\\n\\n\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\tuvs.push( i / tubularSegments );\\n\\t\\t\\t\\tuvs.push( j / radialSegments );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// generate indices\\n\\n\\t\\tfor ( j = 1; j <= tubularSegments; j ++ ) {\\n\\n\\t\\t\\tfor ( i = 1; i <= radialSegments; i ++ ) {\\n\\n\\t\\t\\t\\t// indices\\n\\n\\t\\t\\t\\tvar a = ( radialSegments + 1 ) * ( j - 1 ) + ( i - 1 );\\n\\t\\t\\t\\tvar b = ( radialSegments + 1 ) * j + ( i - 1 );\\n\\t\\t\\t\\tvar c = ( radialSegments + 1 ) * j + i;\\n\\t\\t\\t\\tvar d = ( radialSegments + 1 ) * ( j - 1 ) + i;\\n\\n\\t\\t\\t\\t// faces\\n\\n\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t\\t// this function calculates the current position on the torus curve\\n\\n\\t\\tfunction calculatePositionOnCurve( u, p, q, radius, position ) {\\n\\n\\t\\t\\tvar cu = Math.cos( u );\\n\\t\\t\\tvar su = Math.sin( u );\\n\\t\\t\\tvar quOverP = q / p * u;\\n\\t\\t\\tvar cs = Math.cos( quOverP );\\n\\n\\t\\t\\tposition.x = radius * ( 2 + cs ) * 0.5 * cu;\\n\\t\\t\\tposition.y = radius * ( 2 + cs ) * su * 0.5;\\n\\t\\t\\tposition.z = radius * Math.sin( quOverP ) * 0.5;\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tTorusKnotBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tTorusKnotBufferGeometry.prototype.constructor = TorusKnotBufferGeometry;\\n\\n\\t/**\\n\\t * @author oosmoxiecode\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// TorusGeometry\\n\\n\\tfunction TorusGeometry( radius, tube, radialSegments, tubularSegments, arc ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'TorusGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\ttube: tube,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\ttubularSegments: tubularSegments,\\n\\t\\t\\tarc: arc\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new TorusBufferGeometry( radius, tube, radialSegments, tubularSegments, arc ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tTorusGeometry.prototype = Object.create( Geometry.prototype );\\n\\tTorusGeometry.prototype.constructor = TorusGeometry;\\n\\n\\t// TorusBufferGeometry\\n\\n\\tfunction TorusBufferGeometry( radius, tube, radialSegments, tubularSegments, arc ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'TorusBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\ttube: tube,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\ttubularSegments: tubularSegments,\\n\\t\\t\\tarc: arc\\n\\t\\t};\\n\\n\\t\\tradius = radius || 1;\\n\\t\\ttube = tube || 0.4;\\n\\t\\tradialSegments = Math.floor( radialSegments ) || 8;\\n\\t\\ttubularSegments = Math.floor( tubularSegments ) || 6;\\n\\t\\tarc = arc || Math.PI * 2;\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar center = new Vector3();\\n\\t\\tvar vertex = new Vector3();\\n\\t\\tvar normal = new Vector3();\\n\\n\\t\\tvar j, i;\\n\\n\\t\\t// generate vertices, normals and uvs\\n\\n\\t\\tfor ( j = 0; j <= radialSegments; j ++ ) {\\n\\n\\t\\t\\tfor ( i = 0; i <= tubularSegments; i ++ ) {\\n\\n\\t\\t\\t\\tvar u = i / tubularSegments * arc;\\n\\t\\t\\t\\tvar v = j / radialSegments * Math.PI * 2;\\n\\n\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\tvertex.x = ( radius + tube * Math.cos( v ) ) * Math.cos( u );\\n\\t\\t\\t\\tvertex.y = ( radius + tube * Math.cos( v ) ) * Math.sin( u );\\n\\t\\t\\t\\tvertex.z = tube * Math.sin( v );\\n\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t// normal\\n\\n\\t\\t\\t\\tcenter.x = radius * Math.cos( u );\\n\\t\\t\\t\\tcenter.y = radius * Math.sin( u );\\n\\t\\t\\t\\tnormal.subVectors( vertex, center ).normalize();\\n\\n\\t\\t\\t\\tnormals.push( normal.x, normal.y, normal.z );\\n\\n\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\tuvs.push( i / tubularSegments );\\n\\t\\t\\t\\tuvs.push( j / radialSegments );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// generate indices\\n\\n\\t\\tfor ( j = 1; j <= radialSegments; j ++ ) {\\n\\n\\t\\t\\tfor ( i = 1; i <= tubularSegments; i ++ ) {\\n\\n\\t\\t\\t\\t// indices\\n\\n\\t\\t\\t\\tvar a = ( tubularSegments + 1 ) * j + i - 1;\\n\\t\\t\\t\\tvar b = ( tubularSegments + 1 ) * ( j - 1 ) + i - 1;\\n\\t\\t\\t\\tvar c = ( tubularSegments + 1 ) * ( j - 1 ) + i;\\n\\t\\t\\t\\tvar d = ( tubularSegments + 1 ) * j + i;\\n\\n\\t\\t\\t\\t// faces\\n\\n\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t}\\n\\n\\tTorusBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tTorusBufferGeometry.prototype.constructor = TorusBufferGeometry;\\n\\n\\t/**\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t * Port from https://github.com/mapbox/earcut (v2.1.2)\\n\\t */\\n\\n\\tvar Earcut = {\\n\\n\\t\\ttriangulate: function ( data, holeIndices, dim ) {\\n\\n\\t\\t\\tdim = dim || 2;\\n\\n\\t\\t\\tvar hasHoles = holeIndices && holeIndices.length,\\n\\t\\t\\t\\touterLen = hasHoles ? holeIndices[ 0 ] * dim : data.length,\\n\\t\\t\\t\\touterNode = linkedList( data, 0, outerLen, dim, true ),\\n\\t\\t\\t\\ttriangles = [];\\n\\n\\t\\t\\tif ( ! outerNode ) return triangles;\\n\\n\\t\\t\\tvar minX, minY, maxX, maxY, x, y, invSize;\\n\\n\\t\\t\\tif ( hasHoles ) outerNode = eliminateHoles( data, holeIndices, outerNode, dim );\\n\\n\\t\\t\\t// if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox\\n\\n\\t\\t\\tif ( data.length > 80 * dim ) {\\n\\n\\t\\t\\t\\tminX = maxX = data[ 0 ];\\n\\t\\t\\t\\tminY = maxY = data[ 1 ];\\n\\n\\t\\t\\t\\tfor ( var i = dim; i < outerLen; i += dim ) {\\n\\n\\t\\t\\t\\t\\tx = data[ i ];\\n\\t\\t\\t\\t\\ty = data[ i + 1 ];\\n\\t\\t\\t\\t\\tif ( x < minX ) minX = x;\\n\\t\\t\\t\\t\\tif ( y < minY ) minY = y;\\n\\t\\t\\t\\t\\tif ( x > maxX ) maxX = x;\\n\\t\\t\\t\\t\\tif ( y > maxY ) maxY = y;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// minX, minY and invSize are later used to transform coords into integers for z-order calculation\\n\\n\\t\\t\\t\\tinvSize = Math.max( maxX - minX, maxY - minY );\\n\\t\\t\\t\\tinvSize = invSize !== 0 ? 1 / invSize : 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tearcutLinked( outerNode, triangles, dim, minX, minY, invSize );\\n\\n\\t\\t\\treturn triangles;\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t// create a circular doubly linked list from polygon points in the specified winding order\\n\\n\\tfunction linkedList( data, start, end, dim, clockwise ) {\\n\\n\\t\\tvar i, last;\\n\\n\\t\\tif ( clockwise === ( signedArea( data, start, end, dim ) > 0 ) ) {\\n\\n\\t\\t\\tfor ( i = start; i < end; i += dim ) last = insertNode( i, data[ i ], data[ i + 1 ], last );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tfor ( i = end - dim; i >= start; i -= dim ) last = insertNode( i, data[ i ], data[ i + 1 ], last );\\n\\n\\t\\t}\\n\\n\\t\\tif ( last && equals( last, last.next ) ) {\\n\\n\\t\\t\\tremoveNode( last );\\n\\t\\t\\tlast = last.next;\\n\\n\\t\\t}\\n\\n\\t\\treturn last;\\n\\n\\t}\\n\\n\\t// eliminate colinear or duplicate points\\n\\n\\tfunction filterPoints( start, end ) {\\n\\n\\t\\tif ( ! start ) return start;\\n\\t\\tif ( ! end ) end = start;\\n\\n\\t\\tvar p = start, again;\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tagain = false;\\n\\n\\t\\t\\tif ( ! p.steiner && ( equals( p, p.next ) || area( p.prev, p, p.next ) === 0 ) ) {\\n\\n\\t\\t\\t\\tremoveNode( p );\\n\\t\\t\\t\\tp = end = p.prev;\\n\\t\\t\\t\\tif ( p === p.next ) break;\\n\\t\\t\\t\\tagain = true;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tp = p.next;\\n\\n\\t\\t\\t}\\n\\n\\t\\t} while ( again || p !== end );\\n\\n\\t\\treturn end;\\n\\n\\t}\\n\\n\\t// main ear slicing loop which triangulates a polygon (given as a linked list)\\n\\n\\tfunction earcutLinked( ear, triangles, dim, minX, minY, invSize, pass ) {\\n\\n\\t\\tif ( ! ear ) return;\\n\\n\\t\\t// interlink polygon nodes in z-order\\n\\n\\t\\tif ( ! pass && invSize ) indexCurve( ear, minX, minY, invSize );\\n\\n\\t\\tvar stop = ear, prev, next;\\n\\n\\t\\t// iterate through ears, slicing them one by one\\n\\n\\t\\twhile ( ear.prev !== ear.next ) {\\n\\n\\t\\t\\tprev = ear.prev;\\n\\t\\t\\tnext = ear.next;\\n\\n\\t\\t\\tif ( invSize ? isEarHashed( ear, minX, minY, invSize ) : isEar( ear ) ) {\\n\\n\\t\\t\\t\\t// cut off the triangle\\n\\t\\t\\t\\ttriangles.push( prev.i / dim );\\n\\t\\t\\t\\ttriangles.push( ear.i / dim );\\n\\t\\t\\t\\ttriangles.push( next.i / dim );\\n\\n\\t\\t\\t\\tremoveNode( ear );\\n\\n\\t\\t\\t\\t// skipping the next vertice leads to less sliver triangles\\n\\t\\t\\t\\tear = next.next;\\n\\t\\t\\t\\tstop = next.next;\\n\\n\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tear = next;\\n\\n\\t\\t\\t// if we looped through the whole remaining polygon and can't find any more ears\\n\\n\\t\\t\\tif ( ear === stop ) {\\n\\n\\t\\t\\t\\t// try filtering points and slicing again\\n\\n\\t\\t\\t\\tif ( ! pass ) {\\n\\n\\t\\t\\t\\t\\tearcutLinked( filterPoints( ear ), triangles, dim, minX, minY, invSize, 1 );\\n\\n\\t\\t\\t\\t\\t// if this didn't work, try curing all small self-intersections locally\\n\\n\\t\\t\\t\\t} else if ( pass === 1 ) {\\n\\n\\t\\t\\t\\t\\tear = cureLocalIntersections( ear, triangles, dim );\\n\\t\\t\\t\\t\\tearcutLinked( ear, triangles, dim, minX, minY, invSize, 2 );\\n\\n\\t\\t\\t\\t// as a last resort, try splitting the remaining polygon into two\\n\\n\\t\\t\\t\\t} else if ( pass === 2 ) {\\n\\n\\t\\t\\t\\t\\tsplitEarcut( ear, triangles, dim, minX, minY, invSize );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t// check whether a polygon node forms a valid ear with adjacent nodes\\n\\n\\tfunction isEar( ear ) {\\n\\n\\t\\tvar a = ear.prev,\\n\\t\\t\\tb = ear,\\n\\t\\t\\tc = ear.next;\\n\\n\\t\\tif ( area( a, b, c ) >= 0 ) return false; // reflex, can't be an ear\\n\\n\\t\\t// now make sure we don't have other points inside the potential ear\\n\\t\\tvar p = ear.next.next;\\n\\n\\t\\twhile ( p !== ear.prev ) {\\n\\n\\t\\t\\tif ( pointInTriangle( a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y ) && area( p.prev, p, p.next ) >= 0 ) {\\n\\n\\t\\t\\t\\treturn false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tp = p.next;\\n\\n\\t\\t}\\n\\n\\t\\treturn true;\\n\\n\\t}\\n\\n\\tfunction isEarHashed( ear, minX, minY, invSize ) {\\n\\n\\t\\tvar a = ear.prev,\\n\\t\\t\\tb = ear,\\n\\t\\t\\tc = ear.next;\\n\\n\\t\\tif ( area( a, b, c ) >= 0 ) return false; // reflex, can't be an ear\\n\\n\\t\\t// triangle bbox; min & max are calculated like this for speed\\n\\n\\t\\tvar minTX = a.x < b.x ? ( a.x < c.x ? a.x : c.x ) : ( b.x < c.x ? b.x : c.x ),\\n\\t\\t\\tminTY = a.y < b.y ? ( a.y < c.y ? a.y : c.y ) : ( b.y < c.y ? b.y : c.y ),\\n\\t\\t\\tmaxTX = a.x > b.x ? ( a.x > c.x ? a.x : c.x ) : ( b.x > c.x ? b.x : c.x ),\\n\\t\\t\\tmaxTY = a.y > b.y ? ( a.y > c.y ? a.y : c.y ) : ( b.y > c.y ? b.y : c.y );\\n\\n\\t\\t// z-order range for the current triangle bbox;\\n\\n\\t\\tvar minZ = zOrder( minTX, minTY, minX, minY, invSize ),\\n\\t\\t\\tmaxZ = zOrder( maxTX, maxTY, minX, minY, invSize );\\n\\n\\t\\t// first look for points inside the triangle in increasing z-order\\n\\n\\t\\tvar p = ear.nextZ;\\n\\n\\t\\twhile ( p && p.z <= maxZ ) {\\n\\n\\t\\t\\tif ( p !== ear.prev && p !== ear.next &&\\n\\t\\t\\t\\t\\tpointInTriangle( a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y ) &&\\n\\t\\t\\t\\t\\tarea( p.prev, p, p.next ) >= 0 ) return false;\\n\\t\\t\\tp = p.nextZ;\\n\\n\\t\\t}\\n\\n\\t\\t// then look for points in decreasing z-order\\n\\n\\t\\tp = ear.prevZ;\\n\\n\\t\\twhile ( p && p.z >= minZ ) {\\n\\n\\t\\t\\tif ( p !== ear.prev && p !== ear.next &&\\n\\t\\t\\t\\t\\tpointInTriangle( a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y ) &&\\n\\t\\t\\t\\t\\tarea( p.prev, p, p.next ) >= 0 ) return false;\\n\\n\\t\\t\\tp = p.prevZ;\\n\\n\\t\\t}\\n\\n\\t\\treturn true;\\n\\n\\t}\\n\\n\\t// go through all polygon nodes and cure small local self-intersections\\n\\n\\tfunction cureLocalIntersections( start, triangles, dim ) {\\n\\n\\t\\tvar p = start;\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tvar a = p.prev, b = p.next.next;\\n\\n\\t\\t\\tif ( ! equals( a, b ) && intersects( a, p, p.next, b ) && locallyInside( a, b ) && locallyInside( b, a ) ) {\\n\\n\\t\\t\\t\\ttriangles.push( a.i / dim );\\n\\t\\t\\t\\ttriangles.push( p.i / dim );\\n\\t\\t\\t\\ttriangles.push( b.i / dim );\\n\\n\\t\\t\\t\\t// remove two nodes involved\\n\\n\\t\\t\\t\\tremoveNode( p );\\n\\t\\t\\t\\tremoveNode( p.next );\\n\\n\\t\\t\\t\\tp = start = b;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tp = p.next;\\n\\n\\t\\t} while ( p !== start );\\n\\n\\t\\treturn p;\\n\\n\\t}\\n\\n\\t// try splitting polygon into two and triangulate them independently\\n\\n\\tfunction splitEarcut( start, triangles, dim, minX, minY, invSize ) {\\n\\n\\t\\t// look for a valid diagonal that divides the polygon into two\\n\\n\\t\\tvar a = start;\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tvar b = a.next.next;\\n\\n\\t\\t\\twhile ( b !== a.prev ) {\\n\\n\\t\\t\\t\\tif ( a.i !== b.i && isValidDiagonal( a, b ) ) {\\n\\n\\t\\t\\t\\t\\t// split the polygon in two by the diagonal\\n\\n\\t\\t\\t\\t\\tvar c = splitPolygon( a, b );\\n\\n\\t\\t\\t\\t\\t// filter colinear points around the cuts\\n\\n\\t\\t\\t\\t\\ta = filterPoints( a, a.next );\\n\\t\\t\\t\\t\\tc = filterPoints( c, c.next );\\n\\n\\t\\t\\t\\t\\t// run earcut on each half\\n\\n\\t\\t\\t\\t\\tearcutLinked( a, triangles, dim, minX, minY, invSize );\\n\\t\\t\\t\\t\\tearcutLinked( c, triangles, dim, minX, minY, invSize );\\n\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tb = b.next;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\ta = a.next;\\n\\n\\t\\t} while ( a !== start );\\n\\n\\t}\\n\\n\\t// link every hole into the outer loop, producing a single-ring polygon without holes\\n\\n\\tfunction eliminateHoles( data, holeIndices, outerNode, dim ) {\\n\\n\\t\\tvar queue = [], i, len, start, end, list;\\n\\n\\t\\tfor ( i = 0, len = holeIndices.length; i < len; i ++ ) {\\n\\n\\t\\t\\tstart = holeIndices[ i ] * dim;\\n\\t\\t\\tend = i < len - 1 ? holeIndices[ i + 1 ] * dim : data.length;\\n\\t\\t\\tlist = linkedList( data, start, end, dim, false );\\n\\t\\t\\tif ( list === list.next ) list.steiner = true;\\n\\t\\t\\tqueue.push( getLeftmost( list ) );\\n\\n\\t\\t}\\n\\n\\t\\tqueue.sort( compareX );\\n\\n\\t\\t// process holes from left to right\\n\\n\\t\\tfor ( i = 0; i < queue.length; i ++ ) {\\n\\n\\t\\t\\teliminateHole( queue[ i ], outerNode );\\n\\t\\t\\touterNode = filterPoints( outerNode, outerNode.next );\\n\\n\\t\\t}\\n\\n\\t\\treturn outerNode;\\n\\n\\t}\\n\\n\\tfunction compareX( a, b ) {\\n\\n\\t\\treturn a.x - b.x;\\n\\n\\t}\\n\\n\\t// find a bridge between vertices that connects hole with an outer ring and and link it\\n\\n\\tfunction eliminateHole( hole, outerNode ) {\\n\\n\\t\\touterNode = findHoleBridge( hole, outerNode );\\n\\n\\t\\tif ( outerNode ) {\\n\\n\\t\\t\\tvar b = splitPolygon( outerNode, hole );\\n\\n\\t\\t\\tfilterPoints( b, b.next );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\t// David Eberly's algorithm for finding a bridge between hole and outer polygon\\n\\n\\tfunction findHoleBridge( hole, outerNode ) {\\n\\n\\t\\tvar p = outerNode,\\n\\t\\t\\thx = hole.x,\\n\\t\\t\\thy = hole.y,\\n\\t\\t\\tqx = - Infinity,\\n\\t\\t\\tm;\\n\\n\\t\\t// find a segment intersected by a ray from the hole's leftmost point to the left;\\n\\t\\t// segment's endpoint with lesser x will be potential connection point\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tif ( hy <= p.y && hy >= p.next.y && p.next.y !== p.y ) {\\n\\n\\t\\t\\t\\tvar x = p.x + ( hy - p.y ) * ( p.next.x - p.x ) / ( p.next.y - p.y );\\n\\n\\t\\t\\t\\tif ( x <= hx && x > qx ) {\\n\\n\\t\\t\\t\\t\\tqx = x;\\n\\n\\t\\t\\t\\t\\tif ( x === hx ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( hy === p.y ) return p;\\n\\t\\t\\t\\t\\t\\tif ( hy === p.next.y ) return p.next;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tm = p.x < p.next.x ? p : p.next;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tp = p.next;\\n\\n\\t\\t} while ( p !== outerNode );\\n\\n\\t\\tif ( ! m ) return null;\\n\\n\\t\\tif ( hx === qx ) return m.prev; // hole touches outer segment; pick lower endpoint\\n\\n\\t\\t// look for points inside the triangle of hole point, segment intersection and endpoint;\\n\\t\\t// if there are no points found, we have a valid connection;\\n\\t\\t// otherwise choose the point of the minimum angle with the ray as connection point\\n\\n\\t\\tvar stop = m,\\n\\t\\t\\tmx = m.x,\\n\\t\\t\\tmy = m.y,\\n\\t\\t\\ttanMin = Infinity,\\n\\t\\t\\ttan;\\n\\n\\t\\tp = m.next;\\n\\n\\t\\twhile ( p !== stop ) {\\n\\n\\t\\t\\tif ( hx >= p.x && p.x >= mx && hx !== p.x &&\\n\\t\\t\\t\\t\\t\\t\\tpointInTriangle( hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p.x, p.y ) ) {\\n\\n\\t\\t\\t\\ttan = Math.abs( hy - p.y ) / ( hx - p.x ); // tangential\\n\\n\\t\\t\\t\\tif ( ( tan < tanMin || ( tan === tanMin && p.x > m.x ) ) && locallyInside( p, hole ) ) {\\n\\n\\t\\t\\t\\t\\tm = p;\\n\\t\\t\\t\\t\\ttanMin = tan;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tp = p.next;\\n\\n\\t\\t}\\n\\n\\t\\treturn m;\\n\\n\\t}\\n\\n\\t// interlink polygon nodes in z-order\\n\\n\\tfunction indexCurve( start, minX, minY, invSize ) {\\n\\n\\t\\tvar p = start;\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tif ( p.z === null ) p.z = zOrder( p.x, p.y, minX, minY, invSize );\\n\\t\\t\\tp.prevZ = p.prev;\\n\\t\\t\\tp.nextZ = p.next;\\n\\t\\t\\tp = p.next;\\n\\n\\t\\t} while ( p !== start );\\n\\n\\t\\tp.prevZ.nextZ = null;\\n\\t\\tp.prevZ = null;\\n\\n\\t\\tsortLinked( p );\\n\\n\\t}\\n\\n\\t// Simon Tatham's linked list merge sort algorithm\\n\\t// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html\\n\\n\\tfunction sortLinked( list ) {\\n\\n\\t\\tvar i, p, q, e, tail, numMerges, pSize, qSize, inSize = 1;\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tp = list;\\n\\t\\t\\tlist = null;\\n\\t\\t\\ttail = null;\\n\\t\\t\\tnumMerges = 0;\\n\\n\\t\\t\\twhile ( p ) {\\n\\n\\t\\t\\t\\tnumMerges ++;\\n\\t\\t\\t\\tq = p;\\n\\t\\t\\t\\tpSize = 0;\\n\\n\\t\\t\\t\\tfor ( i = 0; i < inSize; i ++ ) {\\n\\n\\t\\t\\t\\t\\tpSize ++;\\n\\t\\t\\t\\t\\tq = q.nextZ;\\n\\t\\t\\t\\t\\tif ( ! q ) break;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tqSize = inSize;\\n\\n\\t\\t\\t\\twhile ( pSize > 0 || ( qSize > 0 && q ) ) {\\n\\n\\t\\t\\t\\t\\tif ( pSize !== 0 && ( qSize === 0 || ! q || p.z <= q.z ) ) {\\n\\n\\t\\t\\t\\t\\t\\te = p;\\n\\t\\t\\t\\t\\t\\tp = p.nextZ;\\n\\t\\t\\t\\t\\t\\tpSize --;\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\te = q;\\n\\t\\t\\t\\t\\t\\tq = q.nextZ;\\n\\t\\t\\t\\t\\t\\tqSize --;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( tail ) tail.nextZ = e;\\n\\t\\t\\t\\t\\telse list = e;\\n\\n\\t\\t\\t\\t\\te.prevZ = tail;\\n\\t\\t\\t\\t\\ttail = e;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tp = q;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\ttail.nextZ = null;\\n\\t\\t\\tinSize *= 2;\\n\\n\\t\\t} while ( numMerges > 1 );\\n\\n\\t\\treturn list;\\n\\n\\t}\\n\\n\\t// z-order of a point given coords and inverse of the longer side of data bbox\\n\\n\\tfunction zOrder( x, y, minX, minY, invSize ) {\\n\\n\\t\\t// coords are transformed into non-negative 15-bit integer range\\n\\n\\t\\tx = 32767 * ( x - minX ) * invSize;\\n\\t\\ty = 32767 * ( y - minY ) * invSize;\\n\\n\\t\\tx = ( x | ( x << 8 ) ) & 0x00FF00FF;\\n\\t\\tx = ( x | ( x << 4 ) ) & 0x0F0F0F0F;\\n\\t\\tx = ( x | ( x << 2 ) ) & 0x33333333;\\n\\t\\tx = ( x | ( x << 1 ) ) & 0x55555555;\\n\\n\\t\\ty = ( y | ( y << 8 ) ) & 0x00FF00FF;\\n\\t\\ty = ( y | ( y << 4 ) ) & 0x0F0F0F0F;\\n\\t\\ty = ( y | ( y << 2 ) ) & 0x33333333;\\n\\t\\ty = ( y | ( y << 1 ) ) & 0x55555555;\\n\\n\\t\\treturn x | ( y << 1 );\\n\\n\\t}\\n\\n\\t// find the leftmost node of a polygon ring\\n\\n\\tfunction getLeftmost( start ) {\\n\\n\\t\\tvar p = start, leftmost = start;\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tif ( p.x < leftmost.x ) leftmost = p;\\n\\t\\t\\tp = p.next;\\n\\n\\t\\t} while ( p !== start );\\n\\n\\t\\treturn leftmost;\\n\\n\\t}\\n\\n\\t// check if a point lies within a convex triangle\\n\\n\\tfunction pointInTriangle( ax, ay, bx, by, cx, cy, px, py ) {\\n\\n\\t\\treturn ( cx - px ) * ( ay - py ) - ( ax - px ) * ( cy - py ) >= 0 &&\\n\\t\\t ( ax - px ) * ( by - py ) - ( bx - px ) * ( ay - py ) >= 0 &&\\n\\t\\t ( bx - px ) * ( cy - py ) - ( cx - px ) * ( by - py ) >= 0;\\n\\n\\t}\\n\\n\\t// check if a diagonal between two polygon nodes is valid (lies in polygon interior)\\n\\n\\tfunction isValidDiagonal( a, b ) {\\n\\n\\t\\treturn a.next.i !== b.i && a.prev.i !== b.i && ! intersectsPolygon( a, b ) &&\\n\\t\\t\\tlocallyInside( a, b ) && locallyInside( b, a ) && middleInside( a, b );\\n\\n\\t}\\n\\n\\t// signed area of a triangle\\n\\n\\tfunction area( p, q, r ) {\\n\\n\\t\\treturn ( q.y - p.y ) * ( r.x - q.x ) - ( q.x - p.x ) * ( r.y - q.y );\\n\\n\\t}\\n\\n\\t// check if two points are equal\\n\\n\\tfunction equals( p1, p2 ) {\\n\\n\\t\\treturn p1.x === p2.x && p1.y === p2.y;\\n\\n\\t}\\n\\n\\t// check if two segments intersect\\n\\n\\tfunction intersects( p1, q1, p2, q2 ) {\\n\\n\\t\\tif ( ( equals( p1, q1 ) && equals( p2, q2 ) ) ||\\n\\t\\t\\t\\t( equals( p1, q2 ) && equals( p2, q1 ) ) ) return true;\\n\\n\\t\\treturn area( p1, q1, p2 ) > 0 !== area( p1, q1, q2 ) > 0 &&\\n\\t\\t\\t\\t\\t area( p2, q2, p1 ) > 0 !== area( p2, q2, q1 ) > 0;\\n\\n\\t}\\n\\n\\t// check if a polygon diagonal intersects any polygon segments\\n\\n\\tfunction intersectsPolygon( a, b ) {\\n\\n\\t\\tvar p = a;\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tif ( p.i !== a.i && p.next.i !== a.i && p.i !== b.i && p.next.i !== b.i &&\\n\\t\\t\\t\\t\\t\\t\\tintersects( p, p.next, a, b ) ) {\\n\\n\\t\\t\\t\\treturn true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tp = p.next;\\n\\n\\t\\t} while ( p !== a );\\n\\n\\t\\treturn false;\\n\\n\\t}\\n\\n\\t// check if a polygon diagonal is locally inside the polygon\\n\\n\\tfunction locallyInside( a, b ) {\\n\\n\\t\\treturn area( a.prev, a, a.next ) < 0 ?\\n\\t\\t\\tarea( a, b, a.next ) >= 0 && area( a, a.prev, b ) >= 0 :\\n\\t\\t\\tarea( a, b, a.prev ) < 0 || area( a, a.next, b ) < 0;\\n\\n\\t}\\n\\n\\t// check if the middle point of a polygon diagonal is inside the polygon\\n\\n\\tfunction middleInside( a, b ) {\\n\\n\\t\\tvar p = a,\\n\\t\\t\\tinside = false,\\n\\t\\t\\tpx = ( a.x + b.x ) / 2,\\n\\t\\t\\tpy = ( a.y + b.y ) / 2;\\n\\n\\t\\tdo {\\n\\n\\t\\t\\tif ( ( ( p.y > py ) !== ( p.next.y > py ) ) && p.next.y !== p.y &&\\n\\t\\t\\t\\t\\t\\t\\t( px < ( p.next.x - p.x ) * ( py - p.y ) / ( p.next.y - p.y ) + p.x ) ) {\\n\\n\\t\\t\\t\\tinside = ! inside;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tp = p.next;\\n\\n\\t\\t} while ( p !== a );\\n\\n\\t\\treturn inside;\\n\\n\\t}\\n\\n\\t// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits polygon into two;\\n\\t// if one belongs to the outer ring and another to a hole, it merges it into a single ring\\n\\n\\tfunction splitPolygon( a, b ) {\\n\\n\\t\\tvar a2 = new Node( a.i, a.x, a.y ),\\n\\t\\t\\tb2 = new Node( b.i, b.x, b.y ),\\n\\t\\t\\tan = a.next,\\n\\t\\t\\tbp = b.prev;\\n\\n\\t\\ta.next = b;\\n\\t\\tb.prev = a;\\n\\n\\t\\ta2.next = an;\\n\\t\\tan.prev = a2;\\n\\n\\t\\tb2.next = a2;\\n\\t\\ta2.prev = b2;\\n\\n\\t\\tbp.next = b2;\\n\\t\\tb2.prev = bp;\\n\\n\\t\\treturn b2;\\n\\n\\t}\\n\\n\\t// create a node and optionally link it with previous one (in a circular doubly linked list)\\n\\n\\tfunction insertNode( i, x, y, last ) {\\n\\n\\t\\tvar p = new Node( i, x, y );\\n\\n\\t\\tif ( ! last ) {\\n\\n\\t\\t\\tp.prev = p;\\n\\t\\t\\tp.next = p;\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tp.next = last.next;\\n\\t\\t\\tp.prev = last;\\n\\t\\t\\tlast.next.prev = p;\\n\\t\\t\\tlast.next = p;\\n\\n\\t\\t}\\n\\n\\t\\treturn p;\\n\\n\\t}\\n\\n\\tfunction removeNode( p ) {\\n\\n\\t\\tp.next.prev = p.prev;\\n\\t\\tp.prev.next = p.next;\\n\\n\\t\\tif ( p.prevZ ) p.prevZ.nextZ = p.nextZ;\\n\\t\\tif ( p.nextZ ) p.nextZ.prevZ = p.prevZ;\\n\\n\\t}\\n\\n\\tfunction Node( i, x, y ) {\\n\\n\\t\\t// vertice index in coordinates array\\n\\t\\tthis.i = i;\\n\\n\\t\\t// vertex coordinates\\n\\t\\tthis.x = x;\\n\\t\\tthis.y = y;\\n\\n\\t\\t// previous and next vertice nodes in a polygon ring\\n\\t\\tthis.prev = null;\\n\\t\\tthis.next = null;\\n\\n\\t\\t// z-order curve value\\n\\t\\tthis.z = null;\\n\\n\\t\\t// previous and next nodes in z-order\\n\\t\\tthis.prevZ = null;\\n\\t\\tthis.nextZ = null;\\n\\n\\t\\t// indicates whether this is a steiner point\\n\\t\\tthis.steiner = false;\\n\\n\\t}\\n\\n\\tfunction signedArea( data, start, end, dim ) {\\n\\n\\t\\tvar sum = 0;\\n\\n\\t\\tfor ( var i = start, j = end - dim; i < end; i += dim ) {\\n\\n\\t\\t\\tsum += ( data[ j ] - data[ i ] ) * ( data[ i + 1 ] + data[ j + 1 ] );\\n\\t\\t\\tj = i;\\n\\n\\t\\t}\\n\\n\\t\\treturn sum;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t */\\n\\n\\tvar ShapeUtils = {\\n\\n\\t\\t// calculate area of the contour polygon\\n\\n\\t\\tarea: function ( contour ) {\\n\\n\\t\\t\\tvar n = contour.length;\\n\\t\\t\\tvar a = 0.0;\\n\\n\\t\\t\\tfor ( var p = n - 1, q = 0; q < n; p = q ++ ) {\\n\\n\\t\\t\\t\\ta += contour[ p ].x * contour[ q ].y - contour[ q ].x * contour[ p ].y;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn a * 0.5;\\n\\n\\t\\t},\\n\\n\\t\\tisClockWise: function ( pts ) {\\n\\n\\t\\t\\treturn ShapeUtils.area( pts ) < 0;\\n\\n\\t\\t},\\n\\n\\t\\ttriangulateShape: function ( contour, holes ) {\\n\\n\\t\\t\\tfunction removeDupEndPts( points ) {\\n\\n\\t\\t\\t\\tvar l = points.length;\\n\\n\\t\\t\\t\\tif ( l > 2 && points[ l - 1 ].equals( points[ 0 ] ) ) {\\n\\n\\t\\t\\t\\t\\tpoints.pop();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction addContour( vertices, contour ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < contour.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvertices.push( contour[ i ].x );\\n\\t\\t\\t\\t\\tvertices.push( contour[ i ].y );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar vertices = []; // flat array of vertices like [ x0,y0, x1,y1, x2,y2, ... ]\\n\\t\\t\\tvar holeIndices = []; // array of hole indices\\n\\t\\t\\tvar faces = []; // final array of vertex indices like [ [ a,b,d ], [ b,c,d ] ]\\n\\n\\t\\t\\tremoveDupEndPts( contour );\\n\\t\\t\\taddContour( vertices, contour );\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar holeIndex = contour.length;\\n\\t\\t\\tholes.forEach( removeDupEndPts );\\n\\n\\t\\t\\tfor ( i = 0; i < holes.length; i ++ ) {\\n\\n\\t\\t\\t\\tholeIndices.push( holeIndex );\\n\\t\\t\\t\\tholeIndex += holes[ i ].length;\\n\\t\\t\\t\\taddContour( vertices, holes[ i ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar triangles = Earcut.triangulate( vertices, holeIndices );\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tfor ( var i = 0; i < triangles.length; i += 3 ) {\\n\\n\\t\\t\\t\\tfaces.push( triangles.slice( i, i + 3 ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn faces;\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t *\\n\\t * Creates extruded geometry from a path shape.\\n\\t *\\n\\t * parameters = {\\n\\t *\\n\\t *  curveSegments: <int>, // number of points on the curves\\n\\t *  steps: <int>, // number of points for z-side extrusions / used for subdividing segments of extrude spline too\\n\\t *  amount: <int>, // Depth to extrude the shape\\n\\t *\\n\\t *  bevelEnabled: <bool>, // turn on bevel\\n\\t *  bevelThickness: <float>, // how deep into the original shape bevel goes\\n\\t *  bevelSize: <float>, // how far from shape outline is bevel\\n\\t *  bevelSegments: <int>, // number of bevel layers\\n\\t *\\n\\t *  extrudePath: <THREE.Curve> // curve to extrude shape along\\n\\t *  frames: <Object> // containing arrays of tangents, normals, binormals\\n\\t *\\n\\t *  UVGenerator: <Object> // object that provides UV generator functions\\n\\t *\\n\\t * }\\n\\t */\\n\\n\\t// ExtrudeGeometry\\n\\n\\tfunction ExtrudeGeometry( shapes, options ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'ExtrudeGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tshapes: shapes,\\n\\t\\t\\toptions: options\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new ExtrudeBufferGeometry( shapes, options ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tExtrudeGeometry.prototype = Object.create( Geometry.prototype );\\n\\tExtrudeGeometry.prototype.constructor = ExtrudeGeometry;\\n\\n\\t// ExtrudeBufferGeometry\\n\\n\\tfunction ExtrudeBufferGeometry( shapes, options ) {\\n\\n\\t\\tif ( typeof ( shapes ) === \\\"undefined\\\" ) {\\n\\n\\t\\t\\treturn;\\n\\n\\t\\t}\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'ExtrudeBufferGeometry';\\n\\n\\t\\tshapes = Array.isArray( shapes ) ? shapes : [ shapes ];\\n\\n\\t\\tthis.addShapeList( shapes, options );\\n\\n\\t\\tthis.computeVertexNormals();\\n\\n\\t\\t// can't really use automatic vertex normals\\n\\t\\t// as then front and back sides get smoothed too\\n\\t\\t// should do separate smoothing just for sides\\n\\n\\t\\t//this.computeVertexNormals();\\n\\n\\t\\t//console.log( \\\"took\\\", ( Date.now() - startTime ) );\\n\\n\\t}\\n\\n\\tExtrudeBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tExtrudeBufferGeometry.prototype.constructor = ExtrudeBufferGeometry;\\n\\n\\tExtrudeBufferGeometry.prototype.getArrays = function () {\\n\\n\\t\\tvar positionAttribute = this.getAttribute( \\\"position\\\" );\\n\\t\\tvar verticesArray = positionAttribute ? Array.prototype.slice.call( positionAttribute.array ) : [];\\n\\n\\t\\tvar uvAttribute = this.getAttribute( \\\"uv\\\" );\\n\\t\\tvar uvArray = uvAttribute ? Array.prototype.slice.call( uvAttribute.array ) : [];\\n\\n\\t\\tvar IndexAttribute = this.index;\\n\\t\\tvar indicesArray = IndexAttribute ? Array.prototype.slice.call( IndexAttribute.array ) : [];\\n\\n\\t\\treturn {\\n\\t\\t\\tposition: verticesArray,\\n\\t\\t\\tuv: uvArray,\\n\\t\\t\\tindex: indicesArray\\n\\t\\t};\\n\\n\\t};\\n\\n\\tExtrudeBufferGeometry.prototype.addShapeList = function ( shapes, options ) {\\n\\n\\t\\tvar sl = shapes.length;\\n\\t\\toptions.arrays = this.getArrays();\\n\\n\\t\\tfor ( var s = 0; s < sl; s ++ ) {\\n\\n\\t\\t\\tvar shape = shapes[ s ];\\n\\t\\t\\tthis.addShape( shape, options );\\n\\n\\t\\t}\\n\\n\\t\\tthis.setIndex( options.arrays.index );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( options.arrays.position, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( options.arrays.uv, 2 ) );\\n\\n\\t};\\n\\n\\tExtrudeBufferGeometry.prototype.addShape = function ( shape, options ) {\\n\\n\\t\\tvar arrays = options.arrays ? options.arrays : this.getArrays();\\n\\t\\tvar verticesArray = arrays.position;\\n\\t\\tvar indicesArray = arrays.index;\\n\\t\\tvar uvArray = arrays.uv;\\n\\n\\t\\tvar placeholder = [];\\n\\n\\n\\t\\tvar amount = options.amount !== undefined ? options.amount : 100;\\n\\n\\t\\tvar bevelThickness = options.bevelThickness !== undefined ? options.bevelThickness : 6; // 10\\n\\t\\tvar bevelSize = options.bevelSize !== undefined ? options.bevelSize : bevelThickness - 2; // 8\\n\\t\\tvar bevelSegments = options.bevelSegments !== undefined ? options.bevelSegments : 3;\\n\\n\\t\\tvar bevelEnabled = options.bevelEnabled !== undefined ? options.bevelEnabled : true; // false\\n\\n\\t\\tvar curveSegments = options.curveSegments !== undefined ? options.curveSegments : 12;\\n\\n\\t\\tvar steps = options.steps !== undefined ? options.steps : 1;\\n\\n\\t\\tvar extrudePath = options.extrudePath;\\n\\t\\tvar extrudePts, extrudeByPath = false;\\n\\n\\t\\t// Use default WorldUVGenerator if no UV generators are specified.\\n\\t\\tvar uvgen = options.UVGenerator !== undefined ? options.UVGenerator : ExtrudeGeometry.WorldUVGenerator;\\n\\n\\t\\tvar splineTube, binormal, normal, position2;\\n\\t\\tif ( extrudePath ) {\\n\\n\\t\\t\\textrudePts = extrudePath.getSpacedPoints( steps );\\n\\n\\t\\t\\textrudeByPath = true;\\n\\t\\t\\tbevelEnabled = false; // bevels not supported for path extrusion\\n\\n\\t\\t\\t// SETUP TNB variables\\n\\n\\t\\t\\t// TODO1 - have a .isClosed in spline?\\n\\n\\t\\t\\tsplineTube = options.frames !== undefined ? options.frames : extrudePath.computeFrenetFrames( steps, false );\\n\\n\\t\\t\\t// console.log(splineTube, 'splineTube', splineTube.normals.length, 'steps', steps, 'extrudePts', extrudePts.length);\\n\\n\\t\\t\\tbinormal = new Vector3();\\n\\t\\t\\tnormal = new Vector3();\\n\\t\\t\\tposition2 = new Vector3();\\n\\n\\t\\t}\\n\\n\\t\\t// Safeguards if bevels are not enabled\\n\\n\\t\\tif ( ! bevelEnabled ) {\\n\\n\\t\\t\\tbevelSegments = 0;\\n\\t\\t\\tbevelThickness = 0;\\n\\t\\t\\tbevelSize = 0;\\n\\n\\t\\t}\\n\\n\\t\\t// Variables initialization\\n\\n\\t\\tvar ahole, h, hl; // looping of holes\\n\\t\\tvar scope = this;\\n\\n\\t\\tvar shapePoints = shape.extractPoints( curveSegments );\\n\\n\\t\\tvar vertices = shapePoints.shape;\\n\\t\\tvar holes = shapePoints.holes;\\n\\n\\t\\tvar reverse = ! ShapeUtils.isClockWise( vertices );\\n\\n\\t\\tif ( reverse ) {\\n\\n\\t\\t\\tvertices = vertices.reverse();\\n\\n\\t\\t\\t// Maybe we should also check if holes are in the opposite direction, just to be safe ...\\n\\n\\t\\t\\tfor ( h = 0, hl = holes.length; h < hl; h ++ ) {\\n\\n\\t\\t\\t\\tahole = holes[ h ];\\n\\n\\t\\t\\t\\tif ( ShapeUtils.isClockWise( ahole ) ) {\\n\\n\\t\\t\\t\\t\\tholes[ h ] = ahole.reverse();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\n\\t\\tvar faces = ShapeUtils.triangulateShape( vertices, holes );\\n\\n\\t\\t/* Vertices */\\n\\n\\t\\tvar contour = vertices; // vertices has all points but contour has only points of circumference\\n\\n\\t\\tfor ( h = 0, hl = holes.length; h < hl; h ++ ) {\\n\\n\\t\\t\\tahole = holes[ h ];\\n\\n\\t\\t\\tvertices = vertices.concat( ahole );\\n\\n\\t\\t}\\n\\n\\n\\t\\tfunction scalePt2( pt, vec, size ) {\\n\\n\\t\\t\\tif ( ! vec ) console.error( \\\"THREE.ExtrudeGeometry: vec does not exist\\\" );\\n\\n\\t\\t\\treturn vec.clone().multiplyScalar( size ).add( pt );\\n\\n\\t\\t}\\n\\n\\t\\tvar b, bs, t, z,\\n\\t\\t\\tvert, vlen = vertices.length,\\n\\t\\t\\tface, flen = faces.length;\\n\\n\\n\\t\\t// Find directions for point movement\\n\\n\\n\\t\\tfunction getBevelVec( inPt, inPrev, inNext ) {\\n\\n\\t\\t\\t// computes for inPt the corresponding point inPt' on a new contour\\n\\t\\t\\t//   shifted by 1 unit (length of normalized vector) to the left\\n\\t\\t\\t// if we walk along contour clockwise, this new contour is outside the old one\\n\\t\\t\\t//\\n\\t\\t\\t// inPt' is the intersection of the two lines parallel to the two\\n\\t\\t\\t//  adjacent edges of inPt at a distance of 1 unit on the left side.\\n\\n\\t\\t\\tvar v_trans_x, v_trans_y, shrink_by; // resulting translation vector for inPt\\n\\n\\t\\t\\t// good reading for geometry algorithms (here: line-line intersection)\\n\\t\\t\\t// http://geomalgorithms.com/a05-_intersect-1.html\\n\\n\\t\\t\\tvar v_prev_x = inPt.x - inPrev.x,\\n\\t\\t\\t\\tv_prev_y = inPt.y - inPrev.y;\\n\\t\\t\\tvar v_next_x = inNext.x - inPt.x,\\n\\t\\t\\t\\tv_next_y = inNext.y - inPt.y;\\n\\n\\t\\t\\tvar v_prev_lensq = ( v_prev_x * v_prev_x + v_prev_y * v_prev_y );\\n\\n\\t\\t\\t// check for collinear edges\\n\\t\\t\\tvar collinear0 = ( v_prev_x * v_next_y - v_prev_y * v_next_x );\\n\\n\\t\\t\\tif ( Math.abs( collinear0 ) > Number.EPSILON ) {\\n\\n\\t\\t\\t\\t// not collinear\\n\\n\\t\\t\\t\\t// length of vectors for normalizing\\n\\n\\t\\t\\t\\tvar v_prev_len = Math.sqrt( v_prev_lensq );\\n\\t\\t\\t\\tvar v_next_len = Math.sqrt( v_next_x * v_next_x + v_next_y * v_next_y );\\n\\n\\t\\t\\t\\t// shift adjacent points by unit vectors to the left\\n\\n\\t\\t\\t\\tvar ptPrevShift_x = ( inPrev.x - v_prev_y / v_prev_len );\\n\\t\\t\\t\\tvar ptPrevShift_y = ( inPrev.y + v_prev_x / v_prev_len );\\n\\n\\t\\t\\t\\tvar ptNextShift_x = ( inNext.x - v_next_y / v_next_len );\\n\\t\\t\\t\\tvar ptNextShift_y = ( inNext.y + v_next_x / v_next_len );\\n\\n\\t\\t\\t\\t// scaling factor for v_prev to intersection point\\n\\n\\t\\t\\t\\tvar sf = ( ( ptNextShift_x - ptPrevShift_x ) * v_next_y -\\n\\t\\t\\t\\t\\t\\t( ptNextShift_y - ptPrevShift_y ) * v_next_x ) /\\n\\t\\t\\t\\t\\t( v_prev_x * v_next_y - v_prev_y * v_next_x );\\n\\n\\t\\t\\t\\t// vector from inPt to intersection point\\n\\n\\t\\t\\t\\tv_trans_x = ( ptPrevShift_x + v_prev_x * sf - inPt.x );\\n\\t\\t\\t\\tv_trans_y = ( ptPrevShift_y + v_prev_y * sf - inPt.y );\\n\\n\\t\\t\\t\\t// Don't normalize!, otherwise sharp corners become ugly\\n\\t\\t\\t\\t//  but prevent crazy spikes\\n\\t\\t\\t\\tvar v_trans_lensq = ( v_trans_x * v_trans_x + v_trans_y * v_trans_y );\\n\\t\\t\\t\\tif ( v_trans_lensq <= 2 ) {\\n\\n\\t\\t\\t\\t\\treturn new Vector2( v_trans_x, v_trans_y );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tshrink_by = Math.sqrt( v_trans_lensq / 2 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// handle special case of collinear edges\\n\\n\\t\\t\\t\\tvar direction_eq = false; // assumes: opposite\\n\\t\\t\\t\\tif ( v_prev_x > Number.EPSILON ) {\\n\\n\\t\\t\\t\\t\\tif ( v_next_x > Number.EPSILON ) {\\n\\n\\t\\t\\t\\t\\t\\tdirection_eq = true;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tif ( v_prev_x < - Number.EPSILON ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( v_next_x < - Number.EPSILON ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tdirection_eq = true;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tif ( Math.sign( v_prev_y ) === Math.sign( v_next_y ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tdirection_eq = true;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( direction_eq ) {\\n\\n\\t\\t\\t\\t\\t// console.log(\\\"Warning: lines are a straight sequence\\\");\\n\\t\\t\\t\\t\\tv_trans_x = - v_prev_y;\\n\\t\\t\\t\\t\\tv_trans_y = v_prev_x;\\n\\t\\t\\t\\t\\tshrink_by = Math.sqrt( v_prev_lensq );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// console.log(\\\"Warning: lines are a straight spike\\\");\\n\\t\\t\\t\\t\\tv_trans_x = v_prev_x;\\n\\t\\t\\t\\t\\tv_trans_y = v_prev_y;\\n\\t\\t\\t\\t\\tshrink_by = Math.sqrt( v_prev_lensq / 2 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn new Vector2( v_trans_x / shrink_by, v_trans_y / shrink_by );\\n\\n\\t\\t}\\n\\n\\n\\t\\tvar contourMovements = [];\\n\\n\\t\\tfor ( var i = 0, il = contour.length, j = il - 1, k = i + 1; i < il; i ++, j ++, k ++ ) {\\n\\n\\t\\t\\tif ( j === il ) j = 0;\\n\\t\\t\\tif ( k === il ) k = 0;\\n\\n\\t\\t\\t//  (j)---(i)---(k)\\n\\t\\t\\t// console.log('i,j,k', i, j , k)\\n\\n\\t\\t\\tcontourMovements[ i ] = getBevelVec( contour[ i ], contour[ j ], contour[ k ] );\\n\\n\\t\\t}\\n\\n\\t\\tvar holesMovements = [],\\n\\t\\t\\toneHoleMovements, verticesMovements = contourMovements.concat();\\n\\n\\t\\tfor ( h = 0, hl = holes.length; h < hl; h ++ ) {\\n\\n\\t\\t\\tahole = holes[ h ];\\n\\n\\t\\t\\toneHoleMovements = [];\\n\\n\\t\\t\\tfor ( i = 0, il = ahole.length, j = il - 1, k = i + 1; i < il; i ++, j ++, k ++ ) {\\n\\n\\t\\t\\t\\tif ( j === il ) j = 0;\\n\\t\\t\\t\\tif ( k === il ) k = 0;\\n\\n\\t\\t\\t\\t//  (j)---(i)---(k)\\n\\t\\t\\t\\toneHoleMovements[ i ] = getBevelVec( ahole[ i ], ahole[ j ], ahole[ k ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tholesMovements.push( oneHoleMovements );\\n\\t\\t\\tverticesMovements = verticesMovements.concat( oneHoleMovements );\\n\\n\\t\\t}\\n\\n\\n\\t\\t// Loop bevelSegments, 1 for the front, 1 for the back\\n\\n\\t\\tfor ( b = 0; b < bevelSegments; b ++ ) {\\n\\n\\t\\t\\t//for ( b = bevelSegments; b > 0; b -- ) {\\n\\n\\t\\t\\tt = b / bevelSegments;\\n\\t\\t\\tz = bevelThickness * Math.cos( t * Math.PI / 2 );\\n\\t\\t\\tbs = bevelSize * Math.sin( t * Math.PI / 2 );\\n\\n\\t\\t\\t// contract shape\\n\\n\\t\\t\\tfor ( i = 0, il = contour.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvert = scalePt2( contour[ i ], contourMovements[ i ], bs );\\n\\n\\t\\t\\t\\tv( vert.x, vert.y, - z );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// expand holes\\n\\n\\t\\t\\tfor ( h = 0, hl = holes.length; h < hl; h ++ ) {\\n\\n\\t\\t\\t\\tahole = holes[ h ];\\n\\t\\t\\t\\toneHoleMovements = holesMovements[ h ];\\n\\n\\t\\t\\t\\tfor ( i = 0, il = ahole.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs );\\n\\n\\t\\t\\t\\t\\tv( vert.x, vert.y, - z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tbs = bevelSize;\\n\\n\\t\\t// Back facing vertices\\n\\n\\t\\tfor ( i = 0; i < vlen; i ++ ) {\\n\\n\\t\\t\\tvert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ];\\n\\n\\t\\t\\tif ( ! extrudeByPath ) {\\n\\n\\t\\t\\t\\tv( vert.x, vert.y, 0 );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// v( vert.x, vert.y + extrudePts[ 0 ].y, extrudePts[ 0 ].x );\\n\\n\\t\\t\\t\\tnormal.copy( splineTube.normals[ 0 ] ).multiplyScalar( vert.x );\\n\\t\\t\\t\\tbinormal.copy( splineTube.binormals[ 0 ] ).multiplyScalar( vert.y );\\n\\n\\t\\t\\t\\tposition2.copy( extrudePts[ 0 ] ).add( normal ).add( binormal );\\n\\n\\t\\t\\t\\tv( position2.x, position2.y, position2.z );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// Add stepped vertices...\\n\\t\\t// Including front facing vertices\\n\\n\\t\\tvar s;\\n\\n\\t\\tfor ( s = 1; s <= steps; s ++ ) {\\n\\n\\t\\t\\tfor ( i = 0; i < vlen; i ++ ) {\\n\\n\\t\\t\\t\\tvert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ];\\n\\n\\t\\t\\t\\tif ( ! extrudeByPath ) {\\n\\n\\t\\t\\t\\t\\tv( vert.x, vert.y, amount / steps * s );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// v( vert.x, vert.y + extrudePts[ s - 1 ].y, extrudePts[ s - 1 ].x );\\n\\n\\t\\t\\t\\t\\tnormal.copy( splineTube.normals[ s ] ).multiplyScalar( vert.x );\\n\\t\\t\\t\\t\\tbinormal.copy( splineTube.binormals[ s ] ).multiplyScalar( vert.y );\\n\\n\\t\\t\\t\\t\\tposition2.copy( extrudePts[ s ] ).add( normal ).add( binormal );\\n\\n\\t\\t\\t\\t\\tv( position2.x, position2.y, position2.z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\n\\t\\t// Add bevel segments planes\\n\\n\\t\\t//for ( b = 1; b <= bevelSegments; b ++ ) {\\n\\t\\tfor ( b = bevelSegments - 1; b >= 0; b -- ) {\\n\\n\\t\\t\\tt = b / bevelSegments;\\n\\t\\t\\tz = bevelThickness * Math.cos( t * Math.PI / 2 );\\n\\t\\t\\tbs = bevelSize * Math.sin( t * Math.PI / 2 );\\n\\n\\t\\t\\t// contract shape\\n\\n\\t\\t\\tfor ( i = 0, il = contour.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvert = scalePt2( contour[ i ], contourMovements[ i ], bs );\\n\\t\\t\\t\\tv( vert.x, vert.y, amount + z );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// expand holes\\n\\n\\t\\t\\tfor ( h = 0, hl = holes.length; h < hl; h ++ ) {\\n\\n\\t\\t\\t\\tahole = holes[ h ];\\n\\t\\t\\t\\toneHoleMovements = holesMovements[ h ];\\n\\n\\t\\t\\t\\tfor ( i = 0, il = ahole.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs );\\n\\n\\t\\t\\t\\t\\tif ( ! extrudeByPath ) {\\n\\n\\t\\t\\t\\t\\t\\tv( vert.x, vert.y, amount + z );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tv( vert.x, vert.y + extrudePts[ steps - 1 ].y, extrudePts[ steps - 1 ].x + z );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t/* Faces */\\n\\n\\t\\t// Top and bottom faces\\n\\n\\t\\tbuildLidFaces();\\n\\n\\t\\t// Sides faces\\n\\n\\t\\tbuildSideFaces();\\n\\n\\n\\t\\t/////  Internal functions\\n\\n\\t\\tfunction buildLidFaces() {\\n\\n\\t\\t\\tvar start = verticesArray.length / 3;\\n\\n\\t\\t\\tif ( bevelEnabled ) {\\n\\n\\t\\t\\t\\tvar layer = 0; // steps + 1\\n\\t\\t\\t\\tvar offset = vlen * layer;\\n\\n\\t\\t\\t\\t// Bottom faces\\n\\n\\t\\t\\t\\tfor ( i = 0; i < flen; i ++ ) {\\n\\n\\t\\t\\t\\t\\tface = faces[ i ];\\n\\t\\t\\t\\t\\tf3( face[ 2 ] + offset, face[ 1 ] + offset, face[ 0 ] + offset );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tlayer = steps + bevelSegments * 2;\\n\\t\\t\\t\\toffset = vlen * layer;\\n\\n\\t\\t\\t\\t// Top faces\\n\\n\\t\\t\\t\\tfor ( i = 0; i < flen; i ++ ) {\\n\\n\\t\\t\\t\\t\\tface = faces[ i ];\\n\\t\\t\\t\\t\\tf3( face[ 0 ] + offset, face[ 1 ] + offset, face[ 2 ] + offset );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// Bottom faces\\n\\n\\t\\t\\t\\tfor ( i = 0; i < flen; i ++ ) {\\n\\n\\t\\t\\t\\t\\tface = faces[ i ];\\n\\t\\t\\t\\t\\tf3( face[ 2 ], face[ 1 ], face[ 0 ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// Top faces\\n\\n\\t\\t\\t\\tfor ( i = 0; i < flen; i ++ ) {\\n\\n\\t\\t\\t\\t\\tface = faces[ i ];\\n\\t\\t\\t\\t\\tf3( face[ 0 ] + vlen * steps, face[ 1 ] + vlen * steps, face[ 2 ] + vlen * steps );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tscope.addGroup( start, verticesArray.length / 3 - start, options.material !== undefined ? options.material : 0 );\\n\\n\\t\\t}\\n\\n\\t\\t// Create faces for the z-sides of the shape\\n\\n\\t\\tfunction buildSideFaces() {\\n\\n\\t\\t\\tvar start = verticesArray.length / 3;\\n\\t\\t\\tvar layeroffset = 0;\\n\\t\\t\\tsidewalls( contour, layeroffset );\\n\\t\\t\\tlayeroffset += contour.length;\\n\\n\\t\\t\\tfor ( h = 0, hl = holes.length; h < hl; h ++ ) {\\n\\n\\t\\t\\t\\tahole = holes[ h ];\\n\\t\\t\\t\\tsidewalls( ahole, layeroffset );\\n\\n\\t\\t\\t\\t//, true\\n\\t\\t\\t\\tlayeroffset += ahole.length;\\n\\n\\t\\t\\t}\\n\\n\\n\\t\\t\\tscope.addGroup( start, verticesArray.length / 3 - start, options.extrudeMaterial !== undefined ? options.extrudeMaterial : 1 );\\n\\n\\n\\t\\t}\\n\\n\\t\\tfunction sidewalls( contour, layeroffset ) {\\n\\n\\t\\t\\tvar j, k;\\n\\t\\t\\ti = contour.length;\\n\\n\\t\\t\\twhile ( -- i >= 0 ) {\\n\\n\\t\\t\\t\\tj = i;\\n\\t\\t\\t\\tk = i - 1;\\n\\t\\t\\t\\tif ( k < 0 ) k = contour.length - 1;\\n\\n\\t\\t\\t\\t//console.log('b', i,j, i-1, k,vertices.length);\\n\\n\\t\\t\\t\\tvar s = 0,\\n\\t\\t\\t\\t\\tsl = steps + bevelSegments * 2;\\n\\n\\t\\t\\t\\tfor ( s = 0; s < sl; s ++ ) {\\n\\n\\t\\t\\t\\t\\tvar slen1 = vlen * s;\\n\\t\\t\\t\\t\\tvar slen2 = vlen * ( s + 1 );\\n\\n\\t\\t\\t\\t\\tvar a = layeroffset + j + slen1,\\n\\t\\t\\t\\t\\t\\tb = layeroffset + k + slen1,\\n\\t\\t\\t\\t\\t\\tc = layeroffset + k + slen2,\\n\\t\\t\\t\\t\\t\\td = layeroffset + j + slen2;\\n\\n\\t\\t\\t\\t\\tf4( a, b, c, d );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tfunction v( x, y, z ) {\\n\\n\\t\\t\\tplaceholder.push( x );\\n\\t\\t\\tplaceholder.push( y );\\n\\t\\t\\tplaceholder.push( z );\\n\\n\\t\\t}\\n\\n\\n\\t\\tfunction f3( a, b, c ) {\\n\\n\\t\\t\\taddVertex( a );\\n\\t\\t\\taddVertex( b );\\n\\t\\t\\taddVertex( c );\\n\\n\\t\\t\\tvar nextIndex = verticesArray.length / 3;\\n\\t\\t\\tvar uvs = uvgen.generateTopUV( scope, verticesArray, nextIndex - 3, nextIndex - 2, nextIndex - 1 );\\n\\n\\t\\t\\taddUV( uvs[ 0 ] );\\n\\t\\t\\taddUV( uvs[ 1 ] );\\n\\t\\t\\taddUV( uvs[ 2 ] );\\n\\n\\t\\t}\\n\\n\\t\\tfunction f4( a, b, c, d ) {\\n\\n\\t\\t\\taddVertex( a );\\n\\t\\t\\taddVertex( b );\\n\\t\\t\\taddVertex( d );\\n\\n\\t\\t\\taddVertex( b );\\n\\t\\t\\taddVertex( c );\\n\\t\\t\\taddVertex( d );\\n\\n\\n\\t\\t\\tvar nextIndex = verticesArray.length / 3;\\n\\t\\t\\tvar uvs = uvgen.generateSideWallUV( scope, verticesArray, nextIndex - 6, nextIndex - 3, nextIndex - 2, nextIndex - 1 );\\n\\n\\t\\t\\taddUV( uvs[ 0 ] );\\n\\t\\t\\taddUV( uvs[ 1 ] );\\n\\t\\t\\taddUV( uvs[ 3 ] );\\n\\n\\t\\t\\taddUV( uvs[ 1 ] );\\n\\t\\t\\taddUV( uvs[ 2 ] );\\n\\t\\t\\taddUV( uvs[ 3 ] );\\n\\n\\t\\t}\\n\\n\\t\\tfunction addVertex( index ) {\\n\\n\\t\\t\\tindicesArray.push( verticesArray.length / 3 );\\n\\t\\t\\tverticesArray.push( placeholder[ index * 3 + 0 ] );\\n\\t\\t\\tverticesArray.push( placeholder[ index * 3 + 1 ] );\\n\\t\\t\\tverticesArray.push( placeholder[ index * 3 + 2 ] );\\n\\n\\t\\t}\\n\\n\\n\\t\\tfunction addUV( vector2 ) {\\n\\n\\t\\t\\tuvArray.push( vector2.x );\\n\\t\\t\\tuvArray.push( vector2.y );\\n\\n\\t\\t}\\n\\n\\t\\tif ( ! options.arrays ) {\\n\\n\\t\\t\\tthis.setIndex( indicesArray );\\n\\t\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( verticesArray, 3 ) );\\n\\t\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvArray, 2 ) );\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\tExtrudeGeometry.WorldUVGenerator = {\\n\\n\\t\\tgenerateTopUV: function ( geometry, vertices, indexA, indexB, indexC ) {\\n\\n\\t\\t\\tvar a_x = vertices[ indexA * 3 ];\\n\\t\\t\\tvar a_y = vertices[ indexA * 3 + 1 ];\\n\\t\\t\\tvar b_x = vertices[ indexB * 3 ];\\n\\t\\t\\tvar b_y = vertices[ indexB * 3 + 1 ];\\n\\t\\t\\tvar c_x = vertices[ indexC * 3 ];\\n\\t\\t\\tvar c_y = vertices[ indexC * 3 + 1 ];\\n\\n\\t\\t\\treturn [\\n\\t\\t\\t\\tnew Vector2( a_x, a_y ),\\n\\t\\t\\t\\tnew Vector2( b_x, b_y ),\\n\\t\\t\\t\\tnew Vector2( c_x, c_y )\\n\\t\\t\\t];\\n\\n\\t\\t},\\n\\n\\t\\tgenerateSideWallUV: function ( geometry, vertices, indexA, indexB, indexC, indexD ) {\\n\\n\\t\\t\\tvar a_x = vertices[ indexA * 3 ];\\n\\t\\t\\tvar a_y = vertices[ indexA * 3 + 1 ];\\n\\t\\t\\tvar a_z = vertices[ indexA * 3 + 2 ];\\n\\t\\t\\tvar b_x = vertices[ indexB * 3 ];\\n\\t\\t\\tvar b_y = vertices[ indexB * 3 + 1 ];\\n\\t\\t\\tvar b_z = vertices[ indexB * 3 + 2 ];\\n\\t\\t\\tvar c_x = vertices[ indexC * 3 ];\\n\\t\\t\\tvar c_y = vertices[ indexC * 3 + 1 ];\\n\\t\\t\\tvar c_z = vertices[ indexC * 3 + 2 ];\\n\\t\\t\\tvar d_x = vertices[ indexD * 3 ];\\n\\t\\t\\tvar d_y = vertices[ indexD * 3 + 1 ];\\n\\t\\t\\tvar d_z = vertices[ indexD * 3 + 2 ];\\n\\n\\t\\t\\tif ( Math.abs( a_y - b_y ) < 0.01 ) {\\n\\n\\t\\t\\t\\treturn [\\n\\t\\t\\t\\t\\tnew Vector2( a_x, 1 - a_z ),\\n\\t\\t\\t\\t\\tnew Vector2( b_x, 1 - b_z ),\\n\\t\\t\\t\\t\\tnew Vector2( c_x, 1 - c_z ),\\n\\t\\t\\t\\t\\tnew Vector2( d_x, 1 - d_z )\\n\\t\\t\\t\\t];\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\treturn [\\n\\t\\t\\t\\t\\tnew Vector2( a_y, 1 - a_z ),\\n\\t\\t\\t\\t\\tnew Vector2( b_y, 1 - b_z ),\\n\\t\\t\\t\\t\\tnew Vector2( c_y, 1 - c_z ),\\n\\t\\t\\t\\t\\tnew Vector2( d_y, 1 - d_z )\\n\\t\\t\\t\\t];\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\t};\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * Text = 3D Text\\n\\t *\\n\\t * parameters = {\\n\\t *  font: <THREE.Font>, // font\\n\\t *\\n\\t *  size: <float>, // size of the text\\n\\t *  height: <float>, // thickness to extrude text\\n\\t *  curveSegments: <int>, // number of points on the curves\\n\\t *\\n\\t *  bevelEnabled: <bool>, // turn on bevel\\n\\t *  bevelThickness: <float>, // how deep into text bevel goes\\n\\t *  bevelSize: <float> // how far from text outline is bevel\\n\\t * }\\n\\t */\\n\\n\\t// TextGeometry\\n\\n\\tfunction TextGeometry( text, parameters ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'TextGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\ttext: text,\\n\\t\\t\\tparameters: parameters\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new TextBufferGeometry( text, parameters ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tTextGeometry.prototype = Object.create( Geometry.prototype );\\n\\tTextGeometry.prototype.constructor = TextGeometry;\\n\\n\\t// TextBufferGeometry\\n\\n\\tfunction TextBufferGeometry( text, parameters ) {\\n\\n\\t\\tparameters = parameters || {};\\n\\n\\t\\tvar font = parameters.font;\\n\\n\\t\\tif ( ! ( font && font.isFont ) ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.TextGeometry: font parameter is not an instance of THREE.Font.' );\\n\\t\\t\\treturn new Geometry();\\n\\n\\t\\t}\\n\\n\\t\\tvar shapes = font.generateShapes( text, parameters.size, parameters.curveSegments );\\n\\n\\t\\t// translate parameters to ExtrudeGeometry API\\n\\n\\t\\tparameters.amount = parameters.height !== undefined ? parameters.height : 50;\\n\\n\\t\\t// defaults\\n\\n\\t\\tif ( parameters.bevelThickness === undefined ) parameters.bevelThickness = 10;\\n\\t\\tif ( parameters.bevelSize === undefined ) parameters.bevelSize = 8;\\n\\t\\tif ( parameters.bevelEnabled === undefined ) parameters.bevelEnabled = false;\\n\\n\\t\\tExtrudeBufferGeometry.call( this, shapes, parameters );\\n\\n\\t\\tthis.type = 'TextBufferGeometry';\\n\\n\\t}\\n\\n\\tTextBufferGeometry.prototype = Object.create( ExtrudeBufferGeometry.prototype );\\n\\tTextBufferGeometry.prototype.constructor = TextBufferGeometry;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author benaadams / https://twitter.com/ben_a_adams\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// SphereGeometry\\n\\n\\tfunction SphereGeometry( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'SphereGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\twidthSegments: widthSegments,\\n\\t\\t\\theightSegments: heightSegments,\\n\\t\\t\\tphiStart: phiStart,\\n\\t\\t\\tphiLength: phiLength,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new SphereBufferGeometry( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tSphereGeometry.prototype = Object.create( Geometry.prototype );\\n\\tSphereGeometry.prototype.constructor = SphereGeometry;\\n\\n\\t// SphereBufferGeometry\\n\\n\\tfunction SphereBufferGeometry( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'SphereBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\twidthSegments: widthSegments,\\n\\t\\t\\theightSegments: heightSegments,\\n\\t\\t\\tphiStart: phiStart,\\n\\t\\t\\tphiLength: phiLength,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t\\tradius = radius || 1;\\n\\n\\t\\twidthSegments = Math.max( 3, Math.floor( widthSegments ) || 8 );\\n\\t\\theightSegments = Math.max( 2, Math.floor( heightSegments ) || 6 );\\n\\n\\t\\tphiStart = phiStart !== undefined ? phiStart : 0;\\n\\t\\tphiLength = phiLength !== undefined ? phiLength : Math.PI * 2;\\n\\n\\t\\tthetaStart = thetaStart !== undefined ? thetaStart : 0;\\n\\t\\tthetaLength = thetaLength !== undefined ? thetaLength : Math.PI;\\n\\n\\t\\tvar thetaEnd = thetaStart + thetaLength;\\n\\n\\t\\tvar ix, iy;\\n\\n\\t\\tvar index = 0;\\n\\t\\tvar grid = [];\\n\\n\\t\\tvar vertex = new Vector3();\\n\\t\\tvar normal = new Vector3();\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// generate vertices, normals and uvs\\n\\n\\t\\tfor ( iy = 0; iy <= heightSegments; iy ++ ) {\\n\\n\\t\\t\\tvar verticesRow = [];\\n\\n\\t\\t\\tvar v = iy / heightSegments;\\n\\n\\t\\t\\tfor ( ix = 0; ix <= widthSegments; ix ++ ) {\\n\\n\\t\\t\\t\\tvar u = ix / widthSegments;\\n\\n\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\tvertex.x = - radius * Math.cos( phiStart + u * phiLength ) * Math.sin( thetaStart + v * thetaLength );\\n\\t\\t\\t\\tvertex.y = radius * Math.cos( thetaStart + v * thetaLength );\\n\\t\\t\\t\\tvertex.z = radius * Math.sin( phiStart + u * phiLength ) * Math.sin( thetaStart + v * thetaLength );\\n\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t// normal\\n\\n\\t\\t\\t\\tnormal.set( vertex.x, vertex.y, vertex.z ).normalize();\\n\\t\\t\\t\\tnormals.push( normal.x, normal.y, normal.z );\\n\\n\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\tuvs.push( u, 1 - v );\\n\\n\\t\\t\\t\\tverticesRow.push( index ++ );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tgrid.push( verticesRow );\\n\\n\\t\\t}\\n\\n\\t\\t// indices\\n\\n\\t\\tfor ( iy = 0; iy < heightSegments; iy ++ ) {\\n\\n\\t\\t\\tfor ( ix = 0; ix < widthSegments; ix ++ ) {\\n\\n\\t\\t\\t\\tvar a = grid[ iy ][ ix + 1 ];\\n\\t\\t\\t\\tvar b = grid[ iy ][ ix ];\\n\\t\\t\\t\\tvar c = grid[ iy + 1 ][ ix ];\\n\\t\\t\\t\\tvar d = grid[ iy + 1 ][ ix + 1 ];\\n\\n\\t\\t\\t\\tif ( iy !== 0 || thetaStart > 0 ) indices.push( a, b, d );\\n\\t\\t\\t\\tif ( iy !== heightSegments - 1 || thetaEnd < Math.PI ) indices.push( b, c, d );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t}\\n\\n\\tSphereBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tSphereBufferGeometry.prototype.constructor = SphereBufferGeometry;\\n\\n\\t/**\\n\\t * @author Kaleb Murphy\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// RingGeometry\\n\\n\\tfunction RingGeometry( innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'RingGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tinnerRadius: innerRadius,\\n\\t\\t\\touterRadius: outerRadius,\\n\\t\\t\\tthetaSegments: thetaSegments,\\n\\t\\t\\tphiSegments: phiSegments,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new RingBufferGeometry( innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tRingGeometry.prototype = Object.create( Geometry.prototype );\\n\\tRingGeometry.prototype.constructor = RingGeometry;\\n\\n\\t// RingBufferGeometry\\n\\n\\tfunction RingBufferGeometry( innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'RingBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tinnerRadius: innerRadius,\\n\\t\\t\\touterRadius: outerRadius,\\n\\t\\t\\tthetaSegments: thetaSegments,\\n\\t\\t\\tphiSegments: phiSegments,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t\\tinnerRadius = innerRadius || 0.5;\\n\\t\\touterRadius = outerRadius || 1;\\n\\n\\t\\tthetaStart = thetaStart !== undefined ? thetaStart : 0;\\n\\t\\tthetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2;\\n\\n\\t\\tthetaSegments = thetaSegments !== undefined ? Math.max( 3, thetaSegments ) : 8;\\n\\t\\tphiSegments = phiSegments !== undefined ? Math.max( 1, phiSegments ) : 1;\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// some helper variables\\n\\n\\t\\tvar segment;\\n\\t\\tvar radius = innerRadius;\\n\\t\\tvar radiusStep = ( ( outerRadius - innerRadius ) / phiSegments );\\n\\t\\tvar vertex = new Vector3();\\n\\t\\tvar uv = new Vector2();\\n\\t\\tvar j, i;\\n\\n\\t\\t// generate vertices, normals and uvs\\n\\n\\t\\tfor ( j = 0; j <= phiSegments; j ++ ) {\\n\\n\\t\\t\\tfor ( i = 0; i <= thetaSegments; i ++ ) {\\n\\n\\t\\t\\t\\t// values are generate from the inside of the ring to the outside\\n\\n\\t\\t\\t\\tsegment = thetaStart + i / thetaSegments * thetaLength;\\n\\n\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\tvertex.x = radius * Math.cos( segment );\\n\\t\\t\\t\\tvertex.y = radius * Math.sin( segment );\\n\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t// normal\\n\\n\\t\\t\\t\\tnormals.push( 0, 0, 1 );\\n\\n\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\tuv.x = ( vertex.x / outerRadius + 1 ) / 2;\\n\\t\\t\\t\\tuv.y = ( vertex.y / outerRadius + 1 ) / 2;\\n\\n\\t\\t\\t\\tuvs.push( uv.x, uv.y );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// increase the radius for next row of vertices\\n\\n\\t\\t\\tradius += radiusStep;\\n\\n\\t\\t}\\n\\n\\t\\t// indices\\n\\n\\t\\tfor ( j = 0; j < phiSegments; j ++ ) {\\n\\n\\t\\t\\tvar thetaSegmentLevel = j * ( thetaSegments + 1 );\\n\\n\\t\\t\\tfor ( i = 0; i < thetaSegments; i ++ ) {\\n\\n\\t\\t\\t\\tsegment = i + thetaSegmentLevel;\\n\\n\\t\\t\\t\\tvar a = segment;\\n\\t\\t\\t\\tvar b = segment + thetaSegments + 1;\\n\\t\\t\\t\\tvar c = segment + thetaSegments + 2;\\n\\t\\t\\t\\tvar d = segment + 1;\\n\\n\\t\\t\\t\\t// faces\\n\\n\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t}\\n\\n\\tRingBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tRingBufferGeometry.prototype.constructor = RingBufferGeometry;\\n\\n\\t/**\\n\\t * @author astrodud / http://astrodud.isgreat.org/\\n\\t * @author zz85 / https://github.com/zz85\\n\\t * @author bhouston / http://clara.io\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// LatheGeometry\\n\\n\\tfunction LatheGeometry( points, segments, phiStart, phiLength ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'LatheGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tpoints: points,\\n\\t\\t\\tsegments: segments,\\n\\t\\t\\tphiStart: phiStart,\\n\\t\\t\\tphiLength: phiLength\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new LatheBufferGeometry( points, segments, phiStart, phiLength ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tLatheGeometry.prototype = Object.create( Geometry.prototype );\\n\\tLatheGeometry.prototype.constructor = LatheGeometry;\\n\\n\\t// LatheBufferGeometry\\n\\n\\tfunction LatheBufferGeometry( points, segments, phiStart, phiLength ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'LatheBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tpoints: points,\\n\\t\\t\\tsegments: segments,\\n\\t\\t\\tphiStart: phiStart,\\n\\t\\t\\tphiLength: phiLength\\n\\t\\t};\\n\\n\\t\\tsegments = Math.floor( segments ) || 12;\\n\\t\\tphiStart = phiStart || 0;\\n\\t\\tphiLength = phiLength || Math.PI * 2;\\n\\n\\t\\t// clamp phiLength so it's in range of [ 0, 2PI ]\\n\\n\\t\\tphiLength = _Math.clamp( phiLength, 0, Math.PI * 2 );\\n\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar base;\\n\\t\\tvar inverseSegments = 1.0 / segments;\\n\\t\\tvar vertex = new Vector3();\\n\\t\\tvar uv = new Vector2();\\n\\t\\tvar i, j;\\n\\n\\t\\t// generate vertices and uvs\\n\\n\\t\\tfor ( i = 0; i <= segments; i ++ ) {\\n\\n\\t\\t\\tvar phi = phiStart + i * inverseSegments * phiLength;\\n\\n\\t\\t\\tvar sin = Math.sin( phi );\\n\\t\\t\\tvar cos = Math.cos( phi );\\n\\n\\t\\t\\tfor ( j = 0; j <= ( points.length - 1 ); j ++ ) {\\n\\n\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\tvertex.x = points[ j ].x * sin;\\n\\t\\t\\t\\tvertex.y = points[ j ].y;\\n\\t\\t\\t\\tvertex.z = points[ j ].x * cos;\\n\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\tuv.x = i / segments;\\n\\t\\t\\t\\tuv.y = j / ( points.length - 1 );\\n\\n\\t\\t\\t\\tuvs.push( uv.x, uv.y );\\n\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// indices\\n\\n\\t\\tfor ( i = 0; i < segments; i ++ ) {\\n\\n\\t\\t\\tfor ( j = 0; j < ( points.length - 1 ); j ++ ) {\\n\\n\\t\\t\\t\\tbase = j + i * points.length;\\n\\n\\t\\t\\t\\tvar a = base;\\n\\t\\t\\t\\tvar b = base + points.length;\\n\\t\\t\\t\\tvar c = base + points.length + 1;\\n\\t\\t\\t\\tvar d = base + 1;\\n\\n\\t\\t\\t\\t// faces\\n\\n\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t\\t// generate normals\\n\\n\\t\\tthis.computeVertexNormals();\\n\\n\\t\\t// if the geometry is closed, we need to average the normals along the seam.\\n\\t\\t// because the corresponding vertices are identical (but still have different UVs).\\n\\n\\t\\tif ( phiLength === Math.PI * 2 ) {\\n\\n\\t\\t\\tvar normals = this.attributes.normal.array;\\n\\t\\t\\tvar n1 = new Vector3();\\n\\t\\t\\tvar n2 = new Vector3();\\n\\t\\t\\tvar n = new Vector3();\\n\\n\\t\\t\\t// this is the buffer offset for the last line of vertices\\n\\n\\t\\t\\tbase = segments * points.length * 3;\\n\\n\\t\\t\\tfor ( i = 0, j = 0; i < points.length; i ++, j += 3 ) {\\n\\n\\t\\t\\t\\t// select the normal of the vertex in the first line\\n\\n\\t\\t\\t\\tn1.x = normals[ j + 0 ];\\n\\t\\t\\t\\tn1.y = normals[ j + 1 ];\\n\\t\\t\\t\\tn1.z = normals[ j + 2 ];\\n\\n\\t\\t\\t\\t// select the normal of the vertex in the last line\\n\\n\\t\\t\\t\\tn2.x = normals[ base + j + 0 ];\\n\\t\\t\\t\\tn2.y = normals[ base + j + 1 ];\\n\\t\\t\\t\\tn2.z = normals[ base + j + 2 ];\\n\\n\\t\\t\\t\\t// average normals\\n\\n\\t\\t\\t\\tn.addVectors( n1, n2 ).normalize();\\n\\n\\t\\t\\t\\t// assign the new values to both normals\\n\\n\\t\\t\\t\\tnormals[ j + 0 ] = normals[ base + j + 0 ] = n.x;\\n\\t\\t\\t\\tnormals[ j + 1 ] = normals[ base + j + 1 ] = n.y;\\n\\t\\t\\t\\tnormals[ j + 2 ] = normals[ base + j + 2 ] = n.z;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tLatheBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tLatheBufferGeometry.prototype.constructor = LatheBufferGeometry;\\n\\n\\t/**\\n\\t * @author jonobr1 / http://jonobr1.com\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// ShapeGeometry\\n\\n\\tfunction ShapeGeometry( shapes, curveSegments ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'ShapeGeometry';\\n\\n\\t\\tif ( typeof curveSegments === 'object' ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.ShapeGeometry: Options parameter has been removed.' );\\n\\n\\t\\t\\tcurveSegments = curveSegments.curveSegments;\\n\\n\\t\\t}\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tshapes: shapes,\\n\\t\\t\\tcurveSegments: curveSegments\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new ShapeBufferGeometry( shapes, curveSegments ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tShapeGeometry.prototype = Object.create( Geometry.prototype );\\n\\tShapeGeometry.prototype.constructor = ShapeGeometry;\\n\\n\\tShapeGeometry.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Geometry.prototype.toJSON.call( this );\\n\\n\\t\\tvar shapes = this.parameters.shapes;\\n\\n\\t\\treturn toJSON( shapes, data );\\n\\n\\t};\\n\\n\\t// ShapeBufferGeometry\\n\\n\\tfunction ShapeBufferGeometry( shapes, curveSegments ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'ShapeBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tshapes: shapes,\\n\\t\\t\\tcurveSegments: curveSegments\\n\\t\\t};\\n\\n\\t\\tcurveSegments = curveSegments || 12;\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar groupStart = 0;\\n\\t\\tvar groupCount = 0;\\n\\n\\t\\t// allow single and array values for \\\"shapes\\\" parameter\\n\\n\\t\\tif ( Array.isArray( shapes ) === false ) {\\n\\n\\t\\t\\taddShape( shapes );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tfor ( var i = 0; i < shapes.length; i ++ ) {\\n\\n\\t\\t\\t\\taddShape( shapes[ i ] );\\n\\n\\t\\t\\t\\tthis.addGroup( groupStart, groupCount, i ); // enables MultiMaterial support\\n\\n\\t\\t\\t\\tgroupStart += groupCount;\\n\\t\\t\\t\\tgroupCount = 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\n\\t\\t// helper functions\\n\\n\\t\\tfunction addShape( shape ) {\\n\\n\\t\\t\\tvar i, l, shapeHole;\\n\\n\\t\\t\\tvar indexOffset = vertices.length / 3;\\n\\t\\t\\tvar points = shape.extractPoints( curveSegments );\\n\\n\\t\\t\\tvar shapeVertices = points.shape;\\n\\t\\t\\tvar shapeHoles = points.holes;\\n\\n\\t\\t\\t// check direction of vertices\\n\\n\\t\\t\\tif ( ShapeUtils.isClockWise( shapeVertices ) === false ) {\\n\\n\\t\\t\\t\\tshapeVertices = shapeVertices.reverse();\\n\\n\\t\\t\\t\\t// also check if holes are in the opposite direction\\n\\n\\t\\t\\t\\tfor ( i = 0, l = shapeHoles.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tshapeHole = shapeHoles[ i ];\\n\\n\\t\\t\\t\\t\\tif ( ShapeUtils.isClockWise( shapeHole ) === true ) {\\n\\n\\t\\t\\t\\t\\t\\tshapeHoles[ i ] = shapeHole.reverse();\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar faces = ShapeUtils.triangulateShape( shapeVertices, shapeHoles );\\n\\n\\t\\t\\t// join vertices of inner and outer paths to a single array\\n\\n\\t\\t\\tfor ( i = 0, l = shapeHoles.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tshapeHole = shapeHoles[ i ];\\n\\t\\t\\t\\tshapeVertices = shapeVertices.concat( shapeHole );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// vertices, normals, uvs\\n\\n\\t\\t\\tfor ( i = 0, l = shapeVertices.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar vertex = shapeVertices[ i ];\\n\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, 0 );\\n\\t\\t\\t\\tnormals.push( 0, 0, 1 );\\n\\t\\t\\t\\tuvs.push( vertex.x, vertex.y ); // world uvs\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// incides\\n\\n\\t\\t\\tfor ( i = 0, l = faces.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar face = faces[ i ];\\n\\n\\t\\t\\t\\tvar a = face[ 0 ] + indexOffset;\\n\\t\\t\\t\\tvar b = face[ 1 ] + indexOffset;\\n\\t\\t\\t\\tvar c = face[ 2 ] + indexOffset;\\n\\n\\t\\t\\t\\tindices.push( a, b, c );\\n\\t\\t\\t\\tgroupCount += 3;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tShapeBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tShapeBufferGeometry.prototype.constructor = ShapeBufferGeometry;\\n\\n\\tShapeBufferGeometry.prototype.toJSON = function () {\\n\\n\\t\\tvar data = BufferGeometry.prototype.toJSON.call( this );\\n\\n\\t\\tvar shapes = this.parameters.shapes;\\n\\n\\t\\treturn toJSON( shapes, data );\\n\\n\\t};\\n\\n\\t//\\n\\n\\tfunction toJSON( shapes, data ) {\\n\\n\\t\\tdata.shapes = [];\\n\\n\\t\\tif ( Array.isArray( shapes ) ) {\\n\\n\\t\\t\\tfor ( var i = 0, l = shapes.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar shape = shapes[ i ];\\n\\n\\t\\t\\t\\tdata.shapes.push( shape.uuid );\\n\\n\\t\\t\\t}\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tdata.shapes.push( shapes.uuid );\\n\\n\\t\\t}\\n\\n\\t\\treturn data;\\n\\n\\t}\\n\\n\\t/**\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\tfunction EdgesGeometry( geometry, thresholdAngle ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'EdgesGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tthresholdAngle: thresholdAngle\\n\\t\\t};\\n\\n\\t\\tthresholdAngle = ( thresholdAngle !== undefined ) ? thresholdAngle : 1;\\n\\n\\t\\t// buffer\\n\\n\\t\\tvar vertices = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar thresholdDot = Math.cos( _Math.DEG2RAD * thresholdAngle );\\n\\t\\tvar edge = [ 0, 0 ], edges = {}, edge1, edge2;\\n\\t\\tvar key, keys = [ 'a', 'b', 'c' ];\\n\\n\\t\\t// prepare source geometry\\n\\n\\t\\tvar geometry2;\\n\\n\\t\\tif ( geometry.isBufferGeometry ) {\\n\\n\\t\\t\\tgeometry2 = new Geometry();\\n\\t\\t\\tgeometry2.fromBufferGeometry( geometry );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tgeometry2 = geometry.clone();\\n\\n\\t\\t}\\n\\n\\t\\tgeometry2.mergeVertices();\\n\\t\\tgeometry2.computeFaceNormals();\\n\\n\\t\\tvar sourceVertices = geometry2.vertices;\\n\\t\\tvar faces = geometry2.faces;\\n\\n\\t\\t// now create a data structure where each entry represents an edge with its adjoining faces\\n\\n\\t\\tfor ( var i = 0, l = faces.length; i < l; i ++ ) {\\n\\n\\t\\t\\tvar face = faces[ i ];\\n\\n\\t\\t\\tfor ( var j = 0; j < 3; j ++ ) {\\n\\n\\t\\t\\t\\tedge1 = face[ keys[ j ] ];\\n\\t\\t\\t\\tedge2 = face[ keys[ ( j + 1 ) % 3 ] ];\\n\\t\\t\\t\\tedge[ 0 ] = Math.min( edge1, edge2 );\\n\\t\\t\\t\\tedge[ 1 ] = Math.max( edge1, edge2 );\\n\\n\\t\\t\\t\\tkey = edge[ 0 ] + ',' + edge[ 1 ];\\n\\n\\t\\t\\t\\tif ( edges[ key ] === undefined ) {\\n\\n\\t\\t\\t\\t\\tedges[ key ] = { index1: edge[ 0 ], index2: edge[ 1 ], face1: i, face2: undefined };\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tedges[ key ].face2 = i;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// generate vertices\\n\\n\\t\\tfor ( key in edges ) {\\n\\n\\t\\t\\tvar e = edges[ key ];\\n\\n\\t\\t\\t// an edge is only rendered if the angle (in degrees) between the face normals of the adjoining faces exceeds this value. default = 1 degree.\\n\\n\\t\\t\\tif ( e.face2 === undefined || faces[ e.face1 ].normal.dot( faces[ e.face2 ].normal ) <= thresholdDot ) {\\n\\n\\t\\t\\t\\tvar vertex = sourceVertices[ e.index1 ];\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\tvertex = sourceVertices[ e.index2 ];\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\n\\t}\\n\\n\\tEdgesGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tEdgesGeometry.prototype.constructor = EdgesGeometry;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\t// CylinderGeometry\\n\\n\\tfunction CylinderGeometry( radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'CylinderGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradiusTop: radiusTop,\\n\\t\\t\\tradiusBottom: radiusBottom,\\n\\t\\t\\theight: height,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\theightSegments: heightSegments,\\n\\t\\t\\topenEnded: openEnded,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new CylinderBufferGeometry( radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tCylinderGeometry.prototype = Object.create( Geometry.prototype );\\n\\tCylinderGeometry.prototype.constructor = CylinderGeometry;\\n\\n\\t// CylinderBufferGeometry\\n\\n\\tfunction CylinderBufferGeometry( radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'CylinderBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradiusTop: radiusTop,\\n\\t\\t\\tradiusBottom: radiusBottom,\\n\\t\\t\\theight: height,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\theightSegments: heightSegments,\\n\\t\\t\\topenEnded: openEnded,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t\\tvar scope = this;\\n\\n\\t\\tradiusTop = radiusTop !== undefined ? radiusTop : 1;\\n\\t\\tradiusBottom = radiusBottom !== undefined ? radiusBottom : 1;\\n\\t\\theight = height || 1;\\n\\n\\t\\tradialSegments = Math.floor( radialSegments ) || 8;\\n\\t\\theightSegments = Math.floor( heightSegments ) || 1;\\n\\n\\t\\topenEnded = openEnded !== undefined ? openEnded : false;\\n\\t\\tthetaStart = thetaStart !== undefined ? thetaStart : 0.0;\\n\\t\\tthetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2;\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar index = 0;\\n\\t\\tvar indexArray = [];\\n\\t\\tvar halfHeight = height / 2;\\n\\t\\tvar groupStart = 0;\\n\\n\\t\\t// generate geometry\\n\\n\\t\\tgenerateTorso();\\n\\n\\t\\tif ( openEnded === false ) {\\n\\n\\t\\t\\tif ( radiusTop > 0 ) generateCap( true );\\n\\t\\t\\tif ( radiusBottom > 0 ) generateCap( false );\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t\\tfunction generateTorso() {\\n\\n\\t\\t\\tvar x, y;\\n\\t\\t\\tvar normal = new Vector3();\\n\\t\\t\\tvar vertex = new Vector3();\\n\\n\\t\\t\\tvar groupCount = 0;\\n\\n\\t\\t\\t// this will be used to calculate the normal\\n\\t\\t\\tvar slope = ( radiusBottom - radiusTop ) / height;\\n\\n\\t\\t\\t// generate vertices, normals and uvs\\n\\n\\t\\t\\tfor ( y = 0; y <= heightSegments; y ++ ) {\\n\\n\\t\\t\\t\\tvar indexRow = [];\\n\\n\\t\\t\\t\\tvar v = y / heightSegments;\\n\\n\\t\\t\\t\\t// calculate the radius of the current row\\n\\n\\t\\t\\t\\tvar radius = v * ( radiusBottom - radiusTop ) + radiusTop;\\n\\n\\t\\t\\t\\tfor ( x = 0; x <= radialSegments; x ++ ) {\\n\\n\\t\\t\\t\\t\\tvar u = x / radialSegments;\\n\\n\\t\\t\\t\\t\\tvar theta = u * thetaLength + thetaStart;\\n\\n\\t\\t\\t\\t\\tvar sinTheta = Math.sin( theta );\\n\\t\\t\\t\\t\\tvar cosTheta = Math.cos( theta );\\n\\n\\t\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\t\\tvertex.x = radius * sinTheta;\\n\\t\\t\\t\\t\\tvertex.y = - v * height + halfHeight;\\n\\t\\t\\t\\t\\tvertex.z = radius * cosTheta;\\n\\t\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t\\t// normal\\n\\n\\t\\t\\t\\t\\tnormal.set( sinTheta, slope, cosTheta ).normalize();\\n\\t\\t\\t\\t\\tnormals.push( normal.x, normal.y, normal.z );\\n\\n\\t\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\t\\tuvs.push( u, 1 - v );\\n\\n\\t\\t\\t\\t\\t// save index of vertex in respective row\\n\\n\\t\\t\\t\\t\\tindexRow.push( index ++ );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// now save vertices of the row in our index array\\n\\n\\t\\t\\t\\tindexArray.push( indexRow );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// generate indices\\n\\n\\t\\t\\tfor ( x = 0; x < radialSegments; x ++ ) {\\n\\n\\t\\t\\t\\tfor ( y = 0; y < heightSegments; y ++ ) {\\n\\n\\t\\t\\t\\t\\t// we use the index array to access the correct indices\\n\\n\\t\\t\\t\\t\\tvar a = indexArray[ y ][ x ];\\n\\t\\t\\t\\t\\tvar b = indexArray[ y + 1 ][ x ];\\n\\t\\t\\t\\t\\tvar c = indexArray[ y + 1 ][ x + 1 ];\\n\\t\\t\\t\\t\\tvar d = indexArray[ y ][ x + 1 ];\\n\\n\\t\\t\\t\\t\\t// faces\\n\\n\\t\\t\\t\\t\\tindices.push( a, b, d );\\n\\t\\t\\t\\t\\tindices.push( b, c, d );\\n\\n\\t\\t\\t\\t\\t// update group counter\\n\\n\\t\\t\\t\\t\\tgroupCount += 6;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// add a group to the geometry. this will ensure multi material support\\n\\n\\t\\t\\tscope.addGroup( groupStart, groupCount, 0 );\\n\\n\\t\\t\\t// calculate new start value for groups\\n\\n\\t\\t\\tgroupStart += groupCount;\\n\\n\\t\\t}\\n\\n\\t\\tfunction generateCap( top ) {\\n\\n\\t\\t\\tvar x, centerIndexStart, centerIndexEnd;\\n\\n\\t\\t\\tvar uv = new Vector2();\\n\\t\\t\\tvar vertex = new Vector3();\\n\\n\\t\\t\\tvar groupCount = 0;\\n\\n\\t\\t\\tvar radius = ( top === true ) ? radiusTop : radiusBottom;\\n\\t\\t\\tvar sign = ( top === true ) ? 1 : - 1;\\n\\n\\t\\t\\t// save the index of the first center vertex\\n\\t\\t\\tcenterIndexStart = index;\\n\\n\\t\\t\\t// first we generate the center vertex data of the cap.\\n\\t\\t\\t// because the geometry needs one set of uvs per face,\\n\\t\\t\\t// we must generate a center vertex per face/segment\\n\\n\\t\\t\\tfor ( x = 1; x <= radialSegments; x ++ ) {\\n\\n\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\tvertices.push( 0, halfHeight * sign, 0 );\\n\\n\\t\\t\\t\\t// normal\\n\\n\\t\\t\\t\\tnormals.push( 0, sign, 0 );\\n\\n\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\tuvs.push( 0.5, 0.5 );\\n\\n\\t\\t\\t\\t// increase index\\n\\n\\t\\t\\t\\tindex ++;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// save the index of the last center vertex\\n\\n\\t\\t\\tcenterIndexEnd = index;\\n\\n\\t\\t\\t// now we generate the surrounding vertices, normals and uvs\\n\\n\\t\\t\\tfor ( x = 0; x <= radialSegments; x ++ ) {\\n\\n\\t\\t\\t\\tvar u = x / radialSegments;\\n\\t\\t\\t\\tvar theta = u * thetaLength + thetaStart;\\n\\n\\t\\t\\t\\tvar cosTheta = Math.cos( theta );\\n\\t\\t\\t\\tvar sinTheta = Math.sin( theta );\\n\\n\\t\\t\\t\\t// vertex\\n\\n\\t\\t\\t\\tvertex.x = radius * sinTheta;\\n\\t\\t\\t\\tvertex.y = halfHeight * sign;\\n\\t\\t\\t\\tvertex.z = radius * cosTheta;\\n\\t\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t\\t// normal\\n\\n\\t\\t\\t\\tnormals.push( 0, sign, 0 );\\n\\n\\t\\t\\t\\t// uv\\n\\n\\t\\t\\t\\tuv.x = ( cosTheta * 0.5 ) + 0.5;\\n\\t\\t\\t\\tuv.y = ( sinTheta * 0.5 * sign ) + 0.5;\\n\\t\\t\\t\\tuvs.push( uv.x, uv.y );\\n\\n\\t\\t\\t\\t// increase index\\n\\n\\t\\t\\t\\tindex ++;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// generate indices\\n\\n\\t\\t\\tfor ( x = 0; x < radialSegments; x ++ ) {\\n\\n\\t\\t\\t\\tvar c = centerIndexStart + x;\\n\\t\\t\\t\\tvar i = centerIndexEnd + x;\\n\\n\\t\\t\\t\\tif ( top === true ) {\\n\\n\\t\\t\\t\\t\\t// face top\\n\\n\\t\\t\\t\\t\\tindices.push( i, i + 1, c );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// face bottom\\n\\n\\t\\t\\t\\t\\tindices.push( i + 1, i, c );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgroupCount += 3;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// add a group to the geometry. this will ensure multi material support\\n\\n\\t\\t\\tscope.addGroup( groupStart, groupCount, top === true ? 1 : 2 );\\n\\n\\t\\t\\t// calculate new start value for groups\\n\\n\\t\\t\\tgroupStart += groupCount;\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tCylinderBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tCylinderBufferGeometry.prototype.constructor = CylinderBufferGeometry;\\n\\n\\t/**\\n\\t * @author abelnation / http://github.com/abelnation\\n\\t */\\n\\n\\t// ConeGeometry\\n\\n\\tfunction ConeGeometry( radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) {\\n\\n\\t\\tCylinderGeometry.call( this, 0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength );\\n\\n\\t\\tthis.type = 'ConeGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\theight: height,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\theightSegments: heightSegments,\\n\\t\\t\\topenEnded: openEnded,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t}\\n\\n\\tConeGeometry.prototype = Object.create( CylinderGeometry.prototype );\\n\\tConeGeometry.prototype.constructor = ConeGeometry;\\n\\n\\t// ConeBufferGeometry\\n\\n\\tfunction ConeBufferGeometry( radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) {\\n\\n\\t\\tCylinderBufferGeometry.call( this, 0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength );\\n\\n\\t\\tthis.type = 'ConeBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\theight: height,\\n\\t\\t\\tradialSegments: radialSegments,\\n\\t\\t\\theightSegments: heightSegments,\\n\\t\\t\\topenEnded: openEnded,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t}\\n\\n\\tConeBufferGeometry.prototype = Object.create( CylinderBufferGeometry.prototype );\\n\\tConeBufferGeometry.prototype.constructor = ConeBufferGeometry;\\n\\n\\t/**\\n\\t * @author benaadams / https://twitter.com/ben_a_adams\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t * @author hughes\\n\\t */\\n\\n\\t// CircleGeometry\\n\\n\\tfunction CircleGeometry( radius, segments, thetaStart, thetaLength ) {\\n\\n\\t\\tGeometry.call( this );\\n\\n\\t\\tthis.type = 'CircleGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tsegments: segments,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t\\tthis.fromBufferGeometry( new CircleBufferGeometry( radius, segments, thetaStart, thetaLength ) );\\n\\t\\tthis.mergeVertices();\\n\\n\\t}\\n\\n\\tCircleGeometry.prototype = Object.create( Geometry.prototype );\\n\\tCircleGeometry.prototype.constructor = CircleGeometry;\\n\\n\\t// CircleBufferGeometry\\n\\n\\tfunction CircleBufferGeometry( radius, segments, thetaStart, thetaLength ) {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'CircleBufferGeometry';\\n\\n\\t\\tthis.parameters = {\\n\\t\\t\\tradius: radius,\\n\\t\\t\\tsegments: segments,\\n\\t\\t\\tthetaStart: thetaStart,\\n\\t\\t\\tthetaLength: thetaLength\\n\\t\\t};\\n\\n\\t\\tradius = radius || 1;\\n\\t\\tsegments = segments !== undefined ? Math.max( 3, segments ) : 8;\\n\\n\\t\\tthetaStart = thetaStart !== undefined ? thetaStart : 0;\\n\\t\\tthetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2;\\n\\n\\t\\t// buffers\\n\\n\\t\\tvar indices = [];\\n\\t\\tvar vertices = [];\\n\\t\\tvar normals = [];\\n\\t\\tvar uvs = [];\\n\\n\\t\\t// helper variables\\n\\n\\t\\tvar i, s;\\n\\t\\tvar vertex = new Vector3();\\n\\t\\tvar uv = new Vector2();\\n\\n\\t\\t// center point\\n\\n\\t\\tvertices.push( 0, 0, 0 );\\n\\t\\tnormals.push( 0, 0, 1 );\\n\\t\\tuvs.push( 0.5, 0.5 );\\n\\n\\t\\tfor ( s = 0, i = 3; s <= segments; s ++, i += 3 ) {\\n\\n\\t\\t\\tvar segment = thetaStart + s / segments * thetaLength;\\n\\n\\t\\t\\t// vertex\\n\\n\\t\\t\\tvertex.x = radius * Math.cos( segment );\\n\\t\\t\\tvertex.y = radius * Math.sin( segment );\\n\\n\\t\\t\\tvertices.push( vertex.x, vertex.y, vertex.z );\\n\\n\\t\\t\\t// normal\\n\\n\\t\\t\\tnormals.push( 0, 0, 1 );\\n\\n\\t\\t\\t// uvs\\n\\n\\t\\t\\tuv.x = ( vertices[ i ] / radius + 1 ) / 2;\\n\\t\\t\\tuv.y = ( vertices[ i + 1 ] / radius + 1 ) / 2;\\n\\n\\t\\t\\tuvs.push( uv.x, uv.y );\\n\\n\\t\\t}\\n\\n\\t\\t// indices\\n\\n\\t\\tfor ( i = 1; i <= segments; i ++ ) {\\n\\n\\t\\t\\tindices.push( i, i + 1, 0 );\\n\\n\\t\\t}\\n\\n\\t\\t// build geometry\\n\\n\\t\\tthis.setIndex( indices );\\n\\t\\tthis.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tthis.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );\\n\\t\\tthis.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );\\n\\n\\t}\\n\\n\\tCircleBufferGeometry.prototype = Object.create( BufferGeometry.prototype );\\n\\tCircleBufferGeometry.prototype.constructor = CircleBufferGeometry;\\n\\n\\n\\n\\tvar Geometries = Object.freeze({\\n\\t\\tWireframeGeometry: WireframeGeometry,\\n\\t\\tParametricGeometry: ParametricGeometry,\\n\\t\\tParametricBufferGeometry: ParametricBufferGeometry,\\n\\t\\tTetrahedronGeometry: TetrahedronGeometry,\\n\\t\\tTetrahedronBufferGeometry: TetrahedronBufferGeometry,\\n\\t\\tOctahedronGeometry: OctahedronGeometry,\\n\\t\\tOctahedronBufferGeometry: OctahedronBufferGeometry,\\n\\t\\tIcosahedronGeometry: IcosahedronGeometry,\\n\\t\\tIcosahedronBufferGeometry: IcosahedronBufferGeometry,\\n\\t\\tDodecahedronGeometry: DodecahedronGeometry,\\n\\t\\tDodecahedronBufferGeometry: DodecahedronBufferGeometry,\\n\\t\\tPolyhedronGeometry: PolyhedronGeometry,\\n\\t\\tPolyhedronBufferGeometry: PolyhedronBufferGeometry,\\n\\t\\tTubeGeometry: TubeGeometry,\\n\\t\\tTubeBufferGeometry: TubeBufferGeometry,\\n\\t\\tTorusKnotGeometry: TorusKnotGeometry,\\n\\t\\tTorusKnotBufferGeometry: TorusKnotBufferGeometry,\\n\\t\\tTorusGeometry: TorusGeometry,\\n\\t\\tTorusBufferGeometry: TorusBufferGeometry,\\n\\t\\tTextGeometry: TextGeometry,\\n\\t\\tTextBufferGeometry: TextBufferGeometry,\\n\\t\\tSphereGeometry: SphereGeometry,\\n\\t\\tSphereBufferGeometry: SphereBufferGeometry,\\n\\t\\tRingGeometry: RingGeometry,\\n\\t\\tRingBufferGeometry: RingBufferGeometry,\\n\\t\\tPlaneGeometry: PlaneGeometry,\\n\\t\\tPlaneBufferGeometry: PlaneBufferGeometry,\\n\\t\\tLatheGeometry: LatheGeometry,\\n\\t\\tLatheBufferGeometry: LatheBufferGeometry,\\n\\t\\tShapeGeometry: ShapeGeometry,\\n\\t\\tShapeBufferGeometry: ShapeBufferGeometry,\\n\\t\\tExtrudeGeometry: ExtrudeGeometry,\\n\\t\\tExtrudeBufferGeometry: ExtrudeBufferGeometry,\\n\\t\\tEdgesGeometry: EdgesGeometry,\\n\\t\\tConeGeometry: ConeGeometry,\\n\\t\\tConeBufferGeometry: ConeBufferGeometry,\\n\\t\\tCylinderGeometry: CylinderGeometry,\\n\\t\\tCylinderBufferGeometry: CylinderBufferGeometry,\\n\\t\\tCircleGeometry: CircleGeometry,\\n\\t\\tCircleBufferGeometry: CircleBufferGeometry,\\n\\t\\tBoxGeometry: BoxGeometry,\\n\\t\\tBoxBufferGeometry: BoxBufferGeometry\\n\\t});\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t *\\n\\t * parameters = {\\n\\t *  color: <THREE.Color>,\\n\\t *  opacity: <float>\\n\\t * }\\n\\t */\\n\\n\\tfunction ShadowMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'ShadowMaterial';\\n\\n\\t\\tthis.color = new Color( 0x000000 );\\n\\t\\tthis.opacity = 1.0;\\n\\n\\t\\tthis.lights = true;\\n\\t\\tthis.transparent = true;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tShadowMaterial.prototype = Object.create( Material.prototype );\\n\\tShadowMaterial.prototype.constructor = ShadowMaterial;\\n\\n\\tShadowMaterial.prototype.isShadowMaterial = true;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction RawShaderMaterial( parameters ) {\\n\\n\\t\\tShaderMaterial.call( this, parameters );\\n\\n\\t\\tthis.type = 'RawShaderMaterial';\\n\\n\\t}\\n\\n\\tRawShaderMaterial.prototype = Object.create( ShaderMaterial.prototype );\\n\\tRawShaderMaterial.prototype.constructor = RawShaderMaterial;\\n\\n\\tRawShaderMaterial.prototype.isRawShaderMaterial = true;\\n\\n\\t/**\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t *\\n\\t * parameters = {\\n\\t *  color: <hex>,\\n\\t *  roughness: <float>,\\n\\t *  metalness: <float>,\\n\\t *  opacity: <float>,\\n\\t *\\n\\t *  map: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  lightMap: new THREE.Texture( <Image> ),\\n\\t *  lightMapIntensity: <float>\\n\\t *\\n\\t *  aoMap: new THREE.Texture( <Image> ),\\n\\t *  aoMapIntensity: <float>\\n\\t *\\n\\t *  emissive: <hex>,\\n\\t *  emissiveIntensity: <float>\\n\\t *  emissiveMap: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  bumpMap: new THREE.Texture( <Image> ),\\n\\t *  bumpScale: <float>,\\n\\t *\\n\\t *  normalMap: new THREE.Texture( <Image> ),\\n\\t *  normalScale: <Vector2>,\\n\\t *\\n\\t *  displacementMap: new THREE.Texture( <Image> ),\\n\\t *  displacementScale: <float>,\\n\\t *  displacementBias: <float>,\\n\\t *\\n\\t *  roughnessMap: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  metalnessMap: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  alphaMap: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ),\\n\\t *  envMapIntensity: <float>\\n\\t *\\n\\t *  refractionRatio: <float>,\\n\\t *\\n\\t *  wireframe: <boolean>,\\n\\t *  wireframeLinewidth: <float>,\\n\\t *\\n\\t *  skinning: <bool>,\\n\\t *  morphTargets: <bool>,\\n\\t *  morphNormals: <bool>\\n\\t * }\\n\\t */\\n\\n\\tfunction MeshStandardMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.defines = { 'STANDARD': '' };\\n\\n\\t\\tthis.type = 'MeshStandardMaterial';\\n\\n\\t\\tthis.color = new Color( 0xffffff ); // diffuse\\n\\t\\tthis.roughness = 0.5;\\n\\t\\tthis.metalness = 0.5;\\n\\n\\t\\tthis.map = null;\\n\\n\\t\\tthis.lightMap = null;\\n\\t\\tthis.lightMapIntensity = 1.0;\\n\\n\\t\\tthis.aoMap = null;\\n\\t\\tthis.aoMapIntensity = 1.0;\\n\\n\\t\\tthis.emissive = new Color( 0x000000 );\\n\\t\\tthis.emissiveIntensity = 1.0;\\n\\t\\tthis.emissiveMap = null;\\n\\n\\t\\tthis.bumpMap = null;\\n\\t\\tthis.bumpScale = 1;\\n\\n\\t\\tthis.normalMap = null;\\n\\t\\tthis.normalScale = new Vector2( 1, 1 );\\n\\n\\t\\tthis.displacementMap = null;\\n\\t\\tthis.displacementScale = 1;\\n\\t\\tthis.displacementBias = 0;\\n\\n\\t\\tthis.roughnessMap = null;\\n\\n\\t\\tthis.metalnessMap = null;\\n\\n\\t\\tthis.alphaMap = null;\\n\\n\\t\\tthis.envMap = null;\\n\\t\\tthis.envMapIntensity = 1.0;\\n\\n\\t\\tthis.refractionRatio = 0.98;\\n\\n\\t\\tthis.wireframe = false;\\n\\t\\tthis.wireframeLinewidth = 1;\\n\\t\\tthis.wireframeLinecap = 'round';\\n\\t\\tthis.wireframeLinejoin = 'round';\\n\\n\\t\\tthis.skinning = false;\\n\\t\\tthis.morphTargets = false;\\n\\t\\tthis.morphNormals = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshStandardMaterial.prototype = Object.create( Material.prototype );\\n\\tMeshStandardMaterial.prototype.constructor = MeshStandardMaterial;\\n\\n\\tMeshStandardMaterial.prototype.isMeshStandardMaterial = true;\\n\\n\\tMeshStandardMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.defines = { 'STANDARD': '' };\\n\\n\\t\\tthis.color.copy( source.color );\\n\\t\\tthis.roughness = source.roughness;\\n\\t\\tthis.metalness = source.metalness;\\n\\n\\t\\tthis.map = source.map;\\n\\n\\t\\tthis.lightMap = source.lightMap;\\n\\t\\tthis.lightMapIntensity = source.lightMapIntensity;\\n\\n\\t\\tthis.aoMap = source.aoMap;\\n\\t\\tthis.aoMapIntensity = source.aoMapIntensity;\\n\\n\\t\\tthis.emissive.copy( source.emissive );\\n\\t\\tthis.emissiveMap = source.emissiveMap;\\n\\t\\tthis.emissiveIntensity = source.emissiveIntensity;\\n\\n\\t\\tthis.bumpMap = source.bumpMap;\\n\\t\\tthis.bumpScale = source.bumpScale;\\n\\n\\t\\tthis.normalMap = source.normalMap;\\n\\t\\tthis.normalScale.copy( source.normalScale );\\n\\n\\t\\tthis.displacementMap = source.displacementMap;\\n\\t\\tthis.displacementScale = source.displacementScale;\\n\\t\\tthis.displacementBias = source.displacementBias;\\n\\n\\t\\tthis.roughnessMap = source.roughnessMap;\\n\\n\\t\\tthis.metalnessMap = source.metalnessMap;\\n\\n\\t\\tthis.alphaMap = source.alphaMap;\\n\\n\\t\\tthis.envMap = source.envMap;\\n\\t\\tthis.envMapIntensity = source.envMapIntensity;\\n\\n\\t\\tthis.refractionRatio = source.refractionRatio;\\n\\n\\t\\tthis.wireframe = source.wireframe;\\n\\t\\tthis.wireframeLinewidth = source.wireframeLinewidth;\\n\\t\\tthis.wireframeLinecap = source.wireframeLinecap;\\n\\t\\tthis.wireframeLinejoin = source.wireframeLinejoin;\\n\\n\\t\\tthis.skinning = source.skinning;\\n\\t\\tthis.morphTargets = source.morphTargets;\\n\\t\\tthis.morphNormals = source.morphNormals;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t *\\n\\t * parameters = {\\n\\t *  reflectivity: <float>\\n\\t * }\\n\\t */\\n\\n\\tfunction MeshPhysicalMaterial( parameters ) {\\n\\n\\t\\tMeshStandardMaterial.call( this );\\n\\n\\t\\tthis.defines = { 'PHYSICAL': '' };\\n\\n\\t\\tthis.type = 'MeshPhysicalMaterial';\\n\\n\\t\\tthis.reflectivity = 0.5; // maps to F0 = 0.04\\n\\n\\t\\tthis.clearCoat = 0.0;\\n\\t\\tthis.clearCoatRoughness = 0.0;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshPhysicalMaterial.prototype = Object.create( MeshStandardMaterial.prototype );\\n\\tMeshPhysicalMaterial.prototype.constructor = MeshPhysicalMaterial;\\n\\n\\tMeshPhysicalMaterial.prototype.isMeshPhysicalMaterial = true;\\n\\n\\tMeshPhysicalMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMeshStandardMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.defines = { 'PHYSICAL': '' };\\n\\n\\t\\tthis.reflectivity = source.reflectivity;\\n\\n\\t\\tthis.clearCoat = source.clearCoat;\\n\\t\\tthis.clearCoatRoughness = source.clearCoatRoughness;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * parameters = {\\n\\t *  color: <hex>,\\n\\t *  specular: <hex>,\\n\\t *  shininess: <float>,\\n\\t *  opacity: <float>,\\n\\t *\\n\\t *  map: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  lightMap: new THREE.Texture( <Image> ),\\n\\t *  lightMapIntensity: <float>\\n\\t *\\n\\t *  aoMap: new THREE.Texture( <Image> ),\\n\\t *  aoMapIntensity: <float>\\n\\t *\\n\\t *  emissive: <hex>,\\n\\t *  emissiveIntensity: <float>\\n\\t *  emissiveMap: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  bumpMap: new THREE.Texture( <Image> ),\\n\\t *  bumpScale: <float>,\\n\\t *\\n\\t *  normalMap: new THREE.Texture( <Image> ),\\n\\t *  normalScale: <Vector2>,\\n\\t *\\n\\t *  displacementMap: new THREE.Texture( <Image> ),\\n\\t *  displacementScale: <float>,\\n\\t *  displacementBias: <float>,\\n\\t *\\n\\t *  specularMap: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  alphaMap: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ),\\n\\t *  combine: THREE.Multiply,\\n\\t *  reflectivity: <float>,\\n\\t *  refractionRatio: <float>,\\n\\t *\\n\\t *  wireframe: <boolean>,\\n\\t *  wireframeLinewidth: <float>,\\n\\t *\\n\\t *  skinning: <bool>,\\n\\t *  morphTargets: <bool>,\\n\\t *  morphNormals: <bool>\\n\\t * }\\n\\t */\\n\\n\\tfunction MeshPhongMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'MeshPhongMaterial';\\n\\n\\t\\tthis.color = new Color( 0xffffff ); // diffuse\\n\\t\\tthis.specular = new Color( 0x111111 );\\n\\t\\tthis.shininess = 30;\\n\\n\\t\\tthis.map = null;\\n\\n\\t\\tthis.lightMap = null;\\n\\t\\tthis.lightMapIntensity = 1.0;\\n\\n\\t\\tthis.aoMap = null;\\n\\t\\tthis.aoMapIntensity = 1.0;\\n\\n\\t\\tthis.emissive = new Color( 0x000000 );\\n\\t\\tthis.emissiveIntensity = 1.0;\\n\\t\\tthis.emissiveMap = null;\\n\\n\\t\\tthis.bumpMap = null;\\n\\t\\tthis.bumpScale = 1;\\n\\n\\t\\tthis.normalMap = null;\\n\\t\\tthis.normalScale = new Vector2( 1, 1 );\\n\\n\\t\\tthis.displacementMap = null;\\n\\t\\tthis.displacementScale = 1;\\n\\t\\tthis.displacementBias = 0;\\n\\n\\t\\tthis.specularMap = null;\\n\\n\\t\\tthis.alphaMap = null;\\n\\n\\t\\tthis.envMap = null;\\n\\t\\tthis.combine = MultiplyOperation;\\n\\t\\tthis.reflectivity = 1;\\n\\t\\tthis.refractionRatio = 0.98;\\n\\n\\t\\tthis.wireframe = false;\\n\\t\\tthis.wireframeLinewidth = 1;\\n\\t\\tthis.wireframeLinecap = 'round';\\n\\t\\tthis.wireframeLinejoin = 'round';\\n\\n\\t\\tthis.skinning = false;\\n\\t\\tthis.morphTargets = false;\\n\\t\\tthis.morphNormals = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshPhongMaterial.prototype = Object.create( Material.prototype );\\n\\tMeshPhongMaterial.prototype.constructor = MeshPhongMaterial;\\n\\n\\tMeshPhongMaterial.prototype.isMeshPhongMaterial = true;\\n\\n\\tMeshPhongMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.color.copy( source.color );\\n\\t\\tthis.specular.copy( source.specular );\\n\\t\\tthis.shininess = source.shininess;\\n\\n\\t\\tthis.map = source.map;\\n\\n\\t\\tthis.lightMap = source.lightMap;\\n\\t\\tthis.lightMapIntensity = source.lightMapIntensity;\\n\\n\\t\\tthis.aoMap = source.aoMap;\\n\\t\\tthis.aoMapIntensity = source.aoMapIntensity;\\n\\n\\t\\tthis.emissive.copy( source.emissive );\\n\\t\\tthis.emissiveMap = source.emissiveMap;\\n\\t\\tthis.emissiveIntensity = source.emissiveIntensity;\\n\\n\\t\\tthis.bumpMap = source.bumpMap;\\n\\t\\tthis.bumpScale = source.bumpScale;\\n\\n\\t\\tthis.normalMap = source.normalMap;\\n\\t\\tthis.normalScale.copy( source.normalScale );\\n\\n\\t\\tthis.displacementMap = source.displacementMap;\\n\\t\\tthis.displacementScale = source.displacementScale;\\n\\t\\tthis.displacementBias = source.displacementBias;\\n\\n\\t\\tthis.specularMap = source.specularMap;\\n\\n\\t\\tthis.alphaMap = source.alphaMap;\\n\\n\\t\\tthis.envMap = source.envMap;\\n\\t\\tthis.combine = source.combine;\\n\\t\\tthis.reflectivity = source.reflectivity;\\n\\t\\tthis.refractionRatio = source.refractionRatio;\\n\\n\\t\\tthis.wireframe = source.wireframe;\\n\\t\\tthis.wireframeLinewidth = source.wireframeLinewidth;\\n\\t\\tthis.wireframeLinecap = source.wireframeLinecap;\\n\\t\\tthis.wireframeLinejoin = source.wireframeLinejoin;\\n\\n\\t\\tthis.skinning = source.skinning;\\n\\t\\tthis.morphTargets = source.morphTargets;\\n\\t\\tthis.morphNormals = source.morphNormals;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author takahirox / http://github.com/takahirox\\n\\t *\\n\\t * parameters = {\\n\\t *  gradientMap: new THREE.Texture( <Image> )\\n\\t * }\\n\\t */\\n\\n\\tfunction MeshToonMaterial( parameters ) {\\n\\n\\t\\tMeshPhongMaterial.call( this );\\n\\n\\t\\tthis.defines = { 'TOON': '' };\\n\\n\\t\\tthis.type = 'MeshToonMaterial';\\n\\n\\t\\tthis.gradientMap = null;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshToonMaterial.prototype = Object.create( MeshPhongMaterial.prototype );\\n\\tMeshToonMaterial.prototype.constructor = MeshToonMaterial;\\n\\n\\tMeshToonMaterial.prototype.isMeshToonMaterial = true;\\n\\n\\tMeshToonMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMeshPhongMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.gradientMap = source.gradientMap;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t *\\n\\t * parameters = {\\n\\t *  opacity: <float>,\\n\\t *\\n\\t *  bumpMap: new THREE.Texture( <Image> ),\\n\\t *  bumpScale: <float>,\\n\\t *\\n\\t *  normalMap: new THREE.Texture( <Image> ),\\n\\t *  normalScale: <Vector2>,\\n\\t *\\n\\t *  displacementMap: new THREE.Texture( <Image> ),\\n\\t *  displacementScale: <float>,\\n\\t *  displacementBias: <float>,\\n\\t *\\n\\t *  wireframe: <boolean>,\\n\\t *  wireframeLinewidth: <float>\\n\\t *\\n\\t *  skinning: <bool>,\\n\\t *  morphTargets: <bool>,\\n\\t *  morphNormals: <bool>\\n\\t * }\\n\\t */\\n\\n\\tfunction MeshNormalMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'MeshNormalMaterial';\\n\\n\\t\\tthis.bumpMap = null;\\n\\t\\tthis.bumpScale = 1;\\n\\n\\t\\tthis.normalMap = null;\\n\\t\\tthis.normalScale = new Vector2( 1, 1 );\\n\\n\\t\\tthis.displacementMap = null;\\n\\t\\tthis.displacementScale = 1;\\n\\t\\tthis.displacementBias = 0;\\n\\n\\t\\tthis.wireframe = false;\\n\\t\\tthis.wireframeLinewidth = 1;\\n\\n\\t\\tthis.fog = false;\\n\\t\\tthis.lights = false;\\n\\n\\t\\tthis.skinning = false;\\n\\t\\tthis.morphTargets = false;\\n\\t\\tthis.morphNormals = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshNormalMaterial.prototype = Object.create( Material.prototype );\\n\\tMeshNormalMaterial.prototype.constructor = MeshNormalMaterial;\\n\\n\\tMeshNormalMaterial.prototype.isMeshNormalMaterial = true;\\n\\n\\tMeshNormalMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.bumpMap = source.bumpMap;\\n\\t\\tthis.bumpScale = source.bumpScale;\\n\\n\\t\\tthis.normalMap = source.normalMap;\\n\\t\\tthis.normalScale.copy( source.normalScale );\\n\\n\\t\\tthis.displacementMap = source.displacementMap;\\n\\t\\tthis.displacementScale = source.displacementScale;\\n\\t\\tthis.displacementBias = source.displacementBias;\\n\\n\\t\\tthis.wireframe = source.wireframe;\\n\\t\\tthis.wireframeLinewidth = source.wireframeLinewidth;\\n\\n\\t\\tthis.skinning = source.skinning;\\n\\t\\tthis.morphTargets = source.morphTargets;\\n\\t\\tthis.morphNormals = source.morphNormals;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * parameters = {\\n\\t *  color: <hex>,\\n\\t *  opacity: <float>,\\n\\t *\\n\\t *  map: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  lightMap: new THREE.Texture( <Image> ),\\n\\t *  lightMapIntensity: <float>\\n\\t *\\n\\t *  aoMap: new THREE.Texture( <Image> ),\\n\\t *  aoMapIntensity: <float>\\n\\t *\\n\\t *  emissive: <hex>,\\n\\t *  emissiveIntensity: <float>\\n\\t *  emissiveMap: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  specularMap: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  alphaMap: new THREE.Texture( <Image> ),\\n\\t *\\n\\t *  envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ),\\n\\t *  combine: THREE.Multiply,\\n\\t *  reflectivity: <float>,\\n\\t *  refractionRatio: <float>,\\n\\t *\\n\\t *  wireframe: <boolean>,\\n\\t *  wireframeLinewidth: <float>,\\n\\t *\\n\\t *  skinning: <bool>,\\n\\t *  morphTargets: <bool>,\\n\\t *  morphNormals: <bool>\\n\\t * }\\n\\t */\\n\\n\\tfunction MeshLambertMaterial( parameters ) {\\n\\n\\t\\tMaterial.call( this );\\n\\n\\t\\tthis.type = 'MeshLambertMaterial';\\n\\n\\t\\tthis.color = new Color( 0xffffff ); // diffuse\\n\\n\\t\\tthis.map = null;\\n\\n\\t\\tthis.lightMap = null;\\n\\t\\tthis.lightMapIntensity = 1.0;\\n\\n\\t\\tthis.aoMap = null;\\n\\t\\tthis.aoMapIntensity = 1.0;\\n\\n\\t\\tthis.emissive = new Color( 0x000000 );\\n\\t\\tthis.emissiveIntensity = 1.0;\\n\\t\\tthis.emissiveMap = null;\\n\\n\\t\\tthis.specularMap = null;\\n\\n\\t\\tthis.alphaMap = null;\\n\\n\\t\\tthis.envMap = null;\\n\\t\\tthis.combine = MultiplyOperation;\\n\\t\\tthis.reflectivity = 1;\\n\\t\\tthis.refractionRatio = 0.98;\\n\\n\\t\\tthis.wireframe = false;\\n\\t\\tthis.wireframeLinewidth = 1;\\n\\t\\tthis.wireframeLinecap = 'round';\\n\\t\\tthis.wireframeLinejoin = 'round';\\n\\n\\t\\tthis.skinning = false;\\n\\t\\tthis.morphTargets = false;\\n\\t\\tthis.morphNormals = false;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tMeshLambertMaterial.prototype = Object.create( Material.prototype );\\n\\tMeshLambertMaterial.prototype.constructor = MeshLambertMaterial;\\n\\n\\tMeshLambertMaterial.prototype.isMeshLambertMaterial = true;\\n\\n\\tMeshLambertMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.color.copy( source.color );\\n\\n\\t\\tthis.map = source.map;\\n\\n\\t\\tthis.lightMap = source.lightMap;\\n\\t\\tthis.lightMapIntensity = source.lightMapIntensity;\\n\\n\\t\\tthis.aoMap = source.aoMap;\\n\\t\\tthis.aoMapIntensity = source.aoMapIntensity;\\n\\n\\t\\tthis.emissive.copy( source.emissive );\\n\\t\\tthis.emissiveMap = source.emissiveMap;\\n\\t\\tthis.emissiveIntensity = source.emissiveIntensity;\\n\\n\\t\\tthis.specularMap = source.specularMap;\\n\\n\\t\\tthis.alphaMap = source.alphaMap;\\n\\n\\t\\tthis.envMap = source.envMap;\\n\\t\\tthis.combine = source.combine;\\n\\t\\tthis.reflectivity = source.reflectivity;\\n\\t\\tthis.refractionRatio = source.refractionRatio;\\n\\n\\t\\tthis.wireframe = source.wireframe;\\n\\t\\tthis.wireframeLinewidth = source.wireframeLinewidth;\\n\\t\\tthis.wireframeLinecap = source.wireframeLinecap;\\n\\t\\tthis.wireframeLinejoin = source.wireframeLinejoin;\\n\\n\\t\\tthis.skinning = source.skinning;\\n\\t\\tthis.morphTargets = source.morphTargets;\\n\\t\\tthis.morphNormals = source.morphNormals;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t *\\n\\t * parameters = {\\n\\t *  color: <hex>,\\n\\t *  opacity: <float>,\\n\\t *\\n\\t *  linewidth: <float>,\\n\\t *\\n\\t *  scale: <float>,\\n\\t *  dashSize: <float>,\\n\\t *  gapSize: <float>\\n\\t * }\\n\\t */\\n\\n\\tfunction LineDashedMaterial( parameters ) {\\n\\n\\t\\tLineBasicMaterial.call( this );\\n\\n\\t\\tthis.type = 'LineDashedMaterial';\\n\\n\\t\\tthis.scale = 1;\\n\\t\\tthis.dashSize = 3;\\n\\t\\tthis.gapSize = 1;\\n\\n\\t\\tthis.setValues( parameters );\\n\\n\\t}\\n\\n\\tLineDashedMaterial.prototype = Object.create( LineBasicMaterial.prototype );\\n\\tLineDashedMaterial.prototype.constructor = LineDashedMaterial;\\n\\n\\tLineDashedMaterial.prototype.isLineDashedMaterial = true;\\n\\n\\tLineDashedMaterial.prototype.copy = function ( source ) {\\n\\n\\t\\tLineBasicMaterial.prototype.copy.call( this, source );\\n\\n\\t\\tthis.scale = source.scale;\\n\\t\\tthis.dashSize = source.dashSize;\\n\\t\\tthis.gapSize = source.gapSize;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\n\\n\\tvar Materials = Object.freeze({\\n\\t\\tShadowMaterial: ShadowMaterial,\\n\\t\\tSpriteMaterial: SpriteMaterial,\\n\\t\\tRawShaderMaterial: RawShaderMaterial,\\n\\t\\tShaderMaterial: ShaderMaterial,\\n\\t\\tPointsMaterial: PointsMaterial,\\n\\t\\tMeshPhysicalMaterial: MeshPhysicalMaterial,\\n\\t\\tMeshStandardMaterial: MeshStandardMaterial,\\n\\t\\tMeshPhongMaterial: MeshPhongMaterial,\\n\\t\\tMeshToonMaterial: MeshToonMaterial,\\n\\t\\tMeshNormalMaterial: MeshNormalMaterial,\\n\\t\\tMeshLambertMaterial: MeshLambertMaterial,\\n\\t\\tMeshDepthMaterial: MeshDepthMaterial,\\n\\t\\tMeshDistanceMaterial: MeshDistanceMaterial,\\n\\t\\tMeshBasicMaterial: MeshBasicMaterial,\\n\\t\\tLineDashedMaterial: LineDashedMaterial,\\n\\t\\tLineBasicMaterial: LineBasicMaterial,\\n\\t\\tMaterial: Material\\n\\t});\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tvar Cache = {\\n\\n\\t\\tenabled: false,\\n\\n\\t\\tfiles: {},\\n\\n\\t\\tadd: function ( key, file ) {\\n\\n\\t\\t\\tif ( this.enabled === false ) return;\\n\\n\\t\\t\\t// console.log( 'THREE.Cache', 'Adding key:', key );\\n\\n\\t\\t\\tthis.files[ key ] = file;\\n\\n\\t\\t},\\n\\n\\t\\tget: function ( key ) {\\n\\n\\t\\t\\tif ( this.enabled === false ) return;\\n\\n\\t\\t\\t// console.log( 'THREE.Cache', 'Checking key:', key );\\n\\n\\t\\t\\treturn this.files[ key ];\\n\\n\\t\\t},\\n\\n\\t\\tremove: function ( key ) {\\n\\n\\t\\t\\tdelete this.files[ key ];\\n\\n\\t\\t},\\n\\n\\t\\tclear: function () {\\n\\n\\t\\t\\tthis.files = {};\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction LoadingManager( onLoad, onProgress, onError ) {\\n\\n\\t\\tvar scope = this;\\n\\n\\t\\tvar isLoading = false;\\n\\t\\tvar itemsLoaded = 0;\\n\\t\\tvar itemsTotal = 0;\\n\\t\\tvar urlModifier = undefined;\\n\\n\\t\\tthis.onStart = undefined;\\n\\t\\tthis.onLoad = onLoad;\\n\\t\\tthis.onProgress = onProgress;\\n\\t\\tthis.onError = onError;\\n\\n\\t\\tthis.itemStart = function ( url ) {\\n\\n\\t\\t\\titemsTotal ++;\\n\\n\\t\\t\\tif ( isLoading === false ) {\\n\\n\\t\\t\\t\\tif ( scope.onStart !== undefined ) {\\n\\n\\t\\t\\t\\t\\tscope.onStart( url, itemsLoaded, itemsTotal );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tisLoading = true;\\n\\n\\t\\t};\\n\\n\\t\\tthis.itemEnd = function ( url ) {\\n\\n\\t\\t\\titemsLoaded ++;\\n\\n\\t\\t\\tif ( scope.onProgress !== undefined ) {\\n\\n\\t\\t\\t\\tscope.onProgress( url, itemsLoaded, itemsTotal );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( itemsLoaded === itemsTotal ) {\\n\\n\\t\\t\\t\\tisLoading = false;\\n\\n\\t\\t\\t\\tif ( scope.onLoad !== undefined ) {\\n\\n\\t\\t\\t\\t\\tscope.onLoad();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t\\tthis.itemError = function ( url ) {\\n\\n\\t\\t\\tif ( scope.onError !== undefined ) {\\n\\n\\t\\t\\t\\tscope.onError( url );\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t\\tthis.resolveURL = function ( url ) {\\n\\n\\t\\t\\tif ( urlModifier ) {\\n\\n\\t\\t\\t\\treturn urlModifier( url );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn url;\\n\\n\\t\\t};\\n\\n\\t\\tthis.setURLModifier = function ( transform ) {\\n\\n\\t\\t\\turlModifier = transform;\\n\\t\\t\\treturn this;\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\tvar DefaultLoadingManager = new LoadingManager();\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tvar loading = {};\\n\\n\\tfunction FileLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t}\\n\\n\\tObject.assign( FileLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tif ( url === undefined ) url = '';\\n\\n\\t\\t\\tif ( this.path !== undefined ) url = this.path + url;\\n\\n\\t\\t\\turl = this.manager.resolveURL( url );\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar cached = Cache.get( url );\\n\\n\\t\\t\\tif ( cached !== undefined ) {\\n\\n\\t\\t\\t\\tscope.manager.itemStart( url );\\n\\n\\t\\t\\t\\tsetTimeout( function () {\\n\\n\\t\\t\\t\\t\\tif ( onLoad ) onLoad( cached );\\n\\n\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t\\t}, 0 );\\n\\n\\t\\t\\t\\treturn cached;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Check if request is duplicate\\n\\n\\t\\t\\tif ( loading[ url ] !== undefined ) {\\n\\n\\t\\t\\t\\tloading[ url ].push( {\\n\\n\\t\\t\\t\\t\\tonLoad: onLoad,\\n\\t\\t\\t\\t\\tonProgress: onProgress,\\n\\t\\t\\t\\t\\tonError: onError\\n\\n\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Check for data: URI\\n\\t\\t\\tvar dataUriRegex = /^data:(.*?)(;base64)?,(.*)$/;\\n\\t\\t\\tvar dataUriRegexResult = url.match( dataUriRegex );\\n\\n\\t\\t\\t// Safari can not handle Data URIs through XMLHttpRequest so process manually\\n\\t\\t\\tif ( dataUriRegexResult ) {\\n\\n\\t\\t\\t\\tvar mimeType = dataUriRegexResult[ 1 ];\\n\\t\\t\\t\\tvar isBase64 = !! dataUriRegexResult[ 2 ];\\n\\t\\t\\t\\tvar data = dataUriRegexResult[ 3 ];\\n\\n\\t\\t\\t\\tdata = window.decodeURIComponent( data );\\n\\n\\t\\t\\t\\tif ( isBase64 ) data = window.atob( data );\\n\\n\\t\\t\\t\\ttry {\\n\\n\\t\\t\\t\\t\\tvar response;\\n\\t\\t\\t\\t\\tvar responseType = ( this.responseType || '' ).toLowerCase();\\n\\n\\t\\t\\t\\t\\tswitch ( responseType ) {\\n\\n\\t\\t\\t\\t\\t\\tcase 'arraybuffer':\\n\\t\\t\\t\\t\\t\\tcase 'blob':\\n\\n\\t\\t\\t\\t\\t\\t\\tvar view = new Uint8Array( data.length );\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var i = 0; i < data.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tview[ i ] = data.charCodeAt( i );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( responseType === 'blob' ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tresponse = new Blob( [ view.buffer ], { type: mimeType } );\\n\\n\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tresponse = view.buffer;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'document':\\n\\n\\t\\t\\t\\t\\t\\t\\tvar parser = new DOMParser();\\n\\t\\t\\t\\t\\t\\t\\tresponse = parser.parseFromString( data, mimeType );\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'json':\\n\\n\\t\\t\\t\\t\\t\\t\\tresponse = JSON.parse( data );\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tdefault: // 'text' or other\\n\\n\\t\\t\\t\\t\\t\\t\\tresponse = data;\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t// Wait for next browser tick like standard XMLHttpRequest event dispatching does\\n\\t\\t\\t\\t\\twindow.setTimeout( function () {\\n\\n\\t\\t\\t\\t\\t\\tif ( onLoad ) onLoad( response );\\n\\n\\t\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t\\t\\t}, 0 );\\n\\n\\t\\t\\t\\t} catch ( error ) {\\n\\n\\t\\t\\t\\t\\t// Wait for next browser tick like standard XMLHttpRequest event dispatching does\\n\\t\\t\\t\\t\\twindow.setTimeout( function () {\\n\\n\\t\\t\\t\\t\\t\\tif ( onError ) onError( error );\\n\\n\\t\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\t\\t\\t\\t\\t\\tscope.manager.itemError( url );\\n\\n\\t\\t\\t\\t\\t}, 0 );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// Initialise array for duplicate requests\\n\\n\\t\\t\\t\\tloading[ url ] = [];\\n\\n\\t\\t\\t\\tloading[ url ].push( {\\n\\n\\t\\t\\t\\t\\tonLoad: onLoad,\\n\\t\\t\\t\\t\\tonProgress: onProgress,\\n\\t\\t\\t\\t\\tonError: onError\\n\\n\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\tvar request = new XMLHttpRequest();\\n\\n\\t\\t\\t\\trequest.open( 'GET', url, true );\\n\\n\\t\\t\\t\\trequest.addEventListener( 'load', function ( event ) {\\n\\n\\t\\t\\t\\t\\tvar response = this.response;\\n\\n\\t\\t\\t\\t\\tCache.add( url, response );\\n\\n\\t\\t\\t\\t\\tvar callbacks = loading[ url ];\\n\\n\\t\\t\\t\\t\\tdelete loading[ url ];\\n\\n\\t\\t\\t\\t\\tif ( this.status === 200 ) {\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, il = callbacks.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar callback = callbacks[ i ];\\n\\t\\t\\t\\t\\t\\t\\tif ( callback.onLoad ) callback.onLoad( response );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t\\t\\t} else if ( this.status === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\t// Some browsers return HTTP Status 0 when using non-http protocol\\n\\t\\t\\t\\t\\t\\t// e.g. 'file://' or 'data://'. Handle as success.\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.FileLoader: HTTP Status 0 received.' );\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, il = callbacks.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar callback = callbacks[ i ];\\n\\t\\t\\t\\t\\t\\t\\tif ( callback.onLoad ) callback.onLoad( response );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, il = callbacks.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar callback = callbacks[ i ];\\n\\t\\t\\t\\t\\t\\t\\tif ( callback.onError ) callback.onError( event );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\t\\t\\t\\t\\t\\tscope.manager.itemError( url );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}, false );\\n\\n\\t\\t\\t\\trequest.addEventListener( 'progress', function ( event ) {\\n\\n\\t\\t\\t\\t\\tvar callbacks = loading[ url ];\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, il = callbacks.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar callback = callbacks[ i ];\\n\\t\\t\\t\\t\\t\\tif ( callback.onProgress ) callback.onProgress( event );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}, false );\\n\\n\\t\\t\\t\\trequest.addEventListener( 'error', function ( event ) {\\n\\n\\t\\t\\t\\t\\tvar callbacks = loading[ url ];\\n\\n\\t\\t\\t\\t\\tdelete loading[ url ];\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, il = callbacks.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar callback = callbacks[ i ];\\n\\t\\t\\t\\t\\t\\tif ( callback.onError ) callback.onError( event );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\t\\t\\t\\t\\tscope.manager.itemError( url );\\n\\n\\t\\t\\t\\t}, false );\\n\\n\\t\\t\\t\\tif ( this.responseType !== undefined ) request.responseType = this.responseType;\\n\\t\\t\\t\\tif ( this.withCredentials !== undefined ) request.withCredentials = this.withCredentials;\\n\\n\\t\\t\\t\\tif ( request.overrideMimeType ) request.overrideMimeType( this.mimeType !== undefined ? this.mimeType : 'text/plain' );\\n\\n\\t\\t\\t\\tfor ( var header in this.requestHeader ) {\\n\\n\\t\\t\\t\\t\\trequest.setRequestHeader( header, this.requestHeader[ header ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\trequest.send( null );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tscope.manager.itemStart( url );\\n\\n\\t\\t\\treturn request;\\n\\n\\t\\t},\\n\\n\\t\\tsetPath: function ( value ) {\\n\\n\\t\\t\\tthis.path = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetResponseType: function ( value ) {\\n\\n\\t\\t\\tthis.responseType = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetWithCredentials: function ( value ) {\\n\\n\\t\\t\\tthis.withCredentials = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetMimeType: function ( value ) {\\n\\n\\t\\t\\tthis.mimeType = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetRequestHeader: function ( value ) {\\n\\n\\t\\t\\tthis.requestHeader = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t *\\n\\t * Abstract Base class to block based textures loader (dds, pvr, ...)\\n\\t */\\n\\n\\tfunction CompressedTextureLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t\\t// override in sub classes\\n\\t\\tthis._parser = null;\\n\\n\\t}\\n\\n\\tObject.assign( CompressedTextureLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar images = [];\\n\\n\\t\\t\\tvar texture = new CompressedTexture();\\n\\t\\t\\ttexture.image = images;\\n\\n\\t\\t\\tvar loader = new FileLoader( this.manager );\\n\\t\\t\\tloader.setPath( this.path );\\n\\t\\t\\tloader.setResponseType( 'arraybuffer' );\\n\\n\\t\\t\\tfunction loadTexture( i ) {\\n\\n\\t\\t\\t\\tloader.load( url[ i ], function ( buffer ) {\\n\\n\\t\\t\\t\\t\\tvar texDatas = scope._parser( buffer, true );\\n\\n\\t\\t\\t\\t\\timages[ i ] = {\\n\\t\\t\\t\\t\\t\\twidth: texDatas.width,\\n\\t\\t\\t\\t\\t\\theight: texDatas.height,\\n\\t\\t\\t\\t\\t\\tformat: texDatas.format,\\n\\t\\t\\t\\t\\t\\tmipmaps: texDatas.mipmaps\\n\\t\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\t\\tloaded += 1;\\n\\n\\t\\t\\t\\t\\tif ( loaded === 6 ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( texDatas.mipmapCount === 1 )\\n\\t\\t\\t\\t\\t\\t\\ttexture.minFilter = LinearFilter;\\n\\n\\t\\t\\t\\t\\t\\ttexture.format = texDatas.format;\\n\\t\\t\\t\\t\\t\\ttexture.needsUpdate = true;\\n\\n\\t\\t\\t\\t\\t\\tif ( onLoad ) onLoad( texture );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( Array.isArray( url ) ) {\\n\\n\\t\\t\\t\\tvar loaded = 0;\\n\\n\\t\\t\\t\\tfor ( var i = 0, il = url.length; i < il; ++ i ) {\\n\\n\\t\\t\\t\\t\\tloadTexture( i );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// compressed cubemap texture stored in a single DDS file\\n\\n\\t\\t\\t\\tloader.load( url, function ( buffer ) {\\n\\n\\t\\t\\t\\t\\tvar texDatas = scope._parser( buffer, true );\\n\\n\\t\\t\\t\\t\\tif ( texDatas.isCubemap ) {\\n\\n\\t\\t\\t\\t\\t\\tvar faces = texDatas.mipmaps.length / texDatas.mipmapCount;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var f = 0; f < faces; f ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\timages[ f ] = { mipmaps: [] };\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var i = 0; i < texDatas.mipmapCount; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\timages[ f ].mipmaps.push( texDatas.mipmaps[ f * texDatas.mipmapCount + i ] );\\n\\t\\t\\t\\t\\t\\t\\t\\timages[ f ].format = texDatas.format;\\n\\t\\t\\t\\t\\t\\t\\t\\timages[ f ].width = texDatas.width;\\n\\t\\t\\t\\t\\t\\t\\t\\timages[ f ].height = texDatas.height;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\ttexture.image.width = texDatas.width;\\n\\t\\t\\t\\t\\t\\ttexture.image.height = texDatas.height;\\n\\t\\t\\t\\t\\t\\ttexture.mipmaps = texDatas.mipmaps;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( texDatas.mipmapCount === 1 ) {\\n\\n\\t\\t\\t\\t\\t\\ttexture.minFilter = LinearFilter;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\ttexture.format = texDatas.format;\\n\\t\\t\\t\\t\\ttexture.needsUpdate = true;\\n\\n\\t\\t\\t\\t\\tif ( onLoad ) onLoad( texture );\\n\\n\\t\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn texture;\\n\\n\\t\\t},\\n\\n\\t\\tsetPath: function ( value ) {\\n\\n\\t\\t\\tthis.path = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author Nikos M. / https://github.com/foo123/\\n\\t *\\n\\t * Abstract Base class to load generic binary textures formats (rgbe, hdr, ...)\\n\\t */\\n\\n\\tfunction DataTextureLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t\\t// override in sub classes\\n\\t\\tthis._parser = null;\\n\\n\\t}\\n\\n\\tObject.assign( DataTextureLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar texture = new DataTexture();\\n\\n\\t\\t\\tvar loader = new FileLoader( this.manager );\\n\\t\\t\\tloader.setResponseType( 'arraybuffer' );\\n\\n\\t\\t\\tloader.load( url, function ( buffer ) {\\n\\n\\t\\t\\t\\tvar texData = scope._parser( buffer );\\n\\n\\t\\t\\t\\tif ( ! texData ) return;\\n\\n\\t\\t\\t\\tif ( undefined !== texData.image ) {\\n\\n\\t\\t\\t\\t\\ttexture.image = texData.image;\\n\\n\\t\\t\\t\\t} else if ( undefined !== texData.data ) {\\n\\n\\t\\t\\t\\t\\ttexture.image.width = texData.width;\\n\\t\\t\\t\\t\\ttexture.image.height = texData.height;\\n\\t\\t\\t\\t\\ttexture.image.data = texData.data;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\ttexture.wrapS = undefined !== texData.wrapS ? texData.wrapS : ClampToEdgeWrapping;\\n\\t\\t\\t\\ttexture.wrapT = undefined !== texData.wrapT ? texData.wrapT : ClampToEdgeWrapping;\\n\\n\\t\\t\\t\\ttexture.magFilter = undefined !== texData.magFilter ? texData.magFilter : LinearFilter;\\n\\t\\t\\t\\ttexture.minFilter = undefined !== texData.minFilter ? texData.minFilter : LinearMipMapLinearFilter;\\n\\n\\t\\t\\t\\ttexture.anisotropy = undefined !== texData.anisotropy ? texData.anisotropy : 1;\\n\\n\\t\\t\\t\\tif ( undefined !== texData.format ) {\\n\\n\\t\\t\\t\\t\\ttexture.format = texData.format;\\n\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\tif ( undefined !== texData.type ) {\\n\\n\\t\\t\\t\\t\\ttexture.type = texData.type;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( undefined !== texData.mipmaps ) {\\n\\n\\t\\t\\t\\t\\ttexture.mipmaps = texData.mipmaps;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( 1 === texData.mipmapCount ) {\\n\\n\\t\\t\\t\\t\\ttexture.minFilter = LinearFilter;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\ttexture.needsUpdate = true;\\n\\n\\t\\t\\t\\tif ( onLoad ) onLoad( texture, texData );\\n\\n\\t\\t\\t}, onProgress, onError );\\n\\n\\n\\t\\t\\treturn texture;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction ImageLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t}\\n\\n\\tObject.assign( ImageLoader.prototype, {\\n\\n\\t\\tcrossOrigin: 'Anonymous',\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tif ( url === undefined ) url = '';\\n\\n\\t\\t\\tif ( this.path !== undefined ) url = this.path + url;\\n\\n\\t\\t\\turl = this.manager.resolveURL( url );\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar cached = Cache.get( url );\\n\\n\\t\\t\\tif ( cached !== undefined ) {\\n\\n\\t\\t\\t\\tscope.manager.itemStart( url );\\n\\n\\t\\t\\t\\tsetTimeout( function () {\\n\\n\\t\\t\\t\\t\\tif ( onLoad ) onLoad( cached );\\n\\n\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t\\t}, 0 );\\n\\n\\t\\t\\t\\treturn cached;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar image = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'img' );\\n\\n\\t\\t\\timage.addEventListener( 'load', function () {\\n\\n\\t\\t\\t\\tCache.add( url, this );\\n\\n\\t\\t\\t\\tif ( onLoad ) onLoad( this );\\n\\n\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t}, false );\\n\\n\\t\\t\\t/*\\n\\t\\t\\timage.addEventListener( 'progress', function ( event ) {\\n\\n\\t\\t\\t\\tif ( onProgress ) onProgress( event );\\n\\n\\t\\t\\t}, false );\\n\\t\\t\\t*/\\n\\n\\t\\t\\timage.addEventListener( 'error', function ( event ) {\\n\\n\\t\\t\\t\\tif ( onError ) onError( event );\\n\\n\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\t\\t\\t\\tscope.manager.itemError( url );\\n\\n\\t\\t\\t}, false );\\n\\n\\t\\t\\tif ( url.substr( 0, 5 ) !== 'data:' ) {\\n\\n\\t\\t\\t\\tif ( this.crossOrigin !== undefined ) image.crossOrigin = this.crossOrigin;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tscope.manager.itemStart( url );\\n\\n\\t\\t\\timage.src = url;\\n\\n\\t\\t\\treturn image;\\n\\n\\t\\t},\\n\\n\\t\\tsetCrossOrigin: function ( value ) {\\n\\n\\t\\t\\tthis.crossOrigin = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetPath: function ( value ) {\\n\\n\\t\\t\\tthis.path = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction CubeTextureLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t}\\n\\n\\tObject.assign( CubeTextureLoader.prototype, {\\n\\n\\t\\tcrossOrigin: 'Anonymous',\\n\\n\\t\\tload: function ( urls, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar texture = new CubeTexture();\\n\\n\\t\\t\\tvar loader = new ImageLoader( this.manager );\\n\\t\\t\\tloader.setCrossOrigin( this.crossOrigin );\\n\\t\\t\\tloader.setPath( this.path );\\n\\n\\t\\t\\tvar loaded = 0;\\n\\n\\t\\t\\tfunction loadTexture( i ) {\\n\\n\\t\\t\\t\\tloader.load( urls[ i ], function ( image ) {\\n\\n\\t\\t\\t\\t\\ttexture.images[ i ] = image;\\n\\n\\t\\t\\t\\t\\tloaded ++;\\n\\n\\t\\t\\t\\t\\tif ( loaded === 6 ) {\\n\\n\\t\\t\\t\\t\\t\\ttexture.needsUpdate = true;\\n\\n\\t\\t\\t\\t\\t\\tif ( onLoad ) onLoad( texture );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}, undefined, onError );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = 0; i < urls.length; ++ i ) {\\n\\n\\t\\t\\t\\tloadTexture( i );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn texture;\\n\\n\\t\\t},\\n\\n\\t\\tsetCrossOrigin: function ( value ) {\\n\\n\\t\\t\\tthis.crossOrigin = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetPath: function ( value ) {\\n\\n\\t\\t\\tthis.path = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction TextureLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t}\\n\\n\\tObject.assign( TextureLoader.prototype, {\\n\\n\\t\\tcrossOrigin: 'Anonymous',\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar texture = new Texture();\\n\\n\\t\\t\\tvar loader = new ImageLoader( this.manager );\\n\\t\\t\\tloader.setCrossOrigin( this.crossOrigin );\\n\\t\\t\\tloader.setPath( this.path );\\n\\n\\t\\t\\tloader.load( url, function ( image ) {\\n\\n\\t\\t\\t\\ttexture.image = image;\\n\\n\\t\\t\\t\\t// JPEGs can't have an alpha channel, so memory can be saved by storing them as RGB.\\n\\t\\t\\t\\tvar isJPEG = url.search( /\\\\.(jpg|jpeg)$/ ) > 0 || url.search( /^data\\\\:image\\\\/jpeg/ ) === 0;\\n\\n\\t\\t\\t\\ttexture.format = isJPEG ? RGBFormat : RGBAFormat;\\n\\t\\t\\t\\ttexture.needsUpdate = true;\\n\\n\\t\\t\\t\\tif ( onLoad !== undefined ) {\\n\\n\\t\\t\\t\\t\\tonLoad( texture );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t\\treturn texture;\\n\\n\\t\\t},\\n\\n\\t\\tsetCrossOrigin: function ( value ) {\\n\\n\\t\\t\\tthis.crossOrigin = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetPath: function ( value ) {\\n\\n\\t\\t\\tthis.path = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t * Extensible curve object\\n\\t *\\n\\t * Some common of curve methods:\\n\\t * .getPoint( t, optionalTarget ), .getTangent( t )\\n\\t * .getPointAt( u, optionalTarget ), .getTangentAt( u )\\n\\t * .getPoints(), .getSpacedPoints()\\n\\t * .getLength()\\n\\t * .updateArcLengths()\\n\\t *\\n\\t * This following curves inherit from THREE.Curve:\\n\\t *\\n\\t * -- 2D curves --\\n\\t * THREE.ArcCurve\\n\\t * THREE.CubicBezierCurve\\n\\t * THREE.EllipseCurve\\n\\t * THREE.LineCurve\\n\\t * THREE.QuadraticBezierCurve\\n\\t * THREE.SplineCurve\\n\\t *\\n\\t * -- 3D curves --\\n\\t * THREE.CatmullRomCurve3\\n\\t * THREE.CubicBezierCurve3\\n\\t * THREE.LineCurve3\\n\\t * THREE.QuadraticBezierCurve3\\n\\t *\\n\\t * A series of curves can be represented as a THREE.CurvePath.\\n\\t *\\n\\t **/\\n\\n\\t/**************************************************************\\n\\t *\\tAbstract Curve base class\\n\\t **************************************************************/\\n\\n\\tfunction Curve() {\\n\\n\\t\\tthis.type = 'Curve';\\n\\n\\t\\tthis.arcLengthDivisions = 200;\\n\\n\\t}\\n\\n\\tObject.assign( Curve.prototype, {\\n\\n\\t\\t// Virtual base class method to overwrite and implement in subclasses\\n\\t\\t//\\t- t [0 .. 1]\\n\\n\\t\\tgetPoint: function ( /* t, optionalTarget */ ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Curve: .getPoint() not implemented.' );\\n\\t\\t\\treturn null;\\n\\n\\t\\t},\\n\\n\\t\\t// Get point at relative position in curve according to arc length\\n\\t\\t// - u [0 .. 1]\\n\\n\\t\\tgetPointAt: function ( u, optionalTarget ) {\\n\\n\\t\\t\\tvar t = this.getUtoTmapping( u );\\n\\t\\t\\treturn this.getPoint( t, optionalTarget );\\n\\n\\t\\t},\\n\\n\\t\\t// Get sequence of points using getPoint( t )\\n\\n\\t\\tgetPoints: function ( divisions ) {\\n\\n\\t\\t\\tif ( divisions === undefined ) divisions = 5;\\n\\n\\t\\t\\tvar points = [];\\n\\n\\t\\t\\tfor ( var d = 0; d <= divisions; d ++ ) {\\n\\n\\t\\t\\t\\tpoints.push( this.getPoint( d / divisions ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn points;\\n\\n\\t\\t},\\n\\n\\t\\t// Get sequence of points using getPointAt( u )\\n\\n\\t\\tgetSpacedPoints: function ( divisions ) {\\n\\n\\t\\t\\tif ( divisions === undefined ) divisions = 5;\\n\\n\\t\\t\\tvar points = [];\\n\\n\\t\\t\\tfor ( var d = 0; d <= divisions; d ++ ) {\\n\\n\\t\\t\\t\\tpoints.push( this.getPointAt( d / divisions ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn points;\\n\\n\\t\\t},\\n\\n\\t\\t// Get total curve arc length\\n\\n\\t\\tgetLength: function () {\\n\\n\\t\\t\\tvar lengths = this.getLengths();\\n\\t\\t\\treturn lengths[ lengths.length - 1 ];\\n\\n\\t\\t},\\n\\n\\t\\t// Get list of cumulative segment lengths\\n\\n\\t\\tgetLengths: function ( divisions ) {\\n\\n\\t\\t\\tif ( divisions === undefined ) divisions = this.arcLengthDivisions;\\n\\n\\t\\t\\tif ( this.cacheArcLengths &&\\n\\t\\t\\t\\t( this.cacheArcLengths.length === divisions + 1 ) &&\\n\\t\\t\\t\\t! this.needsUpdate ) {\\n\\n\\t\\t\\t\\treturn this.cacheArcLengths;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.needsUpdate = false;\\n\\n\\t\\t\\tvar cache = [];\\n\\t\\t\\tvar current, last = this.getPoint( 0 );\\n\\t\\t\\tvar p, sum = 0;\\n\\n\\t\\t\\tcache.push( 0 );\\n\\n\\t\\t\\tfor ( p = 1; p <= divisions; p ++ ) {\\n\\n\\t\\t\\t\\tcurrent = this.getPoint( p / divisions );\\n\\t\\t\\t\\tsum += current.distanceTo( last );\\n\\t\\t\\t\\tcache.push( sum );\\n\\t\\t\\t\\tlast = current;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.cacheArcLengths = cache;\\n\\n\\t\\t\\treturn cache; // { sums: cache, sum: sum }; Sum is in the last element.\\n\\n\\t\\t},\\n\\n\\t\\tupdateArcLengths: function () {\\n\\n\\t\\t\\tthis.needsUpdate = true;\\n\\t\\t\\tthis.getLengths();\\n\\n\\t\\t},\\n\\n\\t\\t// Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equidistant\\n\\n\\t\\tgetUtoTmapping: function ( u, distance ) {\\n\\n\\t\\t\\tvar arcLengths = this.getLengths();\\n\\n\\t\\t\\tvar i = 0, il = arcLengths.length;\\n\\n\\t\\t\\tvar targetArcLength; // The targeted u distance value to get\\n\\n\\t\\t\\tif ( distance ) {\\n\\n\\t\\t\\t\\ttargetArcLength = distance;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\ttargetArcLength = u * arcLengths[ il - 1 ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// binary search for the index with largest value smaller than target u distance\\n\\n\\t\\t\\tvar low = 0, high = il - 1, comparison;\\n\\n\\t\\t\\twhile ( low <= high ) {\\n\\n\\t\\t\\t\\ti = Math.floor( low + ( high - low ) / 2 ); // less likely to overflow, though probably not issue here, JS doesn't really have integers, all numbers are floats\\n\\n\\t\\t\\t\\tcomparison = arcLengths[ i ] - targetArcLength;\\n\\n\\t\\t\\t\\tif ( comparison < 0 ) {\\n\\n\\t\\t\\t\\t\\tlow = i + 1;\\n\\n\\t\\t\\t\\t} else if ( comparison > 0 ) {\\n\\n\\t\\t\\t\\t\\thigh = i - 1;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\thigh = i;\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t// DONE\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\ti = high;\\n\\n\\t\\t\\tif ( arcLengths[ i ] === targetArcLength ) {\\n\\n\\t\\t\\t\\treturn i / ( il - 1 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// we could get finer grain at lengths, or use simple interpolation between two points\\n\\n\\t\\t\\tvar lengthBefore = arcLengths[ i ];\\n\\t\\t\\tvar lengthAfter = arcLengths[ i + 1 ];\\n\\n\\t\\t\\tvar segmentLength = lengthAfter - lengthBefore;\\n\\n\\t\\t\\t// determine where we are between the 'before' and 'after' points\\n\\n\\t\\t\\tvar segmentFraction = ( targetArcLength - lengthBefore ) / segmentLength;\\n\\n\\t\\t\\t// add that fractional amount to t\\n\\n\\t\\t\\tvar t = ( i + segmentFraction ) / ( il - 1 );\\n\\n\\t\\t\\treturn t;\\n\\n\\t\\t},\\n\\n\\t\\t// Returns a unit vector tangent at t\\n\\t\\t// In case any sub curve does not implement its tangent derivation,\\n\\t\\t// 2 points a small delta apart will be used to find its gradient\\n\\t\\t// which seems to give a reasonable approximation\\n\\n\\t\\tgetTangent: function ( t ) {\\n\\n\\t\\t\\tvar delta = 0.0001;\\n\\t\\t\\tvar t1 = t - delta;\\n\\t\\t\\tvar t2 = t + delta;\\n\\n\\t\\t\\t// Capping in case of danger\\n\\n\\t\\t\\tif ( t1 < 0 ) t1 = 0;\\n\\t\\t\\tif ( t2 > 1 ) t2 = 1;\\n\\n\\t\\t\\tvar pt1 = this.getPoint( t1 );\\n\\t\\t\\tvar pt2 = this.getPoint( t2 );\\n\\n\\t\\t\\tvar vec = pt2.clone().sub( pt1 );\\n\\t\\t\\treturn vec.normalize();\\n\\n\\t\\t},\\n\\n\\t\\tgetTangentAt: function ( u ) {\\n\\n\\t\\t\\tvar t = this.getUtoTmapping( u );\\n\\t\\t\\treturn this.getTangent( t );\\n\\n\\t\\t},\\n\\n\\t\\tcomputeFrenetFrames: function ( segments, closed ) {\\n\\n\\t\\t\\t// see http://www.cs.indiana.edu/pub/techreports/TR425.pdf\\n\\n\\t\\t\\tvar normal = new Vector3();\\n\\n\\t\\t\\tvar tangents = [];\\n\\t\\t\\tvar normals = [];\\n\\t\\t\\tvar binormals = [];\\n\\n\\t\\t\\tvar vec = new Vector3();\\n\\t\\t\\tvar mat = new Matrix4();\\n\\n\\t\\t\\tvar i, u, theta;\\n\\n\\t\\t\\t// compute the tangent vectors for each segment on the curve\\n\\n\\t\\t\\tfor ( i = 0; i <= segments; i ++ ) {\\n\\n\\t\\t\\t\\tu = i / segments;\\n\\n\\t\\t\\t\\ttangents[ i ] = this.getTangentAt( u );\\n\\t\\t\\t\\ttangents[ i ].normalize();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// select an initial normal vector perpendicular to the first tangent vector,\\n\\t\\t\\t// and in the direction of the minimum tangent xyz component\\n\\n\\t\\t\\tnormals[ 0 ] = new Vector3();\\n\\t\\t\\tbinormals[ 0 ] = new Vector3();\\n\\t\\t\\tvar min = Number.MAX_VALUE;\\n\\t\\t\\tvar tx = Math.abs( tangents[ 0 ].x );\\n\\t\\t\\tvar ty = Math.abs( tangents[ 0 ].y );\\n\\t\\t\\tvar tz = Math.abs( tangents[ 0 ].z );\\n\\n\\t\\t\\tif ( tx <= min ) {\\n\\n\\t\\t\\t\\tmin = tx;\\n\\t\\t\\t\\tnormal.set( 1, 0, 0 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( ty <= min ) {\\n\\n\\t\\t\\t\\tmin = ty;\\n\\t\\t\\t\\tnormal.set( 0, 1, 0 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( tz <= min ) {\\n\\n\\t\\t\\t\\tnormal.set( 0, 0, 1 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvec.crossVectors( tangents[ 0 ], normal ).normalize();\\n\\n\\t\\t\\tnormals[ 0 ].crossVectors( tangents[ 0 ], vec );\\n\\t\\t\\tbinormals[ 0 ].crossVectors( tangents[ 0 ], normals[ 0 ] );\\n\\n\\n\\t\\t\\t// compute the slowly-varying normal and binormal vectors for each segment on the curve\\n\\n\\t\\t\\tfor ( i = 1; i <= segments; i ++ ) {\\n\\n\\t\\t\\t\\tnormals[ i ] = normals[ i - 1 ].clone();\\n\\n\\t\\t\\t\\tbinormals[ i ] = binormals[ i - 1 ].clone();\\n\\n\\t\\t\\t\\tvec.crossVectors( tangents[ i - 1 ], tangents[ i ] );\\n\\n\\t\\t\\t\\tif ( vec.length() > Number.EPSILON ) {\\n\\n\\t\\t\\t\\t\\tvec.normalize();\\n\\n\\t\\t\\t\\t\\ttheta = Math.acos( _Math.clamp( tangents[ i - 1 ].dot( tangents[ i ] ), - 1, 1 ) ); // clamp for floating pt errors\\n\\n\\t\\t\\t\\t\\tnormals[ i ].applyMatrix4( mat.makeRotationAxis( vec, theta ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tbinormals[ i ].crossVectors( tangents[ i ], normals[ i ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// if the curve is closed, postprocess the vectors so the first and last normal vectors are the same\\n\\n\\t\\t\\tif ( closed === true ) {\\n\\n\\t\\t\\t\\ttheta = Math.acos( _Math.clamp( normals[ 0 ].dot( normals[ segments ] ), - 1, 1 ) );\\n\\t\\t\\t\\ttheta /= segments;\\n\\n\\t\\t\\t\\tif ( tangents[ 0 ].dot( vec.crossVectors( normals[ 0 ], normals[ segments ] ) ) > 0 ) {\\n\\n\\t\\t\\t\\t\\ttheta = - theta;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfor ( i = 1; i <= segments; i ++ ) {\\n\\n\\t\\t\\t\\t\\t// twist a little...\\n\\t\\t\\t\\t\\tnormals[ i ].applyMatrix4( mat.makeRotationAxis( tangents[ i ], theta * i ) );\\n\\t\\t\\t\\t\\tbinormals[ i ].crossVectors( tangents[ i ], normals[ i ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn {\\n\\t\\t\\t\\ttangents: tangents,\\n\\t\\t\\t\\tnormals: normals,\\n\\t\\t\\t\\tbinormals: binormals\\n\\t\\t\\t};\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tthis.arcLengthDivisions = source.arcLengthDivisions;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function () {\\n\\n\\t\\t\\tvar data = {\\n\\t\\t\\t\\tmetadata: {\\n\\t\\t\\t\\t\\tversion: 4.5,\\n\\t\\t\\t\\t\\ttype: 'Curve',\\n\\t\\t\\t\\t\\tgenerator: 'Curve.toJSON'\\n\\t\\t\\t\\t}\\n\\t\\t\\t};\\n\\n\\t\\t\\tdata.arcLengthDivisions = this.arcLengthDivisions;\\n\\t\\t\\tdata.type = this.type;\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t},\\n\\n\\t\\tfromJSON: function ( json ) {\\n\\n\\t\\t\\tthis.arcLengthDivisions = json.arcLengthDivisions;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tfunction EllipseCurve( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'EllipseCurve';\\n\\n\\t\\tthis.aX = aX || 0;\\n\\t\\tthis.aY = aY || 0;\\n\\n\\t\\tthis.xRadius = xRadius || 1;\\n\\t\\tthis.yRadius = yRadius || 1;\\n\\n\\t\\tthis.aStartAngle = aStartAngle || 0;\\n\\t\\tthis.aEndAngle = aEndAngle || 2 * Math.PI;\\n\\n\\t\\tthis.aClockwise = aClockwise || false;\\n\\n\\t\\tthis.aRotation = aRotation || 0;\\n\\n\\t}\\n\\n\\tEllipseCurve.prototype = Object.create( Curve.prototype );\\n\\tEllipseCurve.prototype.constructor = EllipseCurve;\\n\\n\\tEllipseCurve.prototype.isEllipseCurve = true;\\n\\n\\tEllipseCurve.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector2();\\n\\n\\t\\tvar twoPi = Math.PI * 2;\\n\\t\\tvar deltaAngle = this.aEndAngle - this.aStartAngle;\\n\\t\\tvar samePoints = Math.abs( deltaAngle ) < Number.EPSILON;\\n\\n\\t\\t// ensures that deltaAngle is 0 .. 2 PI\\n\\t\\twhile ( deltaAngle < 0 ) deltaAngle += twoPi;\\n\\t\\twhile ( deltaAngle > twoPi ) deltaAngle -= twoPi;\\n\\n\\t\\tif ( deltaAngle < Number.EPSILON ) {\\n\\n\\t\\t\\tif ( samePoints ) {\\n\\n\\t\\t\\t\\tdeltaAngle = 0;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tdeltaAngle = twoPi;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tif ( this.aClockwise === true && ! samePoints ) {\\n\\n\\t\\t\\tif ( deltaAngle === twoPi ) {\\n\\n\\t\\t\\t\\tdeltaAngle = - twoPi;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tdeltaAngle = deltaAngle - twoPi;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tvar angle = this.aStartAngle + t * deltaAngle;\\n\\t\\tvar x = this.aX + this.xRadius * Math.cos( angle );\\n\\t\\tvar y = this.aY + this.yRadius * Math.sin( angle );\\n\\n\\t\\tif ( this.aRotation !== 0 ) {\\n\\n\\t\\t\\tvar cos = Math.cos( this.aRotation );\\n\\t\\t\\tvar sin = Math.sin( this.aRotation );\\n\\n\\t\\t\\tvar tx = x - this.aX;\\n\\t\\t\\tvar ty = y - this.aY;\\n\\n\\t\\t\\t// Rotate the point about the center of the ellipse.\\n\\t\\t\\tx = tx * cos - ty * sin + this.aX;\\n\\t\\t\\ty = tx * sin + ty * cos + this.aY;\\n\\n\\t\\t}\\n\\n\\t\\treturn point.set( x, y );\\n\\n\\t};\\n\\n\\tEllipseCurve.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.aX = source.aX;\\n\\t\\tthis.aY = source.aY;\\n\\n\\t\\tthis.xRadius = source.xRadius;\\n\\t\\tthis.yRadius = source.yRadius;\\n\\n\\t\\tthis.aStartAngle = source.aStartAngle;\\n\\t\\tthis.aEndAngle = source.aEndAngle;\\n\\n\\t\\tthis.aClockwise = source.aClockwise;\\n\\n\\t\\tthis.aRotation = source.aRotation;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\n\\tEllipseCurve.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.aX = this.aX;\\n\\t\\tdata.aY = this.aY;\\n\\n\\t\\tdata.xRadius = this.xRadius;\\n\\t\\tdata.yRadius = this.yRadius;\\n\\n\\t\\tdata.aStartAngle = this.aStartAngle;\\n\\t\\tdata.aEndAngle = this.aEndAngle;\\n\\n\\t\\tdata.aClockwise = this.aClockwise;\\n\\n\\t\\tdata.aRotation = this.aRotation;\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tEllipseCurve.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.aX = json.aX;\\n\\t\\tthis.aY = json.aY;\\n\\n\\t\\tthis.xRadius = json.xRadius;\\n\\t\\tthis.yRadius = json.yRadius;\\n\\n\\t\\tthis.aStartAngle = json.aStartAngle;\\n\\t\\tthis.aEndAngle = json.aEndAngle;\\n\\n\\t\\tthis.aClockwise = json.aClockwise;\\n\\n\\t\\tthis.aRotation = json.aRotation;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tfunction ArcCurve( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {\\n\\n\\t\\tEllipseCurve.call( this, aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise );\\n\\n\\t\\tthis.type = 'ArcCurve';\\n\\n\\t}\\n\\n\\tArcCurve.prototype = Object.create( EllipseCurve.prototype );\\n\\tArcCurve.prototype.constructor = ArcCurve;\\n\\n\\tArcCurve.prototype.isArcCurve = true;\\n\\n\\t/**\\n\\t * @author zz85 https://github.com/zz85\\n\\t *\\n\\t * Centripetal CatmullRom Curve - which is useful for avoiding\\n\\t * cusps and self-intersections in non-uniform catmull rom curves.\\n\\t * http://www.cemyuksel.com/research/catmullrom_param/catmullrom.pdf\\n\\t *\\n\\t * curve.type accepts centripetal(default), chordal and catmullrom\\n\\t * curve.tension is used for catmullrom which defaults to 0.5\\n\\t */\\n\\n\\n\\t/*\\n\\tBased on an optimized c++ solution in\\n\\t - http://stackoverflow.com/questions/9489736/catmull-rom-curve-with-no-cusps-and-no-self-intersections/\\n\\t - http://ideone.com/NoEbVM\\n\\n\\tThis CubicPoly class could be used for reusing some variables and calculations,\\n\\tbut for three.js curve use, it could be possible inlined and flatten into a single function call\\n\\twhich can be placed in CurveUtils.\\n\\t*/\\n\\n\\tfunction CubicPoly() {\\n\\n\\t\\tvar c0 = 0, c1 = 0, c2 = 0, c3 = 0;\\n\\n\\t\\t/*\\n\\t\\t * Compute coefficients for a cubic polynomial\\n\\t\\t *   p(s) = c0 + c1*s + c2*s^2 + c3*s^3\\n\\t\\t * such that\\n\\t\\t *   p(0) = x0, p(1) = x1\\n\\t\\t *  and\\n\\t\\t *   p'(0) = t0, p'(1) = t1.\\n\\t\\t */\\n\\t\\tfunction init( x0, x1, t0, t1 ) {\\n\\n\\t\\t\\tc0 = x0;\\n\\t\\t\\tc1 = t0;\\n\\t\\t\\tc2 = - 3 * x0 + 3 * x1 - 2 * t0 - t1;\\n\\t\\t\\tc3 = 2 * x0 - 2 * x1 + t0 + t1;\\n\\n\\t\\t}\\n\\n\\t\\treturn {\\n\\n\\t\\t\\tinitCatmullRom: function ( x0, x1, x2, x3, tension ) {\\n\\n\\t\\t\\t\\tinit( x1, x2, tension * ( x2 - x0 ), tension * ( x3 - x1 ) );\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tinitNonuniformCatmullRom: function ( x0, x1, x2, x3, dt0, dt1, dt2 ) {\\n\\n\\t\\t\\t\\t// compute tangents when parameterized in [t1,t2]\\n\\t\\t\\t\\tvar t1 = ( x1 - x0 ) / dt0 - ( x2 - x0 ) / ( dt0 + dt1 ) + ( x2 - x1 ) / dt1;\\n\\t\\t\\t\\tvar t2 = ( x2 - x1 ) / dt1 - ( x3 - x1 ) / ( dt1 + dt2 ) + ( x3 - x2 ) / dt2;\\n\\n\\t\\t\\t\\t// rescale tangents for parametrization in [0,1]\\n\\t\\t\\t\\tt1 *= dt1;\\n\\t\\t\\t\\tt2 *= dt1;\\n\\n\\t\\t\\t\\tinit( x1, x2, t1, t2 );\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tcalc: function ( t ) {\\n\\n\\t\\t\\t\\tvar t2 = t * t;\\n\\t\\t\\t\\tvar t3 = t2 * t;\\n\\t\\t\\t\\treturn c0 + c1 * t + c2 * t2 + c3 * t3;\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t//\\n\\n\\tvar tmp = new Vector3();\\n\\tvar px = new CubicPoly();\\n\\tvar py = new CubicPoly();\\n\\tvar pz = new CubicPoly();\\n\\n\\tfunction CatmullRomCurve3( points, closed, curveType, tension ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'CatmullRomCurve3';\\n\\n\\t\\tthis.points = points || [];\\n\\t\\tthis.closed = closed || false;\\n\\t\\tthis.curveType = curveType || 'centripetal';\\n\\t\\tthis.tension = tension || 0.5;\\n\\n\\t}\\n\\n\\tCatmullRomCurve3.prototype = Object.create( Curve.prototype );\\n\\tCatmullRomCurve3.prototype.constructor = CatmullRomCurve3;\\n\\n\\tCatmullRomCurve3.prototype.isCatmullRomCurve3 = true;\\n\\n\\tCatmullRomCurve3.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector3();\\n\\n\\t\\tvar points = this.points;\\n\\t\\tvar l = points.length;\\n\\n\\t\\tvar p = ( l - ( this.closed ? 0 : 1 ) ) * t;\\n\\t\\tvar intPoint = Math.floor( p );\\n\\t\\tvar weight = p - intPoint;\\n\\n\\t\\tif ( this.closed ) {\\n\\n\\t\\t\\tintPoint += intPoint > 0 ? 0 : ( Math.floor( Math.abs( intPoint ) / points.length ) + 1 ) * points.length;\\n\\n\\t\\t} else if ( weight === 0 && intPoint === l - 1 ) {\\n\\n\\t\\t\\tintPoint = l - 2;\\n\\t\\t\\tweight = 1;\\n\\n\\t\\t}\\n\\n\\t\\tvar p0, p1, p2, p3; // 4 points\\n\\n\\t\\tif ( this.closed || intPoint > 0 ) {\\n\\n\\t\\t\\tp0 = points[ ( intPoint - 1 ) % l ];\\n\\n\\t\\t} else {\\n\\n\\t\\t\\t// extrapolate first point\\n\\t\\t\\ttmp.subVectors( points[ 0 ], points[ 1 ] ).add( points[ 0 ] );\\n\\t\\t\\tp0 = tmp;\\n\\n\\t\\t}\\n\\n\\t\\tp1 = points[ intPoint % l ];\\n\\t\\tp2 = points[ ( intPoint + 1 ) % l ];\\n\\n\\t\\tif ( this.closed || intPoint + 2 < l ) {\\n\\n\\t\\t\\tp3 = points[ ( intPoint + 2 ) % l ];\\n\\n\\t\\t} else {\\n\\n\\t\\t\\t// extrapolate last point\\n\\t\\t\\ttmp.subVectors( points[ l - 1 ], points[ l - 2 ] ).add( points[ l - 1 ] );\\n\\t\\t\\tp3 = tmp;\\n\\n\\t\\t}\\n\\n\\t\\tif ( this.curveType === 'centripetal' || this.curveType === 'chordal' ) {\\n\\n\\t\\t\\t// init Centripetal / Chordal Catmull-Rom\\n\\t\\t\\tvar pow = this.curveType === 'chordal' ? 0.5 : 0.25;\\n\\t\\t\\tvar dt0 = Math.pow( p0.distanceToSquared( p1 ), pow );\\n\\t\\t\\tvar dt1 = Math.pow( p1.distanceToSquared( p2 ), pow );\\n\\t\\t\\tvar dt2 = Math.pow( p2.distanceToSquared( p3 ), pow );\\n\\n\\t\\t\\t// safety check for repeated points\\n\\t\\t\\tif ( dt1 < 1e-4 ) dt1 = 1.0;\\n\\t\\t\\tif ( dt0 < 1e-4 ) dt0 = dt1;\\n\\t\\t\\tif ( dt2 < 1e-4 ) dt2 = dt1;\\n\\n\\t\\t\\tpx.initNonuniformCatmullRom( p0.x, p1.x, p2.x, p3.x, dt0, dt1, dt2 );\\n\\t\\t\\tpy.initNonuniformCatmullRom( p0.y, p1.y, p2.y, p3.y, dt0, dt1, dt2 );\\n\\t\\t\\tpz.initNonuniformCatmullRom( p0.z, p1.z, p2.z, p3.z, dt0, dt1, dt2 );\\n\\n\\t\\t} else if ( this.curveType === 'catmullrom' ) {\\n\\n\\t\\t\\tpx.initCatmullRom( p0.x, p1.x, p2.x, p3.x, this.tension );\\n\\t\\t\\tpy.initCatmullRom( p0.y, p1.y, p2.y, p3.y, this.tension );\\n\\t\\t\\tpz.initCatmullRom( p0.z, p1.z, p2.z, p3.z, this.tension );\\n\\n\\t\\t}\\n\\n\\t\\tpoint.set(\\n\\t\\t\\tpx.calc( weight ),\\n\\t\\t\\tpy.calc( weight ),\\n\\t\\t\\tpz.calc( weight )\\n\\t\\t);\\n\\n\\t\\treturn point;\\n\\n\\t};\\n\\n\\tCatmullRomCurve3.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.points = [];\\n\\n\\t\\tfor ( var i = 0, l = source.points.length; i < l; i ++ ) {\\n\\n\\t\\t\\tvar point = source.points[ i ];\\n\\n\\t\\t\\tthis.points.push( point.clone() );\\n\\n\\t\\t}\\n\\n\\t\\tthis.closed = source.closed;\\n\\t\\tthis.curveType = source.curveType;\\n\\t\\tthis.tension = source.tension;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tCatmullRomCurve3.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.points = [];\\n\\n\\t\\tfor ( var i = 0, l = this.points.length; i < l; i ++ ) {\\n\\n\\t\\t\\tvar point = this.points[ i ];\\n\\t\\t\\tdata.points.push( point.toArray() );\\n\\n\\t\\t}\\n\\n\\t\\tdata.closed = this.closed;\\n\\t\\tdata.curveType = this.curveType;\\n\\t\\tdata.tension = this.tension;\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tCatmullRomCurve3.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.points = [];\\n\\n\\t\\tfor ( var i = 0, l = json.points.length; i < l; i ++ ) {\\n\\n\\t\\t\\tvar point = json.points[ i ];\\n\\t\\t\\tthis.points.push( new Vector3().fromArray( point ) );\\n\\n\\t\\t}\\n\\n\\t\\tthis.closed = json.closed;\\n\\t\\tthis.curveType = json.curveType;\\n\\t\\tthis.tension = json.tension;\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t *\\n\\t * Bezier Curves formulas obtained from\\n\\t * http://en.wikipedia.org/wiki/Bézier_curve\\n\\t */\\n\\n\\tfunction CatmullRom( t, p0, p1, p2, p3 ) {\\n\\n\\t\\tvar v0 = ( p2 - p0 ) * 0.5;\\n\\t\\tvar v1 = ( p3 - p1 ) * 0.5;\\n\\t\\tvar t2 = t * t;\\n\\t\\tvar t3 = t * t2;\\n\\t\\treturn ( 2 * p1 - 2 * p2 + v0 + v1 ) * t3 + ( - 3 * p1 + 3 * p2 - 2 * v0 - v1 ) * t2 + v0 * t + p1;\\n\\n\\t}\\n\\n\\t//\\n\\n\\tfunction QuadraticBezierP0( t, p ) {\\n\\n\\t\\tvar k = 1 - t;\\n\\t\\treturn k * k * p;\\n\\n\\t}\\n\\n\\tfunction QuadraticBezierP1( t, p ) {\\n\\n\\t\\treturn 2 * ( 1 - t ) * t * p;\\n\\n\\t}\\n\\n\\tfunction QuadraticBezierP2( t, p ) {\\n\\n\\t\\treturn t * t * p;\\n\\n\\t}\\n\\n\\tfunction QuadraticBezier( t, p0, p1, p2 ) {\\n\\n\\t\\treturn QuadraticBezierP0( t, p0 ) + QuadraticBezierP1( t, p1 ) +\\n\\t\\t\\tQuadraticBezierP2( t, p2 );\\n\\n\\t}\\n\\n\\t//\\n\\n\\tfunction CubicBezierP0( t, p ) {\\n\\n\\t\\tvar k = 1 - t;\\n\\t\\treturn k * k * k * p;\\n\\n\\t}\\n\\n\\tfunction CubicBezierP1( t, p ) {\\n\\n\\t\\tvar k = 1 - t;\\n\\t\\treturn 3 * k * k * t * p;\\n\\n\\t}\\n\\n\\tfunction CubicBezierP2( t, p ) {\\n\\n\\t\\treturn 3 * ( 1 - t ) * t * t * p;\\n\\n\\t}\\n\\n\\tfunction CubicBezierP3( t, p ) {\\n\\n\\t\\treturn t * t * t * p;\\n\\n\\t}\\n\\n\\tfunction CubicBezier( t, p0, p1, p2, p3 ) {\\n\\n\\t\\treturn CubicBezierP0( t, p0 ) + CubicBezierP1( t, p1 ) + CubicBezierP2( t, p2 ) +\\n\\t\\t\\tCubicBezierP3( t, p3 );\\n\\n\\t}\\n\\n\\tfunction CubicBezierCurve( v0, v1, v2, v3 ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'CubicBezierCurve';\\n\\n\\t\\tthis.v0 = v0 || new Vector2();\\n\\t\\tthis.v1 = v1 || new Vector2();\\n\\t\\tthis.v2 = v2 || new Vector2();\\n\\t\\tthis.v3 = v3 || new Vector2();\\n\\n\\t}\\n\\n\\tCubicBezierCurve.prototype = Object.create( Curve.prototype );\\n\\tCubicBezierCurve.prototype.constructor = CubicBezierCurve;\\n\\n\\tCubicBezierCurve.prototype.isCubicBezierCurve = true;\\n\\n\\tCubicBezierCurve.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector2();\\n\\n\\t\\tvar v0 = this.v0, v1 = this.v1, v2 = this.v2, v3 = this.v3;\\n\\n\\t\\tpoint.set(\\n\\t\\t\\tCubicBezier( t, v0.x, v1.x, v2.x, v3.x ),\\n\\t\\t\\tCubicBezier( t, v0.y, v1.y, v2.y, v3.y )\\n\\t\\t);\\n\\n\\t\\treturn point;\\n\\n\\t};\\n\\n\\tCubicBezierCurve.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.v0.copy( source.v0 );\\n\\t\\tthis.v1.copy( source.v1 );\\n\\t\\tthis.v2.copy( source.v2 );\\n\\t\\tthis.v3.copy( source.v3 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tCubicBezierCurve.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.v0 = this.v0.toArray();\\n\\t\\tdata.v1 = this.v1.toArray();\\n\\t\\tdata.v2 = this.v2.toArray();\\n\\t\\tdata.v3 = this.v3.toArray();\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tCubicBezierCurve.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.v0.fromArray( json.v0 );\\n\\t\\tthis.v1.fromArray( json.v1 );\\n\\t\\tthis.v2.fromArray( json.v2 );\\n\\t\\tthis.v3.fromArray( json.v3 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tfunction CubicBezierCurve3( v0, v1, v2, v3 ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'CubicBezierCurve3';\\n\\n\\t\\tthis.v0 = v0 || new Vector3();\\n\\t\\tthis.v1 = v1 || new Vector3();\\n\\t\\tthis.v2 = v2 || new Vector3();\\n\\t\\tthis.v3 = v3 || new Vector3();\\n\\n\\t}\\n\\n\\tCubicBezierCurve3.prototype = Object.create( Curve.prototype );\\n\\tCubicBezierCurve3.prototype.constructor = CubicBezierCurve3;\\n\\n\\tCubicBezierCurve3.prototype.isCubicBezierCurve3 = true;\\n\\n\\tCubicBezierCurve3.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector3();\\n\\n\\t\\tvar v0 = this.v0, v1 = this.v1, v2 = this.v2, v3 = this.v3;\\n\\n\\t\\tpoint.set(\\n\\t\\t\\tCubicBezier( t, v0.x, v1.x, v2.x, v3.x ),\\n\\t\\t\\tCubicBezier( t, v0.y, v1.y, v2.y, v3.y ),\\n\\t\\t\\tCubicBezier( t, v0.z, v1.z, v2.z, v3.z )\\n\\t\\t);\\n\\n\\t\\treturn point;\\n\\n\\t};\\n\\n\\tCubicBezierCurve3.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.v0.copy( source.v0 );\\n\\t\\tthis.v1.copy( source.v1 );\\n\\t\\tthis.v2.copy( source.v2 );\\n\\t\\tthis.v3.copy( source.v3 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tCubicBezierCurve3.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.v0 = this.v0.toArray();\\n\\t\\tdata.v1 = this.v1.toArray();\\n\\t\\tdata.v2 = this.v2.toArray();\\n\\t\\tdata.v3 = this.v3.toArray();\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tCubicBezierCurve3.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.v0.fromArray( json.v0 );\\n\\t\\tthis.v1.fromArray( json.v1 );\\n\\t\\tthis.v2.fromArray( json.v2 );\\n\\t\\tthis.v3.fromArray( json.v3 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tfunction LineCurve( v1, v2 ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'LineCurve';\\n\\n\\t\\tthis.v1 = v1 || new Vector2();\\n\\t\\tthis.v2 = v2 || new Vector2();\\n\\n\\t}\\n\\n\\tLineCurve.prototype = Object.create( Curve.prototype );\\n\\tLineCurve.prototype.constructor = LineCurve;\\n\\n\\tLineCurve.prototype.isLineCurve = true;\\n\\n\\tLineCurve.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector2();\\n\\n\\t\\tif ( t === 1 ) {\\n\\n\\t\\t\\tpoint.copy( this.v2 );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tpoint.copy( this.v2 ).sub( this.v1 );\\n\\t\\t\\tpoint.multiplyScalar( t ).add( this.v1 );\\n\\n\\t\\t}\\n\\n\\t\\treturn point;\\n\\n\\t};\\n\\n\\t// Line curve is linear, so we can overwrite default getPointAt\\n\\n\\tLineCurve.prototype.getPointAt = function ( u, optionalTarget ) {\\n\\n\\t\\treturn this.getPoint( u, optionalTarget );\\n\\n\\t};\\n\\n\\tLineCurve.prototype.getTangent = function ( /* t */ ) {\\n\\n\\t\\tvar tangent = this.v2.clone().sub( this.v1 );\\n\\n\\t\\treturn tangent.normalize();\\n\\n\\t};\\n\\n\\tLineCurve.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.v1.copy( source.v1 );\\n\\t\\tthis.v2.copy( source.v2 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tLineCurve.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.v1 = this.v1.toArray();\\n\\t\\tdata.v2 = this.v2.toArray();\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tLineCurve.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.v1.fromArray( json.v1 );\\n\\t\\tthis.v2.fromArray( json.v2 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tfunction LineCurve3( v1, v2 ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'LineCurve3';\\n\\n\\t\\tthis.v1 = v1 || new Vector3();\\n\\t\\tthis.v2 = v2 || new Vector3();\\n\\n\\t}\\n\\n\\tLineCurve3.prototype = Object.create( Curve.prototype );\\n\\tLineCurve3.prototype.constructor = LineCurve3;\\n\\n\\tLineCurve3.prototype.isLineCurve3 = true;\\n\\n\\tLineCurve3.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector3();\\n\\n\\t\\tif ( t === 1 ) {\\n\\n\\t\\t\\tpoint.copy( this.v2 );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tpoint.copy( this.v2 ).sub( this.v1 );\\n\\t\\t\\tpoint.multiplyScalar( t ).add( this.v1 );\\n\\n\\t\\t}\\n\\n\\t\\treturn point;\\n\\n\\t};\\n\\n\\t// Line curve is linear, so we can overwrite default getPointAt\\n\\n\\tLineCurve3.prototype.getPointAt = function ( u, optionalTarget ) {\\n\\n\\t\\treturn this.getPoint( u, optionalTarget );\\n\\n\\t};\\n\\n\\tLineCurve3.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.v1.copy( source.v1 );\\n\\t\\tthis.v2.copy( source.v2 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tLineCurve3.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.v1 = this.v1.toArray();\\n\\t\\tdata.v2 = this.v2.toArray();\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tLineCurve3.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.v1.fromArray( json.v1 );\\n\\t\\tthis.v2.fromArray( json.v2 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tfunction QuadraticBezierCurve( v0, v1, v2 ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'QuadraticBezierCurve';\\n\\n\\t\\tthis.v0 = v0 || new Vector2();\\n\\t\\tthis.v1 = v1 || new Vector2();\\n\\t\\tthis.v2 = v2 || new Vector2();\\n\\n\\t}\\n\\n\\tQuadraticBezierCurve.prototype = Object.create( Curve.prototype );\\n\\tQuadraticBezierCurve.prototype.constructor = QuadraticBezierCurve;\\n\\n\\tQuadraticBezierCurve.prototype.isQuadraticBezierCurve = true;\\n\\n\\tQuadraticBezierCurve.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector2();\\n\\n\\t\\tvar v0 = this.v0, v1 = this.v1, v2 = this.v2;\\n\\n\\t\\tpoint.set(\\n\\t\\t\\tQuadraticBezier( t, v0.x, v1.x, v2.x ),\\n\\t\\t\\tQuadraticBezier( t, v0.y, v1.y, v2.y )\\n\\t\\t);\\n\\n\\t\\treturn point;\\n\\n\\t};\\n\\n\\tQuadraticBezierCurve.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.v0.copy( source.v0 );\\n\\t\\tthis.v1.copy( source.v1 );\\n\\t\\tthis.v2.copy( source.v2 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tQuadraticBezierCurve.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.v0 = this.v0.toArray();\\n\\t\\tdata.v1 = this.v1.toArray();\\n\\t\\tdata.v2 = this.v2.toArray();\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tQuadraticBezierCurve.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.v0.fromArray( json.v0 );\\n\\t\\tthis.v1.fromArray( json.v1 );\\n\\t\\tthis.v2.fromArray( json.v2 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tfunction QuadraticBezierCurve3( v0, v1, v2 ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'QuadraticBezierCurve3';\\n\\n\\t\\tthis.v0 = v0 || new Vector3();\\n\\t\\tthis.v1 = v1 || new Vector3();\\n\\t\\tthis.v2 = v2 || new Vector3();\\n\\n\\t}\\n\\n\\tQuadraticBezierCurve3.prototype = Object.create( Curve.prototype );\\n\\tQuadraticBezierCurve3.prototype.constructor = QuadraticBezierCurve3;\\n\\n\\tQuadraticBezierCurve3.prototype.isQuadraticBezierCurve3 = true;\\n\\n\\tQuadraticBezierCurve3.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector3();\\n\\n\\t\\tvar v0 = this.v0, v1 = this.v1, v2 = this.v2;\\n\\n\\t\\tpoint.set(\\n\\t\\t\\tQuadraticBezier( t, v0.x, v1.x, v2.x ),\\n\\t\\t\\tQuadraticBezier( t, v0.y, v1.y, v2.y ),\\n\\t\\t\\tQuadraticBezier( t, v0.z, v1.z, v2.z )\\n\\t\\t);\\n\\n\\t\\treturn point;\\n\\n\\t};\\n\\n\\tQuadraticBezierCurve3.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.v0.copy( source.v0 );\\n\\t\\tthis.v1.copy( source.v1 );\\n\\t\\tthis.v2.copy( source.v2 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tQuadraticBezierCurve3.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.v0 = this.v0.toArray();\\n\\t\\tdata.v1 = this.v1.toArray();\\n\\t\\tdata.v2 = this.v2.toArray();\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tQuadraticBezierCurve3.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.v0.fromArray( json.v0 );\\n\\t\\tthis.v1.fromArray( json.v1 );\\n\\t\\tthis.v2.fromArray( json.v2 );\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tfunction SplineCurve( points /* array of Vector2 */ ) {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'SplineCurve';\\n\\n\\t\\tthis.points = points || [];\\n\\n\\t}\\n\\n\\tSplineCurve.prototype = Object.create( Curve.prototype );\\n\\tSplineCurve.prototype.constructor = SplineCurve;\\n\\n\\tSplineCurve.prototype.isSplineCurve = true;\\n\\n\\tSplineCurve.prototype.getPoint = function ( t, optionalTarget ) {\\n\\n\\t\\tvar point = optionalTarget || new Vector2();\\n\\n\\t\\tvar points = this.points;\\n\\t\\tvar p = ( points.length - 1 ) * t;\\n\\n\\t\\tvar intPoint = Math.floor( p );\\n\\t\\tvar weight = p - intPoint;\\n\\n\\t\\tvar p0 = points[ intPoint === 0 ? intPoint : intPoint - 1 ];\\n\\t\\tvar p1 = points[ intPoint ];\\n\\t\\tvar p2 = points[ intPoint > points.length - 2 ? points.length - 1 : intPoint + 1 ];\\n\\t\\tvar p3 = points[ intPoint > points.length - 3 ? points.length - 1 : intPoint + 2 ];\\n\\n\\t\\tpoint.set(\\n\\t\\t\\tCatmullRom( weight, p0.x, p1.x, p2.x, p3.x ),\\n\\t\\t\\tCatmullRom( weight, p0.y, p1.y, p2.y, p3.y )\\n\\t\\t);\\n\\n\\t\\treturn point;\\n\\n\\t};\\n\\n\\tSplineCurve.prototype.copy = function ( source ) {\\n\\n\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\tthis.points = [];\\n\\n\\t\\tfor ( var i = 0, l = source.points.length; i < l; i ++ ) {\\n\\n\\t\\t\\tvar point = source.points[ i ];\\n\\n\\t\\t\\tthis.points.push( point.clone() );\\n\\n\\t\\t}\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tSplineCurve.prototype.toJSON = function () {\\n\\n\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\tdata.points = [];\\n\\n\\t\\tfor ( var i = 0, l = this.points.length; i < l; i ++ ) {\\n\\n\\t\\t\\tvar point = this.points[ i ];\\n\\t\\t\\tdata.points.push( point.toArray() );\\n\\n\\t\\t}\\n\\n\\t\\treturn data;\\n\\n\\t};\\n\\n\\tSplineCurve.prototype.fromJSON = function ( json ) {\\n\\n\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\tthis.points = [];\\n\\n\\t\\tfor ( var i = 0, l = json.points.length; i < l; i ++ ) {\\n\\n\\t\\t\\tvar point = json.points[ i ];\\n\\t\\t\\tthis.points.push( new Vector2().fromArray( point ) );\\n\\n\\t\\t}\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\n\\n\\tvar Curves = Object.freeze({\\n\\t\\tArcCurve: ArcCurve,\\n\\t\\tCatmullRomCurve3: CatmullRomCurve3,\\n\\t\\tCubicBezierCurve: CubicBezierCurve,\\n\\t\\tCubicBezierCurve3: CubicBezierCurve3,\\n\\t\\tEllipseCurve: EllipseCurve,\\n\\t\\tLineCurve: LineCurve,\\n\\t\\tLineCurve3: LineCurve3,\\n\\t\\tQuadraticBezierCurve: QuadraticBezierCurve,\\n\\t\\tQuadraticBezierCurve3: QuadraticBezierCurve3,\\n\\t\\tSplineCurve: SplineCurve\\n\\t});\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t *\\n\\t **/\\n\\n\\t/**************************************************************\\n\\t *\\tCurved Path - a curve path is simply a array of connected\\n\\t *  curves, but retains the api of a curve\\n\\t **************************************************************/\\n\\n\\tfunction CurvePath() {\\n\\n\\t\\tCurve.call( this );\\n\\n\\t\\tthis.type = 'CurvePath';\\n\\n\\t\\tthis.curves = [];\\n\\t\\tthis.autoClose = false; // Automatically closes the path\\n\\n\\t}\\n\\n\\tCurvePath.prototype = Object.assign( Object.create( Curve.prototype ), {\\n\\n\\t\\tconstructor: CurvePath,\\n\\n\\t\\tadd: function ( curve ) {\\n\\n\\t\\t\\tthis.curves.push( curve );\\n\\n\\t\\t},\\n\\n\\t\\tclosePath: function () {\\n\\n\\t\\t\\t// Add a line curve if start and end of lines are not connected\\n\\t\\t\\tvar startPoint = this.curves[ 0 ].getPoint( 0 );\\n\\t\\t\\tvar endPoint = this.curves[ this.curves.length - 1 ].getPoint( 1 );\\n\\n\\t\\t\\tif ( ! startPoint.equals( endPoint ) ) {\\n\\n\\t\\t\\t\\tthis.curves.push( new LineCurve( endPoint, startPoint ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t// To get accurate point with reference to\\n\\t\\t// entire path distance at time t,\\n\\t\\t// following has to be done:\\n\\n\\t\\t// 1. Length of each sub path have to be known\\n\\t\\t// 2. Locate and identify type of curve\\n\\t\\t// 3. Get t for the curve\\n\\t\\t// 4. Return curve.getPointAt(t')\\n\\n\\t\\tgetPoint: function ( t ) {\\n\\n\\t\\t\\tvar d = t * this.getLength();\\n\\t\\t\\tvar curveLengths = this.getCurveLengths();\\n\\t\\t\\tvar i = 0;\\n\\n\\t\\t\\t// To think about boundaries points.\\n\\n\\t\\t\\twhile ( i < curveLengths.length ) {\\n\\n\\t\\t\\t\\tif ( curveLengths[ i ] >= d ) {\\n\\n\\t\\t\\t\\t\\tvar diff = curveLengths[ i ] - d;\\n\\t\\t\\t\\t\\tvar curve = this.curves[ i ];\\n\\n\\t\\t\\t\\t\\tvar segmentLength = curve.getLength();\\n\\t\\t\\t\\t\\tvar u = segmentLength === 0 ? 0 : 1 - diff / segmentLength;\\n\\n\\t\\t\\t\\t\\treturn curve.getPointAt( u );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\ti ++;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn null;\\n\\n\\t\\t\\t// loop where sum != 0, sum > d , sum+1 <d\\n\\n\\t\\t},\\n\\n\\t\\t// We cannot use the default THREE.Curve getPoint() with getLength() because in\\n\\t\\t// THREE.Curve, getLength() depends on getPoint() but in THREE.CurvePath\\n\\t\\t// getPoint() depends on getLength\\n\\n\\t\\tgetLength: function () {\\n\\n\\t\\t\\tvar lens = this.getCurveLengths();\\n\\t\\t\\treturn lens[ lens.length - 1 ];\\n\\n\\t\\t},\\n\\n\\t\\t// cacheLengths must be recalculated.\\n\\t\\tupdateArcLengths: function () {\\n\\n\\t\\t\\tthis.needsUpdate = true;\\n\\t\\t\\tthis.cacheLengths = null;\\n\\t\\t\\tthis.getCurveLengths();\\n\\n\\t\\t},\\n\\n\\t\\t// Compute lengths and cache them\\n\\t\\t// We cannot overwrite getLengths() because UtoT mapping uses it.\\n\\n\\t\\tgetCurveLengths: function () {\\n\\n\\t\\t\\t// We use cache values if curves and cache array are same length\\n\\n\\t\\t\\tif ( this.cacheLengths && this.cacheLengths.length === this.curves.length ) {\\n\\n\\t\\t\\t\\treturn this.cacheLengths;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Get length of sub-curve\\n\\t\\t\\t// Push sums into cached array\\n\\n\\t\\t\\tvar lengths = [], sums = 0;\\n\\n\\t\\t\\tfor ( var i = 0, l = this.curves.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tsums += this.curves[ i ].getLength();\\n\\t\\t\\t\\tlengths.push( sums );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.cacheLengths = lengths;\\n\\n\\t\\t\\treturn lengths;\\n\\n\\t\\t},\\n\\n\\t\\tgetSpacedPoints: function ( divisions ) {\\n\\n\\t\\t\\tif ( divisions === undefined ) divisions = 40;\\n\\n\\t\\t\\tvar points = [];\\n\\n\\t\\t\\tfor ( var i = 0; i <= divisions; i ++ ) {\\n\\n\\t\\t\\t\\tpoints.push( this.getPoint( i / divisions ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.autoClose ) {\\n\\n\\t\\t\\t\\tpoints.push( points[ 0 ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn points;\\n\\n\\t\\t},\\n\\n\\t\\tgetPoints: function ( divisions ) {\\n\\n\\t\\t\\tdivisions = divisions || 12;\\n\\n\\t\\t\\tvar points = [], last;\\n\\n\\t\\t\\tfor ( var i = 0, curves = this.curves; i < curves.length; i ++ ) {\\n\\n\\t\\t\\t\\tvar curve = curves[ i ];\\n\\t\\t\\t\\tvar resolution = ( curve && curve.isEllipseCurve ) ? divisions * 2\\n\\t\\t\\t\\t\\t: ( curve && curve.isLineCurve ) ? 1\\n\\t\\t\\t\\t\\t\\t: ( curve && curve.isSplineCurve ) ? divisions * curve.points.length\\n\\t\\t\\t\\t\\t\\t\\t: divisions;\\n\\n\\t\\t\\t\\tvar pts = curve.getPoints( resolution );\\n\\n\\t\\t\\t\\tfor ( var j = 0; j < pts.length; j ++ ) {\\n\\n\\t\\t\\t\\t\\tvar point = pts[ j ];\\n\\n\\t\\t\\t\\t\\tif ( last && last.equals( point ) ) continue; // ensures no consecutive points are duplicates\\n\\n\\t\\t\\t\\t\\tpoints.push( point );\\n\\t\\t\\t\\t\\tlast = point;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.autoClose && points.length > 1 && ! points[ points.length - 1 ].equals( points[ 0 ] ) ) {\\n\\n\\t\\t\\t\\tpoints.push( points[ 0 ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn points;\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tCurve.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.curves = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = source.curves.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar curve = source.curves[ i ];\\n\\n\\t\\t\\t\\tthis.curves.push( curve.clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.autoClose = source.autoClose;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function () {\\n\\n\\t\\t\\tvar data = Curve.prototype.toJSON.call( this );\\n\\n\\t\\t\\tdata.autoClose = this.autoClose;\\n\\t\\t\\tdata.curves = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = this.curves.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar curve = this.curves[ i ];\\n\\t\\t\\t\\tdata.curves.push( curve.toJSON() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t},\\n\\n\\t\\tfromJSON: function ( json ) {\\n\\n\\t\\t\\tCurve.prototype.fromJSON.call( this, json );\\n\\n\\t\\t\\tthis.autoClose = json.autoClose;\\n\\t\\t\\tthis.curves = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = json.curves.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar curve = json.curves[ i ];\\n\\t\\t\\t\\tthis.curves.push( new Curves[ curve.type ]().fromJSON( curve ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t * Creates free form 2d path using series of points, lines or curves.\\n\\t **/\\n\\n\\tfunction Path( points ) {\\n\\n\\t\\tCurvePath.call( this );\\n\\n\\t\\tthis.type = 'Path';\\n\\n\\t\\tthis.currentPoint = new Vector2();\\n\\n\\t\\tif ( points ) {\\n\\n\\t\\t\\tthis.setFromPoints( points );\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tPath.prototype = Object.assign( Object.create( CurvePath.prototype ), {\\n\\n\\t\\tconstructor: Path,\\n\\n\\t\\tsetFromPoints: function ( points ) {\\n\\n\\t\\t\\tthis.moveTo( points[ 0 ].x, points[ 0 ].y );\\n\\n\\t\\t\\tfor ( var i = 1, l = points.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tthis.lineTo( points[ i ].x, points[ i ].y );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tmoveTo: function ( x, y ) {\\n\\n\\t\\t\\tthis.currentPoint.set( x, y ); // TODO consider referencing vectors instead of copying?\\n\\n\\t\\t},\\n\\n\\t\\tlineTo: function ( x, y ) {\\n\\n\\t\\t\\tvar curve = new LineCurve( this.currentPoint.clone(), new Vector2( x, y ) );\\n\\t\\t\\tthis.curves.push( curve );\\n\\n\\t\\t\\tthis.currentPoint.set( x, y );\\n\\n\\t\\t},\\n\\n\\t\\tquadraticCurveTo: function ( aCPx, aCPy, aX, aY ) {\\n\\n\\t\\t\\tvar curve = new QuadraticBezierCurve(\\n\\t\\t\\t\\tthis.currentPoint.clone(),\\n\\t\\t\\t\\tnew Vector2( aCPx, aCPy ),\\n\\t\\t\\t\\tnew Vector2( aX, aY )\\n\\t\\t\\t);\\n\\n\\t\\t\\tthis.curves.push( curve );\\n\\n\\t\\t\\tthis.currentPoint.set( aX, aY );\\n\\n\\t\\t},\\n\\n\\t\\tbezierCurveTo: function ( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY ) {\\n\\n\\t\\t\\tvar curve = new CubicBezierCurve(\\n\\t\\t\\t\\tthis.currentPoint.clone(),\\n\\t\\t\\t\\tnew Vector2( aCP1x, aCP1y ),\\n\\t\\t\\t\\tnew Vector2( aCP2x, aCP2y ),\\n\\t\\t\\t\\tnew Vector2( aX, aY )\\n\\t\\t\\t);\\n\\n\\t\\t\\tthis.curves.push( curve );\\n\\n\\t\\t\\tthis.currentPoint.set( aX, aY );\\n\\n\\t\\t},\\n\\n\\t\\tsplineThru: function ( pts /*Array of Vector*/ ) {\\n\\n\\t\\t\\tvar npts = [ this.currentPoint.clone() ].concat( pts );\\n\\n\\t\\t\\tvar curve = new SplineCurve( npts );\\n\\t\\t\\tthis.curves.push( curve );\\n\\n\\t\\t\\tthis.currentPoint.copy( pts[ pts.length - 1 ] );\\n\\n\\t\\t},\\n\\n\\t\\tarc: function ( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {\\n\\n\\t\\t\\tvar x0 = this.currentPoint.x;\\n\\t\\t\\tvar y0 = this.currentPoint.y;\\n\\n\\t\\t\\tthis.absarc( aX + x0, aY + y0, aRadius,\\n\\t\\t\\t\\taStartAngle, aEndAngle, aClockwise );\\n\\n\\t\\t},\\n\\n\\t\\tabsarc: function ( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {\\n\\n\\t\\t\\tthis.absellipse( aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise );\\n\\n\\t\\t},\\n\\n\\t\\tellipse: function ( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {\\n\\n\\t\\t\\tvar x0 = this.currentPoint.x;\\n\\t\\t\\tvar y0 = this.currentPoint.y;\\n\\n\\t\\t\\tthis.absellipse( aX + x0, aY + y0, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation );\\n\\n\\t\\t},\\n\\n\\t\\tabsellipse: function ( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {\\n\\n\\t\\t\\tvar curve = new EllipseCurve( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation );\\n\\n\\t\\t\\tif ( this.curves.length > 0 ) {\\n\\n\\t\\t\\t\\t// if a previous curve is present, attempt to join\\n\\t\\t\\t\\tvar firstPoint = curve.getPoint( 0 );\\n\\n\\t\\t\\t\\tif ( ! firstPoint.equals( this.currentPoint ) ) {\\n\\n\\t\\t\\t\\t\\tthis.lineTo( firstPoint.x, firstPoint.y );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.curves.push( curve );\\n\\n\\t\\t\\tvar lastPoint = curve.getPoint( 1 );\\n\\t\\t\\tthis.currentPoint.copy( lastPoint );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tCurvePath.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.currentPoint.copy( source.currentPoint );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function () {\\n\\n\\t\\t\\tvar data = CurvePath.prototype.toJSON.call( this );\\n\\n\\t\\t\\tdata.currentPoint = this.currentPoint.toArray();\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t},\\n\\n\\t\\tfromJSON: function ( json ) {\\n\\n\\t\\t\\tCurvePath.prototype.fromJSON.call( this, json );\\n\\n\\t\\t\\tthis.currentPoint.fromArray( json.currentPoint );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t * Defines a 2d shape plane using paths.\\n\\t **/\\n\\n\\t// STEP 1 Create a path.\\n\\t// STEP 2 Turn path into shape.\\n\\t// STEP 3 ExtrudeGeometry takes in Shape/Shapes\\n\\t// STEP 3a - Extract points from each shape, turn to vertices\\n\\t// STEP 3b - Triangulate each shape, add faces.\\n\\n\\tfunction Shape( points ) {\\n\\n\\t\\tPath.call( this, points );\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.type = 'Shape';\\n\\n\\t\\tthis.holes = [];\\n\\n\\t}\\n\\n\\tShape.prototype = Object.assign( Object.create( Path.prototype ), {\\n\\n\\t\\tconstructor: Shape,\\n\\n\\t\\tgetPointsHoles: function ( divisions ) {\\n\\n\\t\\t\\tvar holesPts = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = this.holes.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tholesPts[ i ] = this.holes[ i ].getPoints( divisions );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn holesPts;\\n\\n\\t\\t},\\n\\n\\t\\t// get points of shape and holes (keypoints based on segments parameter)\\n\\n\\t\\textractPoints: function ( divisions ) {\\n\\n\\t\\t\\treturn {\\n\\n\\t\\t\\t\\tshape: this.getPoints( divisions ),\\n\\t\\t\\t\\tholes: this.getPointsHoles( divisions )\\n\\n\\t\\t\\t};\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tPath.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.holes = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = source.holes.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar hole = source.holes[ i ];\\n\\n\\t\\t\\t\\tthis.holes.push( hole.clone() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function () {\\n\\n\\t\\t\\tvar data = Path.prototype.toJSON.call( this );\\n\\n\\t\\t\\tdata.uuid = this.uuid;\\n\\t\\t\\tdata.holes = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = this.holes.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar hole = this.holes[ i ];\\n\\t\\t\\t\\tdata.holes.push( hole.toJSON() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t},\\n\\n\\t\\tfromJSON: function ( json ) {\\n\\n\\t\\t\\tPath.prototype.fromJSON.call( this, json );\\n\\n\\t\\t\\tthis.uuid = json.uuid;\\n\\t\\t\\tthis.holes = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = json.holes.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar hole = json.holes[ i ];\\n\\t\\t\\t\\tthis.holes.push( new Path().fromJSON( hole ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction Light( color, intensity ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Light';\\n\\n\\t\\tthis.color = new Color( color );\\n\\t\\tthis.intensity = intensity !== undefined ? intensity : 1;\\n\\n\\t\\tthis.receiveShadow = undefined;\\n\\n\\t}\\n\\n\\tLight.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Light,\\n\\n\\t\\tisLight: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tObject3D.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.color.copy( source.color );\\n\\t\\t\\tthis.intensity = source.intensity;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\tvar data = Object3D.prototype.toJSON.call( this, meta );\\n\\n\\t\\t\\tdata.object.color = this.color.getHex();\\n\\t\\t\\tdata.object.intensity = this.intensity;\\n\\n\\t\\t\\tif ( this.groundColor !== undefined ) data.object.groundColor = this.groundColor.getHex();\\n\\n\\t\\t\\tif ( this.distance !== undefined ) data.object.distance = this.distance;\\n\\t\\t\\tif ( this.angle !== undefined ) data.object.angle = this.angle;\\n\\t\\t\\tif ( this.decay !== undefined ) data.object.decay = this.decay;\\n\\t\\t\\tif ( this.penumbra !== undefined ) data.object.penumbra = this.penumbra;\\n\\n\\t\\t\\tif ( this.shadow !== undefined ) data.object.shadow = this.shadow.toJSON();\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction HemisphereLight( skyColor, groundColor, intensity ) {\\n\\n\\t\\tLight.call( this, skyColor, intensity );\\n\\n\\t\\tthis.type = 'HemisphereLight';\\n\\n\\t\\tthis.castShadow = undefined;\\n\\n\\t\\tthis.position.copy( Object3D.DefaultUp );\\n\\t\\tthis.updateMatrix();\\n\\n\\t\\tthis.groundColor = new Color( groundColor );\\n\\n\\t}\\n\\n\\tHemisphereLight.prototype = Object.assign( Object.create( Light.prototype ), {\\n\\n\\t\\tconstructor: HemisphereLight,\\n\\n\\t\\tisHemisphereLight: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tLight.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.groundColor.copy( source.groundColor );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction LightShadow( camera ) {\\n\\n\\t\\tthis.camera = camera;\\n\\n\\t\\tthis.bias = 0;\\n\\t\\tthis.radius = 1;\\n\\n\\t\\tthis.mapSize = new Vector2( 512, 512 );\\n\\n\\t\\tthis.map = null;\\n\\t\\tthis.matrix = new Matrix4();\\n\\n\\t}\\n\\n\\tObject.assign( LightShadow.prototype, {\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tthis.camera = source.camera.clone();\\n\\n\\t\\t\\tthis.bias = source.bias;\\n\\t\\t\\tthis.radius = source.radius;\\n\\n\\t\\t\\tthis.mapSize.copy( source.mapSize );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function () {\\n\\n\\t\\t\\tvar object = {};\\n\\n\\t\\t\\tif ( this.bias !== 0 ) object.bias = this.bias;\\n\\t\\t\\tif ( this.radius !== 1 ) object.radius = this.radius;\\n\\t\\t\\tif ( this.mapSize.x !== 512 || this.mapSize.y !== 512 ) object.mapSize = this.mapSize.toArray();\\n\\n\\t\\t\\tobject.camera = this.camera.toJSON( false ).object;\\n\\t\\t\\tdelete object.camera.matrix;\\n\\n\\t\\t\\treturn object;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction SpotLightShadow() {\\n\\n\\t\\tLightShadow.call( this, new PerspectiveCamera( 50, 1, 0.5, 500 ) );\\n\\n\\t}\\n\\n\\tSpotLightShadow.prototype = Object.assign( Object.create( LightShadow.prototype ), {\\n\\n\\t\\tconstructor: SpotLightShadow,\\n\\n\\t\\tisSpotLightShadow: true,\\n\\n\\t\\tupdate: function ( light ) {\\n\\n\\t\\t\\tvar camera = this.camera;\\n\\n\\t\\t\\tvar fov = _Math.RAD2DEG * 2 * light.angle;\\n\\t\\t\\tvar aspect = this.mapSize.width / this.mapSize.height;\\n\\t\\t\\tvar far = light.distance || camera.far;\\n\\n\\t\\t\\tif ( fov !== camera.fov || aspect !== camera.aspect || far !== camera.far ) {\\n\\n\\t\\t\\t\\tcamera.fov = fov;\\n\\t\\t\\t\\tcamera.aspect = aspect;\\n\\t\\t\\t\\tcamera.far = far;\\n\\t\\t\\t\\tcamera.updateProjectionMatrix();\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction SpotLight( color, intensity, distance, angle, penumbra, decay ) {\\n\\n\\t\\tLight.call( this, color, intensity );\\n\\n\\t\\tthis.type = 'SpotLight';\\n\\n\\t\\tthis.position.copy( Object3D.DefaultUp );\\n\\t\\tthis.updateMatrix();\\n\\n\\t\\tthis.target = new Object3D();\\n\\n\\t\\tObject.defineProperty( this, 'power', {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\t// intensity = power per solid angle.\\n\\t\\t\\t\\t// ref: equation (17) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf\\n\\t\\t\\t\\treturn this.intensity * Math.PI;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( power ) {\\n\\n\\t\\t\\t\\t// intensity = power per solid angle.\\n\\t\\t\\t\\t// ref: equation (17) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf\\n\\t\\t\\t\\tthis.intensity = power / Math.PI;\\n\\n\\t\\t\\t}\\n\\t\\t} );\\n\\n\\t\\tthis.distance = ( distance !== undefined ) ? distance : 0;\\n\\t\\tthis.angle = ( angle !== undefined ) ? angle : Math.PI / 3;\\n\\t\\tthis.penumbra = ( penumbra !== undefined ) ? penumbra : 0;\\n\\t\\tthis.decay = ( decay !== undefined ) ? decay : 1;\\t// for physically correct lights, should be 2.\\n\\n\\t\\tthis.shadow = new SpotLightShadow();\\n\\n\\t}\\n\\n\\tSpotLight.prototype = Object.assign( Object.create( Light.prototype ), {\\n\\n\\t\\tconstructor: SpotLight,\\n\\n\\t\\tisSpotLight: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tLight.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.distance = source.distance;\\n\\t\\t\\tthis.angle = source.angle;\\n\\t\\t\\tthis.penumbra = source.penumbra;\\n\\t\\t\\tthis.decay = source.decay;\\n\\n\\t\\t\\tthis.target = source.target.clone();\\n\\n\\t\\t\\tthis.shadow = source.shadow.clone();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\n\\tfunction PointLight( color, intensity, distance, decay ) {\\n\\n\\t\\tLight.call( this, color, intensity );\\n\\n\\t\\tthis.type = 'PointLight';\\n\\n\\t\\tObject.defineProperty( this, 'power', {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\t// intensity = power per solid angle.\\n\\t\\t\\t\\t// ref: equation (15) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf\\n\\t\\t\\t\\treturn this.intensity * 4 * Math.PI;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( power ) {\\n\\n\\t\\t\\t\\t// intensity = power per solid angle.\\n\\t\\t\\t\\t// ref: equation (15) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf\\n\\t\\t\\t\\tthis.intensity = power / ( 4 * Math.PI );\\n\\n\\t\\t\\t}\\n\\t\\t} );\\n\\n\\t\\tthis.distance = ( distance !== undefined ) ? distance : 0;\\n\\t\\tthis.decay = ( decay !== undefined ) ? decay : 1;\\t// for physically correct lights, should be 2.\\n\\n\\t\\tthis.shadow = new LightShadow( new PerspectiveCamera( 90, 1, 0.5, 500 ) );\\n\\n\\t}\\n\\n\\tPointLight.prototype = Object.assign( Object.create( Light.prototype ), {\\n\\n\\t\\tconstructor: PointLight,\\n\\n\\t\\tisPointLight: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tLight.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.distance = source.distance;\\n\\t\\t\\tthis.decay = source.decay;\\n\\n\\t\\t\\tthis.shadow = source.shadow.clone();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction DirectionalLightShadow( ) {\\n\\n\\t\\tLightShadow.call( this, new OrthographicCamera( - 5, 5, 5, - 5, 0.5, 500 ) );\\n\\n\\t}\\n\\n\\tDirectionalLightShadow.prototype = Object.assign( Object.create( LightShadow.prototype ), {\\n\\n\\t\\tconstructor: DirectionalLightShadow\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction DirectionalLight( color, intensity ) {\\n\\n\\t\\tLight.call( this, color, intensity );\\n\\n\\t\\tthis.type = 'DirectionalLight';\\n\\n\\t\\tthis.position.copy( Object3D.DefaultUp );\\n\\t\\tthis.updateMatrix();\\n\\n\\t\\tthis.target = new Object3D();\\n\\n\\t\\tthis.shadow = new DirectionalLightShadow();\\n\\n\\t}\\n\\n\\tDirectionalLight.prototype = Object.assign( Object.create( Light.prototype ), {\\n\\n\\t\\tconstructor: DirectionalLight,\\n\\n\\t\\tisDirectionalLight: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tLight.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.target = source.target.clone();\\n\\n\\t\\t\\tthis.shadow = source.shadow.clone();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction AmbientLight( color, intensity ) {\\n\\n\\t\\tLight.call( this, color, intensity );\\n\\n\\t\\tthis.type = 'AmbientLight';\\n\\n\\t\\tthis.castShadow = undefined;\\n\\n\\t}\\n\\n\\tAmbientLight.prototype = Object.assign( Object.create( Light.prototype ), {\\n\\n\\t\\tconstructor: AmbientLight,\\n\\n\\t\\tisAmbientLight: true\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author abelnation / http://github.com/abelnation\\n\\t */\\n\\n\\tfunction RectAreaLight( color, intensity, width, height ) {\\n\\n\\t\\tLight.call( this, color, intensity );\\n\\n\\t\\tthis.type = 'RectAreaLight';\\n\\n\\t\\tthis.position.set( 0, 1, 0 );\\n\\t\\tthis.updateMatrix();\\n\\n\\t\\tthis.width = ( width !== undefined ) ? width : 10;\\n\\t\\tthis.height = ( height !== undefined ) ? height : 10;\\n\\n\\t\\t// TODO (abelnation): distance/decay\\n\\n\\t\\t// TODO (abelnation): update method for RectAreaLight to update transform to lookat target\\n\\n\\t\\t// TODO (abelnation): shadows\\n\\n\\t}\\n\\n\\t// TODO (abelnation): RectAreaLight update when light shape is changed\\n\\tRectAreaLight.prototype = Object.assign( Object.create( Light.prototype ), {\\n\\n\\t\\tconstructor: RectAreaLight,\\n\\n\\t\\tisRectAreaLight: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tLight.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.width = source.width;\\n\\t\\t\\tthis.height = source.height;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( meta ) {\\n\\n\\t\\t\\tvar data = Light.prototype.toJSON.call( this, meta );\\n\\n\\t\\t\\tdata.object.width = this.width;\\n\\t\\t\\tdata.object.height = this.height;\\n\\n\\t\\t\\treturn data;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * A Track that interpolates Strings\\n\\t *\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction StringKeyframeTrack( name, times, values, interpolation ) {\\n\\n\\t\\tKeyframeTrack.call( this, name, times, values, interpolation );\\n\\n\\t}\\n\\n\\tStringKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {\\n\\n\\t\\tconstructor: StringKeyframeTrack,\\n\\n\\t\\tValueTypeName: 'string',\\n\\t\\tValueBufferType: Array,\\n\\n\\t\\tDefaultInterpolation: InterpolateDiscrete,\\n\\n\\t\\tInterpolantFactoryMethodLinear: undefined,\\n\\n\\t\\tInterpolantFactoryMethodSmooth: undefined\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * A Track of Boolean keyframe values.\\n\\t *\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction BooleanKeyframeTrack( name, times, values ) {\\n\\n\\t\\tKeyframeTrack.call( this, name, times, values );\\n\\n\\t}\\n\\n\\tBooleanKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {\\n\\n\\t\\tconstructor: BooleanKeyframeTrack,\\n\\n\\t\\tValueTypeName: 'bool',\\n\\t\\tValueBufferType: Array,\\n\\n\\t\\tDefaultInterpolation: InterpolateDiscrete,\\n\\n\\t\\tInterpolantFactoryMethodLinear: undefined,\\n\\t\\tInterpolantFactoryMethodSmooth: undefined\\n\\n\\t\\t// Note: Actually this track could have a optimized / compressed\\n\\t\\t// representation of a single value and a custom interpolant that\\n\\t\\t// computes \\\"firstValue ^ isOdd( index )\\\".\\n\\n\\t} );\\n\\n\\t/**\\n\\t * Abstract base class of interpolants over parametric samples.\\n\\t *\\n\\t * The parameter domain is one dimensional, typically the time or a path\\n\\t * along a curve defined by the data.\\n\\t *\\n\\t * The sample values can have any dimensionality and derived classes may\\n\\t * apply special interpretations to the data.\\n\\t *\\n\\t * This class provides the interval seek in a Template Method, deferring\\n\\t * the actual interpolation to derived classes.\\n\\t *\\n\\t * Time complexity is O(1) for linear access crossing at most two points\\n\\t * and O(log N) for random access, where N is the number of positions.\\n\\t *\\n\\t * References:\\n\\t *\\n\\t * \\t\\thttp://www.oodesign.com/template-method-pattern.html\\n\\t *\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction Interpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {\\n\\n\\t\\tthis.parameterPositions = parameterPositions;\\n\\t\\tthis._cachedIndex = 0;\\n\\n\\t\\tthis.resultBuffer = resultBuffer !== undefined ?\\n\\t\\t\\tresultBuffer : new sampleValues.constructor( sampleSize );\\n\\t\\tthis.sampleValues = sampleValues;\\n\\t\\tthis.valueSize = sampleSize;\\n\\n\\t}\\n\\n\\tObject.assign( Interpolant.prototype, {\\n\\n\\t\\tevaluate: function ( t ) {\\n\\n\\t\\t\\tvar pp = this.parameterPositions,\\n\\t\\t\\t\\ti1 = this._cachedIndex,\\n\\n\\t\\t\\t\\tt1 = pp[ i1 ],\\n\\t\\t\\t\\tt0 = pp[ i1 - 1 ];\\n\\n\\t\\t\\tvalidate_interval: {\\n\\n\\t\\t\\t\\tseek: {\\n\\n\\t\\t\\t\\t\\tvar right;\\n\\n\\t\\t\\t\\t\\tlinear_scan: {\\n\\n\\t\\t\\t\\t\\t\\t//- See http://jsperf.com/comparison-to-undefined/3\\n\\t\\t\\t\\t\\t\\t//- slower code:\\n\\t\\t\\t\\t\\t\\t//-\\n\\t\\t\\t\\t\\t\\t//- \\t\\t\\t\\tif ( t >= t1 || t1 === undefined ) {\\n\\t\\t\\t\\t\\t\\tforward_scan: if ( ! ( t < t1 ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var giveUpAt = i1 + 2; ; ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( t1 === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif ( t < t0 ) break forward_scan;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// after end\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\ti1 = pp.length;\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tthis._cachedIndex = i1;\\n\\t\\t\\t\\t\\t\\t\\t\\t\\treturn this.afterEnd_( i1 - 1, t, t0 );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( i1 === giveUpAt ) break; // this loop\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tt0 = t1;\\n\\t\\t\\t\\t\\t\\t\\t\\tt1 = pp[ ++ i1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( t < t1 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// we have arrived at the sought interval\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak seek;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t// prepare binary search on the right side of the index\\n\\t\\t\\t\\t\\t\\t\\tright = pp.length;\\n\\t\\t\\t\\t\\t\\t\\tbreak linear_scan;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t//- slower code:\\n\\t\\t\\t\\t\\t\\t//-\\t\\t\\t\\t\\tif ( t < t0 || t0 === undefined ) {\\n\\t\\t\\t\\t\\t\\tif ( ! ( t >= t0 ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// looping?\\n\\n\\t\\t\\t\\t\\t\\t\\tvar t1global = pp[ 1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( t < t1global ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\ti1 = 2; // + 1, using the scan for the details\\n\\t\\t\\t\\t\\t\\t\\t\\tt0 = t1global;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t// linear reverse scan\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var giveUpAt = i1 - 2; ; ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( t0 === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// before start\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tthis._cachedIndex = 0;\\n\\t\\t\\t\\t\\t\\t\\t\\t\\treturn this.beforeStart_( 0, t, t1 );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( i1 === giveUpAt ) break; // this loop\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tt1 = t0;\\n\\t\\t\\t\\t\\t\\t\\t\\tt0 = pp[ -- i1 - 1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( t >= t0 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t// we have arrived at the sought interval\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbreak seek;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t// prepare binary search on the left side of the index\\n\\t\\t\\t\\t\\t\\t\\tright = i1;\\n\\t\\t\\t\\t\\t\\t\\ti1 = 0;\\n\\t\\t\\t\\t\\t\\t\\tbreak linear_scan;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t// the interval is valid\\n\\n\\t\\t\\t\\t\\t\\tbreak validate_interval;\\n\\n\\t\\t\\t\\t\\t} // linear scan\\n\\n\\t\\t\\t\\t\\t// binary search\\n\\n\\t\\t\\t\\t\\twhile ( i1 < right ) {\\n\\n\\t\\t\\t\\t\\t\\tvar mid = ( i1 + right ) >>> 1;\\n\\n\\t\\t\\t\\t\\t\\tif ( t < pp[ mid ] ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tright = mid;\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\ti1 = mid + 1;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tt1 = pp[ i1 ];\\n\\t\\t\\t\\t\\tt0 = pp[ i1 - 1 ];\\n\\n\\t\\t\\t\\t\\t// check boundary cases, again\\n\\n\\t\\t\\t\\t\\tif ( t0 === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tthis._cachedIndex = 0;\\n\\t\\t\\t\\t\\t\\treturn this.beforeStart_( 0, t, t1 );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( t1 === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\ti1 = pp.length;\\n\\t\\t\\t\\t\\t\\tthis._cachedIndex = i1;\\n\\t\\t\\t\\t\\t\\treturn this.afterEnd_( i1 - 1, t0, t );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} // seek\\n\\n\\t\\t\\t\\tthis._cachedIndex = i1;\\n\\n\\t\\t\\t\\tthis.intervalChanged_( i1, t0, t1 );\\n\\n\\t\\t\\t} // validate_interval\\n\\n\\t\\t\\treturn this.interpolate_( i1, t0, t, t1 );\\n\\n\\t\\t},\\n\\n\\t\\tsettings: null, // optional, subclass-specific settings structure\\n\\t\\t// Note: The indirection allows central control of many interpolants.\\n\\n\\t\\t// --- Protected interface\\n\\n\\t\\tDefaultSettings_: {},\\n\\n\\t\\tgetSettings_: function () {\\n\\n\\t\\t\\treturn this.settings || this.DefaultSettings_;\\n\\n\\t\\t},\\n\\n\\t\\tcopySampleValue_: function ( index ) {\\n\\n\\t\\t\\t// copies a sample value to the result buffer\\n\\n\\t\\t\\tvar result = this.resultBuffer,\\n\\t\\t\\t\\tvalues = this.sampleValues,\\n\\t\\t\\t\\tstride = this.valueSize,\\n\\t\\t\\t\\toffset = index * stride;\\n\\n\\t\\t\\tfor ( var i = 0; i !== stride; ++ i ) {\\n\\n\\t\\t\\t\\tresult[ i ] = values[ offset + i ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn result;\\n\\n\\t\\t},\\n\\n\\t\\t// Template methods for derived classes:\\n\\n\\t\\tinterpolate_: function ( /* i1, t0, t, t1 */ ) {\\n\\n\\t\\t\\tthrow new Error( 'call to abstract method' );\\n\\t\\t\\t// implementations shall return this.resultBuffer\\n\\n\\t\\t},\\n\\n\\t\\tintervalChanged_: function ( /* i1, t0, t1 */ ) {\\n\\n\\t\\t\\t// empty\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//!\\\\ DECLARE ALIAS AFTER assign prototype !\\n\\tObject.assign( Interpolant.prototype, {\\n\\n\\t\\t//( 0, t, t0 ), returns this.resultBuffer\\n\\t\\tbeforeStart_: Interpolant.prototype.copySampleValue_,\\n\\n\\t\\t//( N-1, tN-1, t ), returns this.resultBuffer\\n\\t\\tafterEnd_: Interpolant.prototype.copySampleValue_,\\n\\n\\t} );\\n\\n\\t/**\\n\\t * Spherical linear unit quaternion interpolant.\\n\\t *\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction QuaternionLinearInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {\\n\\n\\t\\tInterpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );\\n\\n\\t}\\n\\n\\tQuaternionLinearInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), {\\n\\n\\t\\tconstructor: QuaternionLinearInterpolant,\\n\\n\\t\\tinterpolate_: function ( i1, t0, t, t1 ) {\\n\\n\\t\\t\\tvar result = this.resultBuffer,\\n\\t\\t\\t\\tvalues = this.sampleValues,\\n\\t\\t\\t\\tstride = this.valueSize,\\n\\n\\t\\t\\t\\toffset = i1 * stride,\\n\\n\\t\\t\\t\\talpha = ( t - t0 ) / ( t1 - t0 );\\n\\n\\t\\t\\tfor ( var end = offset + stride; offset !== end; offset += 4 ) {\\n\\n\\t\\t\\t\\tQuaternion.slerpFlat( result, 0, values, offset - stride, values, offset, alpha );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn result;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * A Track of quaternion keyframe values.\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction QuaternionKeyframeTrack( name, times, values, interpolation ) {\\n\\n\\t\\tKeyframeTrack.call( this, name, times, values, interpolation );\\n\\n\\t}\\n\\n\\tQuaternionKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {\\n\\n\\t\\tconstructor: QuaternionKeyframeTrack,\\n\\n\\t\\tValueTypeName: 'quaternion',\\n\\n\\t\\t// ValueBufferType is inherited\\n\\n\\t\\tDefaultInterpolation: InterpolateLinear,\\n\\n\\t\\tInterpolantFactoryMethodLinear: function ( result ) {\\n\\n\\t\\t\\treturn new QuaternionLinearInterpolant( this.times, this.values, this.getValueSize(), result );\\n\\n\\t\\t},\\n\\n\\t\\tInterpolantFactoryMethodSmooth: undefined // not yet implemented\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * A Track of keyframe values that represent color.\\n\\t *\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction ColorKeyframeTrack( name, times, values, interpolation ) {\\n\\n\\t\\tKeyframeTrack.call( this, name, times, values, interpolation );\\n\\n\\t}\\n\\n\\tColorKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {\\n\\n\\t\\tconstructor: ColorKeyframeTrack,\\n\\n\\t\\tValueTypeName: 'color'\\n\\n\\t\\t// ValueBufferType is inherited\\n\\n\\t\\t// DefaultInterpolation is inherited\\n\\n\\t\\t// Note: Very basic implementation and nothing special yet.\\n\\t\\t// However, this is the place for color space parameterization.\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * A Track of numeric keyframe values.\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction NumberKeyframeTrack( name, times, values, interpolation ) {\\n\\n\\t\\tKeyframeTrack.call( this, name, times, values, interpolation );\\n\\n\\t}\\n\\n\\tNumberKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {\\n\\n\\t\\tconstructor: NumberKeyframeTrack,\\n\\n\\t\\tValueTypeName: 'number'\\n\\n\\t\\t// ValueBufferType is inherited\\n\\n\\t\\t// DefaultInterpolation is inherited\\n\\n\\t} );\\n\\n\\t/**\\n\\t * Fast and simple cubic spline interpolant.\\n\\t *\\n\\t * It was derived from a Hermitian construction setting the first derivative\\n\\t * at each sample position to the linear slope between neighboring positions\\n\\t * over their parameter interval.\\n\\t *\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction CubicInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {\\n\\n\\t\\tInterpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );\\n\\n\\t\\tthis._weightPrev = - 0;\\n\\t\\tthis._offsetPrev = - 0;\\n\\t\\tthis._weightNext = - 0;\\n\\t\\tthis._offsetNext = - 0;\\n\\n\\t}\\n\\n\\tCubicInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), {\\n\\n\\t\\tconstructor: CubicInterpolant,\\n\\n\\t\\tDefaultSettings_: {\\n\\n\\t\\t\\tendingStart: ZeroCurvatureEnding,\\n\\t\\t\\tendingEnd: ZeroCurvatureEnding\\n\\n\\t\\t},\\n\\n\\t\\tintervalChanged_: function ( i1, t0, t1 ) {\\n\\n\\t\\t\\tvar pp = this.parameterPositions,\\n\\t\\t\\t\\tiPrev = i1 - 2,\\n\\t\\t\\t\\tiNext = i1 + 1,\\n\\n\\t\\t\\t\\ttPrev = pp[ iPrev ],\\n\\t\\t\\t\\ttNext = pp[ iNext ];\\n\\n\\t\\t\\tif ( tPrev === undefined ) {\\n\\n\\t\\t\\t\\tswitch ( this.getSettings_().endingStart ) {\\n\\n\\t\\t\\t\\t\\tcase ZeroSlopeEnding:\\n\\n\\t\\t\\t\\t\\t\\t// f'(t0) = 0\\n\\t\\t\\t\\t\\t\\tiPrev = i1;\\n\\t\\t\\t\\t\\t\\ttPrev = 2 * t0 - t1;\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase WrapAroundEnding:\\n\\n\\t\\t\\t\\t\\t\\t// use the other end of the curve\\n\\t\\t\\t\\t\\t\\tiPrev = pp.length - 2;\\n\\t\\t\\t\\t\\t\\ttPrev = t0 + pp[ iPrev ] - pp[ iPrev + 1 ];\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tdefault: // ZeroCurvatureEnding\\n\\n\\t\\t\\t\\t\\t\\t// f''(t0) = 0 a.k.a. Natural Spline\\n\\t\\t\\t\\t\\t\\tiPrev = i1;\\n\\t\\t\\t\\t\\t\\ttPrev = t1;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( tNext === undefined ) {\\n\\n\\t\\t\\t\\tswitch ( this.getSettings_().endingEnd ) {\\n\\n\\t\\t\\t\\t\\tcase ZeroSlopeEnding:\\n\\n\\t\\t\\t\\t\\t\\t// f'(tN) = 0\\n\\t\\t\\t\\t\\t\\tiNext = i1;\\n\\t\\t\\t\\t\\t\\ttNext = 2 * t1 - t0;\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase WrapAroundEnding:\\n\\n\\t\\t\\t\\t\\t\\t// use the other end of the curve\\n\\t\\t\\t\\t\\t\\tiNext = 1;\\n\\t\\t\\t\\t\\t\\ttNext = t1 + pp[ 1 ] - pp[ 0 ];\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tdefault: // ZeroCurvatureEnding\\n\\n\\t\\t\\t\\t\\t\\t// f''(tN) = 0, a.k.a. Natural Spline\\n\\t\\t\\t\\t\\t\\tiNext = i1 - 1;\\n\\t\\t\\t\\t\\t\\ttNext = t0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar halfDt = ( t1 - t0 ) * 0.5,\\n\\t\\t\\t\\tstride = this.valueSize;\\n\\n\\t\\t\\tthis._weightPrev = halfDt / ( t0 - tPrev );\\n\\t\\t\\tthis._weightNext = halfDt / ( tNext - t1 );\\n\\t\\t\\tthis._offsetPrev = iPrev * stride;\\n\\t\\t\\tthis._offsetNext = iNext * stride;\\n\\n\\t\\t},\\n\\n\\t\\tinterpolate_: function ( i1, t0, t, t1 ) {\\n\\n\\t\\t\\tvar result = this.resultBuffer,\\n\\t\\t\\t\\tvalues = this.sampleValues,\\n\\t\\t\\t\\tstride = this.valueSize,\\n\\n\\t\\t\\t\\to1 = i1 * stride,\\t\\to0 = o1 - stride,\\n\\t\\t\\t\\toP = this._offsetPrev, \\toN = this._offsetNext,\\n\\t\\t\\t\\twP = this._weightPrev,\\twN = this._weightNext,\\n\\n\\t\\t\\t\\tp = ( t - t0 ) / ( t1 - t0 ),\\n\\t\\t\\t\\tpp = p * p,\\n\\t\\t\\t\\tppp = pp * p;\\n\\n\\t\\t\\t// evaluate polynomials\\n\\n\\t\\t\\tvar sP = - wP * ppp + 2 * wP * pp - wP * p;\\n\\t\\t\\tvar s0 = ( 1 + wP ) * ppp + ( - 1.5 - 2 * wP ) * pp + ( - 0.5 + wP ) * p + 1;\\n\\t\\t\\tvar s1 = ( - 1 - wN ) * ppp + ( 1.5 + wN ) * pp + 0.5 * p;\\n\\t\\t\\tvar sN = wN * ppp - wN * pp;\\n\\n\\t\\t\\t// combine data linearly\\n\\n\\t\\t\\tfor ( var i = 0; i !== stride; ++ i ) {\\n\\n\\t\\t\\t\\tresult[ i ] =\\n\\t\\t\\t\\t\\t\\tsP * values[ oP + i ] +\\n\\t\\t\\t\\t\\t\\ts0 * values[ o0 + i ] +\\n\\t\\t\\t\\t\\t\\ts1 * values[ o1 + i ] +\\n\\t\\t\\t\\t\\t\\tsN * values[ oN + i ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn result;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction LinearInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {\\n\\n\\t\\tInterpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );\\n\\n\\t}\\n\\n\\tLinearInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), {\\n\\n\\t\\tconstructor: LinearInterpolant,\\n\\n\\t\\tinterpolate_: function ( i1, t0, t, t1 ) {\\n\\n\\t\\t\\tvar result = this.resultBuffer,\\n\\t\\t\\t\\tvalues = this.sampleValues,\\n\\t\\t\\t\\tstride = this.valueSize,\\n\\n\\t\\t\\t\\toffset1 = i1 * stride,\\n\\t\\t\\t\\toffset0 = offset1 - stride,\\n\\n\\t\\t\\t\\tweight1 = ( t - t0 ) / ( t1 - t0 ),\\n\\t\\t\\t\\tweight0 = 1 - weight1;\\n\\n\\t\\t\\tfor ( var i = 0; i !== stride; ++ i ) {\\n\\n\\t\\t\\t\\tresult[ i ] =\\n\\t\\t\\t\\t\\t\\tvalues[ offset0 + i ] * weight0 +\\n\\t\\t\\t\\t\\t\\tvalues[ offset1 + i ] * weight1;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn result;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * Interpolant that evaluates to the sample value at the position preceeding\\n\\t * the parameter.\\n\\t *\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction DiscreteInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {\\n\\n\\t\\tInterpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );\\n\\n\\t}\\n\\n\\tDiscreteInterpolant.prototype = Object.assign( Object.create( Interpolant.prototype ), {\\n\\n\\t\\tconstructor: DiscreteInterpolant,\\n\\n\\t\\tinterpolate_: function ( i1 /*, t0, t, t1 */ ) {\\n\\n\\t\\t\\treturn this.copySampleValue_( i1 - 1 );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author tschw\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t */\\n\\n\\tvar AnimationUtils = {\\n\\n\\t\\t// same as Array.prototype.slice, but also works on typed arrays\\n\\t\\tarraySlice: function ( array, from, to ) {\\n\\n\\t\\t\\tif ( AnimationUtils.isTypedArray( array ) ) {\\n\\n\\t\\t\\t\\t// in ios9 array.subarray(from, undefined) will return empty array\\n\\t\\t\\t\\t// but array.subarray(from) or array.subarray(from, len) is correct\\n\\t\\t\\t\\treturn new array.constructor( array.subarray( from, to !== undefined ? to : array.length ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn array.slice( from, to );\\n\\n\\t\\t},\\n\\n\\t\\t// converts an array to a specific type\\n\\t\\tconvertArray: function ( array, type, forceClone ) {\\n\\n\\t\\t\\tif ( ! array || // let 'undefined' and 'null' pass\\n\\t\\t\\t\\t\\t! forceClone && array.constructor === type ) return array;\\n\\n\\t\\t\\tif ( typeof type.BYTES_PER_ELEMENT === 'number' ) {\\n\\n\\t\\t\\t\\treturn new type( array ); // create typed array\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn Array.prototype.slice.call( array ); // create Array\\n\\n\\t\\t},\\n\\n\\t\\tisTypedArray: function ( object ) {\\n\\n\\t\\t\\treturn ArrayBuffer.isView( object ) &&\\n\\t\\t\\t\\t\\t! ( object instanceof DataView );\\n\\n\\t\\t},\\n\\n\\t\\t// returns an array by which times and values can be sorted\\n\\t\\tgetKeyframeOrder: function ( times ) {\\n\\n\\t\\t\\tfunction compareTime( i, j ) {\\n\\n\\t\\t\\t\\treturn times[ i ] - times[ j ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar n = times.length;\\n\\t\\t\\tvar result = new Array( n );\\n\\t\\t\\tfor ( var i = 0; i !== n; ++ i ) result[ i ] = i;\\n\\n\\t\\t\\tresult.sort( compareTime );\\n\\n\\t\\t\\treturn result;\\n\\n\\t\\t},\\n\\n\\t\\t// uses the array previously returned by 'getKeyframeOrder' to sort data\\n\\t\\tsortedArray: function ( values, stride, order ) {\\n\\n\\t\\t\\tvar nValues = values.length;\\n\\t\\t\\tvar result = new values.constructor( nValues );\\n\\n\\t\\t\\tfor ( var i = 0, dstOffset = 0; dstOffset !== nValues; ++ i ) {\\n\\n\\t\\t\\t\\tvar srcOffset = order[ i ] * stride;\\n\\n\\t\\t\\t\\tfor ( var j = 0; j !== stride; ++ j ) {\\n\\n\\t\\t\\t\\t\\tresult[ dstOffset ++ ] = values[ srcOffset + j ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn result;\\n\\n\\t\\t},\\n\\n\\t\\t// function for parsing AOS keyframe formats\\n\\t\\tflattenJSON: function ( jsonKeys, times, values, valuePropertyName ) {\\n\\n\\t\\t\\tvar i = 1, key = jsonKeys[ 0 ];\\n\\n\\t\\t\\twhile ( key !== undefined && key[ valuePropertyName ] === undefined ) {\\n\\n\\t\\t\\t\\tkey = jsonKeys[ i ++ ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( key === undefined ) return; // no data\\n\\n\\t\\t\\tvar value = key[ valuePropertyName ];\\n\\t\\t\\tif ( value === undefined ) return; // no data\\n\\n\\t\\t\\tif ( Array.isArray( value ) ) {\\n\\n\\t\\t\\t\\tdo {\\n\\n\\t\\t\\t\\t\\tvalue = key[ valuePropertyName ];\\n\\n\\t\\t\\t\\t\\tif ( value !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\ttimes.push( key.time );\\n\\t\\t\\t\\t\\t\\tvalues.push.apply( values, value ); // push all elements\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tkey = jsonKeys[ i ++ ];\\n\\n\\t\\t\\t\\t} while ( key !== undefined );\\n\\n\\t\\t\\t} else if ( value.toArray !== undefined ) {\\n\\n\\t\\t\\t\\t// ...assume THREE.Math-ish\\n\\n\\t\\t\\t\\tdo {\\n\\n\\t\\t\\t\\t\\tvalue = key[ valuePropertyName ];\\n\\n\\t\\t\\t\\t\\tif ( value !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\ttimes.push( key.time );\\n\\t\\t\\t\\t\\t\\tvalue.toArray( values, values.length );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tkey = jsonKeys[ i ++ ];\\n\\n\\t\\t\\t\\t} while ( key !== undefined );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// otherwise push as-is\\n\\n\\t\\t\\t\\tdo {\\n\\n\\t\\t\\t\\t\\tvalue = key[ valuePropertyName ];\\n\\n\\t\\t\\t\\t\\tif ( value !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\ttimes.push( key.time );\\n\\t\\t\\t\\t\\t\\tvalues.push( value );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tkey = jsonKeys[ i ++ ];\\n\\n\\t\\t\\t\\t} while ( key !== undefined );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t *\\n\\t * A timed sequence of keyframes for a specific property.\\n\\t *\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction KeyframeTrack( name, times, values, interpolation ) {\\n\\n\\t\\tif ( name === undefined ) throw new Error( 'THREE.KeyframeTrack: track name is undefined' );\\n\\t\\tif ( times === undefined || times.length === 0 ) throw new Error( 'THREE.KeyframeTrack: no keyframes in track named ' + name );\\n\\n\\t\\tthis.name = name;\\n\\n\\t\\tthis.times = AnimationUtils.convertArray( times, this.TimeBufferType );\\n\\t\\tthis.values = AnimationUtils.convertArray( values, this.ValueBufferType );\\n\\n\\t\\tthis.setInterpolation( interpolation || this.DefaultInterpolation );\\n\\n\\t\\tthis.validate();\\n\\t\\tthis.optimize();\\n\\n\\t}\\n\\n\\t// Static methods:\\n\\n\\tObject.assign( KeyframeTrack, {\\n\\n\\t\\t// Serialization (in static context, because of constructor invocation\\n\\t\\t// and automatic invocation of .toJSON):\\n\\n\\t\\tparse: function ( json ) {\\n\\n\\t\\t\\tif ( json.type === undefined ) {\\n\\n\\t\\t\\t\\tthrow new Error( 'THREE.KeyframeTrack: track type undefined, can not parse' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar trackType = KeyframeTrack._getTrackTypeForValueTypeName( json.type );\\n\\n\\t\\t\\tif ( json.times === undefined ) {\\n\\n\\t\\t\\t\\tvar times = [], values = [];\\n\\n\\t\\t\\t\\tAnimationUtils.flattenJSON( json.keys, times, values, 'value' );\\n\\n\\t\\t\\t\\tjson.times = times;\\n\\t\\t\\t\\tjson.values = values;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// derived classes can define a static parse method\\n\\t\\t\\tif ( trackType.parse !== undefined ) {\\n\\n\\t\\t\\t\\treturn trackType.parse( json );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// by default, we assume a constructor compatible with the base\\n\\t\\t\\t\\treturn new trackType( json.name, json.times, json.values, json.interpolation );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( track ) {\\n\\n\\t\\t\\tvar trackType = track.constructor;\\n\\n\\t\\t\\tvar json;\\n\\n\\t\\t\\t// derived classes can define a static toJSON method\\n\\t\\t\\tif ( trackType.toJSON !== undefined ) {\\n\\n\\t\\t\\t\\tjson = trackType.toJSON( track );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// by default, we assume the data can be serialized as-is\\n\\t\\t\\t\\tjson = {\\n\\n\\t\\t\\t\\t\\t'name': track.name,\\n\\t\\t\\t\\t\\t'times': AnimationUtils.convertArray( track.times, Array ),\\n\\t\\t\\t\\t\\t'values': AnimationUtils.convertArray( track.values, Array )\\n\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\tvar interpolation = track.getInterpolation();\\n\\n\\t\\t\\t\\tif ( interpolation !== track.DefaultInterpolation ) {\\n\\n\\t\\t\\t\\t\\tjson.interpolation = interpolation;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tjson.type = track.ValueTypeName; // mandatory\\n\\n\\t\\t\\treturn json;\\n\\n\\t\\t},\\n\\n\\t\\t_getTrackTypeForValueTypeName: function ( typeName ) {\\n\\n\\t\\t\\tswitch ( typeName.toLowerCase() ) {\\n\\n\\t\\t\\t\\tcase 'scalar':\\n\\t\\t\\t\\tcase 'double':\\n\\t\\t\\t\\tcase 'float':\\n\\t\\t\\t\\tcase 'number':\\n\\t\\t\\t\\tcase 'integer':\\n\\n\\t\\t\\t\\t\\treturn NumberKeyframeTrack;\\n\\n\\t\\t\\t\\tcase 'vector':\\n\\t\\t\\t\\tcase 'vector2':\\n\\t\\t\\t\\tcase 'vector3':\\n\\t\\t\\t\\tcase 'vector4':\\n\\n\\t\\t\\t\\t\\treturn VectorKeyframeTrack;\\n\\n\\t\\t\\t\\tcase 'color':\\n\\n\\t\\t\\t\\t\\treturn ColorKeyframeTrack;\\n\\n\\t\\t\\t\\tcase 'quaternion':\\n\\n\\t\\t\\t\\t\\treturn QuaternionKeyframeTrack;\\n\\n\\t\\t\\t\\tcase 'bool':\\n\\t\\t\\t\\tcase 'boolean':\\n\\n\\t\\t\\t\\t\\treturn BooleanKeyframeTrack;\\n\\n\\t\\t\\t\\tcase 'string':\\n\\n\\t\\t\\t\\t\\treturn StringKeyframeTrack;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthrow new Error( 'THREE.KeyframeTrack: Unsupported typeName: ' + typeName );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( KeyframeTrack.prototype, {\\n\\n\\t\\tconstructor: KeyframeTrack,\\n\\n\\t\\tTimeBufferType: Float32Array,\\n\\n\\t\\tValueBufferType: Float32Array,\\n\\n\\t\\tDefaultInterpolation: InterpolateLinear,\\n\\n\\t\\tInterpolantFactoryMethodDiscrete: function ( result ) {\\n\\n\\t\\t\\treturn new DiscreteInterpolant( this.times, this.values, this.getValueSize(), result );\\n\\n\\t\\t},\\n\\n\\t\\tInterpolantFactoryMethodLinear: function ( result ) {\\n\\n\\t\\t\\treturn new LinearInterpolant( this.times, this.values, this.getValueSize(), result );\\n\\n\\t\\t},\\n\\n\\t\\tInterpolantFactoryMethodSmooth: function ( result ) {\\n\\n\\t\\t\\treturn new CubicInterpolant( this.times, this.values, this.getValueSize(), result );\\n\\n\\t\\t},\\n\\n\\t\\tsetInterpolation: function ( interpolation ) {\\n\\n\\t\\t\\tvar factoryMethod;\\n\\n\\t\\t\\tswitch ( interpolation ) {\\n\\n\\t\\t\\t\\tcase InterpolateDiscrete:\\n\\n\\t\\t\\t\\t\\tfactoryMethod = this.InterpolantFactoryMethodDiscrete;\\n\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\tcase InterpolateLinear:\\n\\n\\t\\t\\t\\t\\tfactoryMethod = this.InterpolantFactoryMethodLinear;\\n\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\tcase InterpolateSmooth:\\n\\n\\t\\t\\t\\t\\tfactoryMethod = this.InterpolantFactoryMethodSmooth;\\n\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( factoryMethod === undefined ) {\\n\\n\\t\\t\\t\\tvar message = \\\"unsupported interpolation for \\\" +\\n\\t\\t\\t\\t\\tthis.ValueTypeName + \\\" keyframe track named \\\" + this.name;\\n\\n\\t\\t\\t\\tif ( this.createInterpolant === undefined ) {\\n\\n\\t\\t\\t\\t\\t// fall back to default, unless the default itself is messed up\\n\\t\\t\\t\\t\\tif ( interpolation !== this.DefaultInterpolation ) {\\n\\n\\t\\t\\t\\t\\t\\tthis.setInterpolation( this.DefaultInterpolation );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tthrow new Error( message ); // fatal, in this case\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.KeyframeTrack:', message );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.createInterpolant = factoryMethod;\\n\\n\\t\\t},\\n\\n\\t\\tgetInterpolation: function () {\\n\\n\\t\\t\\tswitch ( this.createInterpolant ) {\\n\\n\\t\\t\\t\\tcase this.InterpolantFactoryMethodDiscrete:\\n\\n\\t\\t\\t\\t\\treturn InterpolateDiscrete;\\n\\n\\t\\t\\t\\tcase this.InterpolantFactoryMethodLinear:\\n\\n\\t\\t\\t\\t\\treturn InterpolateLinear;\\n\\n\\t\\t\\t\\tcase this.InterpolantFactoryMethodSmooth:\\n\\n\\t\\t\\t\\t\\treturn InterpolateSmooth;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tgetValueSize: function () {\\n\\n\\t\\t\\treturn this.values.length / this.times.length;\\n\\n\\t\\t},\\n\\n\\t\\t// move all keyframes either forwards or backwards in time\\n\\t\\tshift: function ( timeOffset ) {\\n\\n\\t\\t\\tif ( timeOffset !== 0.0 ) {\\n\\n\\t\\t\\t\\tvar times = this.times;\\n\\n\\t\\t\\t\\tfor ( var i = 0, n = times.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\ttimes[ i ] += timeOffset;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// scale all keyframe times by a factor (useful for frame <-> seconds conversions)\\n\\t\\tscale: function ( timeScale ) {\\n\\n\\t\\t\\tif ( timeScale !== 1.0 ) {\\n\\n\\t\\t\\t\\tvar times = this.times;\\n\\n\\t\\t\\t\\tfor ( var i = 0, n = times.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\ttimes[ i ] *= timeScale;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// removes keyframes before and after animation without changing any values within the range [startTime, endTime].\\n\\t\\t// IMPORTANT: We do not shift around keys to the start of the track time, because for interpolated keys this will change their values\\n\\t\\ttrim: function ( startTime, endTime ) {\\n\\n\\t\\t\\tvar times = this.times,\\n\\t\\t\\t\\tnKeys = times.length,\\n\\t\\t\\t\\tfrom = 0,\\n\\t\\t\\t\\tto = nKeys - 1;\\n\\n\\t\\t\\twhile ( from !== nKeys && times[ from ] < startTime ) {\\n\\n\\t\\t\\t\\t++ from;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\twhile ( to !== - 1 && times[ to ] > endTime ) {\\n\\n\\t\\t\\t\\t-- to;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t++ to; // inclusive -> exclusive bound\\n\\n\\t\\t\\tif ( from !== 0 || to !== nKeys ) {\\n\\n\\t\\t\\t\\t// empty tracks are forbidden, so keep at least one keyframe\\n\\t\\t\\t\\tif ( from >= to ) to = Math.max( to, 1 ), from = to - 1;\\n\\n\\t\\t\\t\\tvar stride = this.getValueSize();\\n\\t\\t\\t\\tthis.times = AnimationUtils.arraySlice( times, from, to );\\n\\t\\t\\t\\tthis.values = AnimationUtils.arraySlice( this.values, from * stride, to * stride );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// ensure we do not get a GarbageInGarbageOut situation, make sure tracks are at least minimally viable\\n\\t\\tvalidate: function () {\\n\\n\\t\\t\\tvar valid = true;\\n\\n\\t\\t\\tvar valueSize = this.getValueSize();\\n\\t\\t\\tif ( valueSize - Math.floor( valueSize ) !== 0 ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.KeyframeTrack: Invalid value size in track.', this );\\n\\t\\t\\t\\tvalid = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar times = this.times,\\n\\t\\t\\t\\tvalues = this.values,\\n\\n\\t\\t\\t\\tnKeys = times.length;\\n\\n\\t\\t\\tif ( nKeys === 0 ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.KeyframeTrack: Track is empty.', this );\\n\\t\\t\\t\\tvalid = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar prevTime = null;\\n\\n\\t\\t\\tfor ( var i = 0; i !== nKeys; i ++ ) {\\n\\n\\t\\t\\t\\tvar currTime = times[ i ];\\n\\n\\t\\t\\t\\tif ( typeof currTime === 'number' && isNaN( currTime ) ) {\\n\\n\\t\\t\\t\\t\\tconsole.error( 'THREE.KeyframeTrack: Time is not a valid number.', this, i, currTime );\\n\\t\\t\\t\\t\\tvalid = false;\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( prevTime !== null && prevTime > currTime ) {\\n\\n\\t\\t\\t\\t\\tconsole.error( 'THREE.KeyframeTrack: Out of order keys.', this, i, currTime, prevTime );\\n\\t\\t\\t\\t\\tvalid = false;\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tprevTime = currTime;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( values !== undefined ) {\\n\\n\\t\\t\\t\\tif ( AnimationUtils.isTypedArray( values ) ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, n = values.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\t\\tvar value = values[ i ];\\n\\n\\t\\t\\t\\t\\t\\tif ( isNaN( value ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.KeyframeTrack: Value is not a valid number.', this, i, value );\\n\\t\\t\\t\\t\\t\\t\\tvalid = false;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn valid;\\n\\n\\t\\t},\\n\\n\\t\\t// removes equivalent sequential keys as common in morph target sequences\\n\\t\\t// (0,0,0,0,1,1,1,0,0,0,0,0,0,0) --> (0,0,1,1,0,0)\\n\\t\\toptimize: function () {\\n\\n\\t\\t\\tvar times = this.times,\\n\\t\\t\\t\\tvalues = this.values,\\n\\t\\t\\t\\tstride = this.getValueSize(),\\n\\n\\t\\t\\t\\tsmoothInterpolation = this.getInterpolation() === InterpolateSmooth,\\n\\n\\t\\t\\t\\twriteIndex = 1,\\n\\t\\t\\t\\tlastIndex = times.length - 1;\\n\\n\\t\\t\\tfor ( var i = 1; i < lastIndex; ++ i ) {\\n\\n\\t\\t\\t\\tvar keep = false;\\n\\n\\t\\t\\t\\tvar time = times[ i ];\\n\\t\\t\\t\\tvar timeNext = times[ i + 1 ];\\n\\n\\t\\t\\t\\t// remove adjacent keyframes scheduled at the same time\\n\\n\\t\\t\\t\\tif ( time !== timeNext && ( i !== 1 || time !== time[ 0 ] ) ) {\\n\\n\\t\\t\\t\\t\\tif ( ! smoothInterpolation ) {\\n\\n\\t\\t\\t\\t\\t\\t// remove unnecessary keyframes same as their neighbors\\n\\n\\t\\t\\t\\t\\t\\tvar offset = i * stride,\\n\\t\\t\\t\\t\\t\\t\\toffsetP = offset - stride,\\n\\t\\t\\t\\t\\t\\t\\toffsetN = offset + stride;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var j = 0; j !== stride; ++ j ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar value = values[ offset + j ];\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( value !== values[ offsetP + j ] ||\\n\\t\\t\\t\\t\\t\\t\\t\\tvalue !== values[ offsetN + j ] ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tkeep = true;\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tkeep = true;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// in-place compaction\\n\\n\\t\\t\\t\\tif ( keep ) {\\n\\n\\t\\t\\t\\t\\tif ( i !== writeIndex ) {\\n\\n\\t\\t\\t\\t\\t\\ttimes[ writeIndex ] = times[ i ];\\n\\n\\t\\t\\t\\t\\t\\tvar readOffset = i * stride,\\n\\t\\t\\t\\t\\t\\t\\twriteOffset = writeIndex * stride;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var j = 0; j !== stride; ++ j ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvalues[ writeOffset + j ] = values[ readOffset + j ];\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t++ writeIndex;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// flush last keyframe (compaction looks ahead)\\n\\n\\t\\t\\tif ( lastIndex > 0 ) {\\n\\n\\t\\t\\t\\ttimes[ writeIndex ] = times[ lastIndex ];\\n\\n\\t\\t\\t\\tfor ( var readOffset = lastIndex * stride, writeOffset = writeIndex * stride, j = 0; j !== stride; ++ j ) {\\n\\n\\t\\t\\t\\t\\tvalues[ writeOffset + j ] = values[ readOffset + j ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t++ writeIndex;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( writeIndex !== times.length ) {\\n\\n\\t\\t\\t\\tthis.times = AnimationUtils.arraySlice( times, 0, writeIndex );\\n\\t\\t\\t\\tthis.values = AnimationUtils.arraySlice( values, 0, writeIndex * stride );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * A Track of vectored keyframe values.\\n\\t *\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction VectorKeyframeTrack( name, times, values, interpolation ) {\\n\\n\\t\\tKeyframeTrack.call( this, name, times, values, interpolation );\\n\\n\\t}\\n\\n\\tVectorKeyframeTrack.prototype = Object.assign( Object.create( KeyframeTrack.prototype ), {\\n\\n\\t\\tconstructor: VectorKeyframeTrack,\\n\\n\\t\\tValueTypeName: 'vector'\\n\\n\\t\\t// ValueBufferType is inherited\\n\\n\\t\\t// DefaultInterpolation is inherited\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * Reusable set of Tracks that represent an animation.\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t */\\n\\n\\tfunction AnimationClip( name, duration, tracks ) {\\n\\n\\t\\tthis.name = name;\\n\\t\\tthis.tracks = tracks;\\n\\t\\tthis.duration = ( duration !== undefined ) ? duration : - 1;\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\t// this means it should figure out its duration by scanning the tracks\\n\\t\\tif ( this.duration < 0 ) {\\n\\n\\t\\t\\tthis.resetDuration();\\n\\n\\t\\t}\\n\\n\\t\\tthis.optimize();\\n\\n\\t}\\n\\n\\tObject.assign( AnimationClip, {\\n\\n\\t\\tparse: function ( json ) {\\n\\n\\t\\t\\tvar tracks = [],\\n\\t\\t\\t\\tjsonTracks = json.tracks,\\n\\t\\t\\t\\tframeTime = 1.0 / ( json.fps || 1.0 );\\n\\n\\t\\t\\tfor ( var i = 0, n = jsonTracks.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\ttracks.push( KeyframeTrack.parse( jsonTracks[ i ] ).scale( frameTime ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn new AnimationClip( json.name, json.duration, tracks );\\n\\n\\t\\t},\\n\\n\\t\\ttoJSON: function ( clip ) {\\n\\n\\t\\t\\tvar tracks = [],\\n\\t\\t\\t\\tclipTracks = clip.tracks;\\n\\n\\t\\t\\tvar json = {\\n\\n\\t\\t\\t\\t'name': clip.name,\\n\\t\\t\\t\\t'duration': clip.duration,\\n\\t\\t\\t\\t'tracks': tracks\\n\\n\\t\\t\\t};\\n\\n\\t\\t\\tfor ( var i = 0, n = clipTracks.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\ttracks.push( KeyframeTrack.toJSON( clipTracks[ i ] ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn json;\\n\\n\\t\\t},\\n\\n\\t\\tCreateFromMorphTargetSequence: function ( name, morphTargetSequence, fps, noLoop ) {\\n\\n\\t\\t\\tvar numMorphTargets = morphTargetSequence.length;\\n\\t\\t\\tvar tracks = [];\\n\\n\\t\\t\\tfor ( var i = 0; i < numMorphTargets; i ++ ) {\\n\\n\\t\\t\\t\\tvar times = [];\\n\\t\\t\\t\\tvar values = [];\\n\\n\\t\\t\\t\\ttimes.push(\\n\\t\\t\\t\\t\\t( i + numMorphTargets - 1 ) % numMorphTargets,\\n\\t\\t\\t\\t\\ti,\\n\\t\\t\\t\\t\\t( i + 1 ) % numMorphTargets );\\n\\n\\t\\t\\t\\tvalues.push( 0, 1, 0 );\\n\\n\\t\\t\\t\\tvar order = AnimationUtils.getKeyframeOrder( times );\\n\\t\\t\\t\\ttimes = AnimationUtils.sortedArray( times, 1, order );\\n\\t\\t\\t\\tvalues = AnimationUtils.sortedArray( values, 1, order );\\n\\n\\t\\t\\t\\t// if there is a key at the first frame, duplicate it as the\\n\\t\\t\\t\\t// last frame as well for perfect loop.\\n\\t\\t\\t\\tif ( ! noLoop && times[ 0 ] === 0 ) {\\n\\n\\t\\t\\t\\t\\ttimes.push( numMorphTargets );\\n\\t\\t\\t\\t\\tvalues.push( values[ 0 ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\ttracks.push(\\n\\t\\t\\t\\t\\tnew NumberKeyframeTrack(\\n\\t\\t\\t\\t\\t\\t'.morphTargetInfluences[' + morphTargetSequence[ i ].name + ']',\\n\\t\\t\\t\\t\\t\\ttimes, values\\n\\t\\t\\t\\t\\t).scale( 1.0 / fps ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn new AnimationClip( name, - 1, tracks );\\n\\n\\t\\t},\\n\\n\\t\\tfindByName: function ( objectOrClipArray, name ) {\\n\\n\\t\\t\\tvar clipArray = objectOrClipArray;\\n\\n\\t\\t\\tif ( ! Array.isArray( objectOrClipArray ) ) {\\n\\n\\t\\t\\t\\tvar o = objectOrClipArray;\\n\\t\\t\\t\\tclipArray = o.geometry && o.geometry.animations || o.animations;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = 0; i < clipArray.length; i ++ ) {\\n\\n\\t\\t\\t\\tif ( clipArray[ i ].name === name ) {\\n\\n\\t\\t\\t\\t\\treturn clipArray[ i ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn null;\\n\\n\\t\\t},\\n\\n\\t\\tCreateClipsFromMorphTargetSequences: function ( morphTargets, fps, noLoop ) {\\n\\n\\t\\t\\tvar animationToMorphTargets = {};\\n\\n\\t\\t\\t// tested with https://regex101.com/ on trick sequences\\n\\t\\t\\t// such flamingo_flyA_003, flamingo_run1_003, crdeath0059\\n\\t\\t\\tvar pattern = /^([\\\\w-]*?)([\\\\d]+)$/;\\n\\n\\t\\t\\t// sort morph target names into animation groups based\\n\\t\\t\\t// patterns like Walk_001, Walk_002, Run_001, Run_002\\n\\t\\t\\tfor ( var i = 0, il = morphTargets.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\tvar morphTarget = morphTargets[ i ];\\n\\t\\t\\t\\tvar parts = morphTarget.name.match( pattern );\\n\\n\\t\\t\\t\\tif ( parts && parts.length > 1 ) {\\n\\n\\t\\t\\t\\t\\tvar name = parts[ 1 ];\\n\\n\\t\\t\\t\\t\\tvar animationMorphTargets = animationToMorphTargets[ name ];\\n\\t\\t\\t\\t\\tif ( ! animationMorphTargets ) {\\n\\n\\t\\t\\t\\t\\t\\tanimationToMorphTargets[ name ] = animationMorphTargets = [];\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tanimationMorphTargets.push( morphTarget );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar clips = [];\\n\\n\\t\\t\\tfor ( var name in animationToMorphTargets ) {\\n\\n\\t\\t\\t\\tclips.push( AnimationClip.CreateFromMorphTargetSequence( name, animationToMorphTargets[ name ], fps, noLoop ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn clips;\\n\\n\\t\\t},\\n\\n\\t\\t// parse the animation.hierarchy format\\n\\t\\tparseAnimation: function ( animation, bones ) {\\n\\n\\t\\t\\tif ( ! animation ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.AnimationClip: No animation in JSONLoader data.' );\\n\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar addNonemptyTrack = function ( trackType, trackName, animationKeys, propertyName, destTracks ) {\\n\\n\\t\\t\\t\\t// only return track if there are actually keys.\\n\\t\\t\\t\\tif ( animationKeys.length !== 0 ) {\\n\\n\\t\\t\\t\\t\\tvar times = [];\\n\\t\\t\\t\\t\\tvar values = [];\\n\\n\\t\\t\\t\\t\\tAnimationUtils.flattenJSON( animationKeys, times, values, propertyName );\\n\\n\\t\\t\\t\\t\\t// empty keys are filtered out, so check again\\n\\t\\t\\t\\t\\tif ( times.length !== 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tdestTracks.push( new trackType( trackName, times, values ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t\\tvar tracks = [];\\n\\n\\t\\t\\tvar clipName = animation.name || 'default';\\n\\t\\t\\t// automatic length determination in AnimationClip.\\n\\t\\t\\tvar duration = animation.length || - 1;\\n\\t\\t\\tvar fps = animation.fps || 30;\\n\\n\\t\\t\\tvar hierarchyTracks = animation.hierarchy || [];\\n\\n\\t\\t\\tfor ( var h = 0; h < hierarchyTracks.length; h ++ ) {\\n\\n\\t\\t\\t\\tvar animationKeys = hierarchyTracks[ h ].keys;\\n\\n\\t\\t\\t\\t// skip empty tracks\\n\\t\\t\\t\\tif ( ! animationKeys || animationKeys.length === 0 ) continue;\\n\\n\\t\\t\\t\\t// process morph targets\\n\\t\\t\\t\\tif ( animationKeys[ 0 ].morphTargets ) {\\n\\n\\t\\t\\t\\t\\t// figure out all morph targets used in this track\\n\\t\\t\\t\\t\\tvar morphTargetNames = {};\\n\\n\\t\\t\\t\\t\\tfor ( var k = 0; k < animationKeys.length; k ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( animationKeys[ k ].morphTargets ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var m = 0; m < animationKeys[ k ].morphTargets.length; m ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tmorphTargetNames[ animationKeys[ k ].morphTargets[ m ] ] = - 1;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t// create a track for each morph target with all zero\\n\\t\\t\\t\\t\\t// morphTargetInfluences except for the keys in which\\n\\t\\t\\t\\t\\t// the morphTarget is named.\\n\\t\\t\\t\\t\\tfor ( var morphTargetName in morphTargetNames ) {\\n\\n\\t\\t\\t\\t\\t\\tvar times = [];\\n\\t\\t\\t\\t\\t\\tvar values = [];\\n\\n\\t\\t\\t\\t\\t\\tfor ( var m = 0; m !== animationKeys[ k ].morphTargets.length; ++ m ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar animationKey = animationKeys[ k ];\\n\\n\\t\\t\\t\\t\\t\\t\\ttimes.push( animationKey.time );\\n\\t\\t\\t\\t\\t\\t\\tvalues.push( ( animationKey.morphTarget === morphTargetName ) ? 1 : 0 );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\ttracks.push( new NumberKeyframeTrack( '.morphTargetInfluence[' + morphTargetName + ']', times, values ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tduration = morphTargetNames.length * ( fps || 1.0 );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t// ...assume skeletal animation\\n\\n\\t\\t\\t\\t\\tvar boneName = '.bones[' + bones[ h ].name + ']';\\n\\n\\t\\t\\t\\t\\taddNonemptyTrack(\\n\\t\\t\\t\\t\\t\\tVectorKeyframeTrack, boneName + '.position',\\n\\t\\t\\t\\t\\t\\tanimationKeys, 'pos', tracks );\\n\\n\\t\\t\\t\\t\\taddNonemptyTrack(\\n\\t\\t\\t\\t\\t\\tQuaternionKeyframeTrack, boneName + '.quaternion',\\n\\t\\t\\t\\t\\t\\tanimationKeys, 'rot', tracks );\\n\\n\\t\\t\\t\\t\\taddNonemptyTrack(\\n\\t\\t\\t\\t\\t\\tVectorKeyframeTrack, boneName + '.scale',\\n\\t\\t\\t\\t\\t\\tanimationKeys, 'scl', tracks );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( tracks.length === 0 ) {\\n\\n\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar clip = new AnimationClip( clipName, duration, tracks );\\n\\n\\t\\t\\treturn clip;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( AnimationClip.prototype, {\\n\\n\\t\\tresetDuration: function () {\\n\\n\\t\\t\\tvar tracks = this.tracks, duration = 0;\\n\\n\\t\\t\\tfor ( var i = 0, n = tracks.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tvar track = this.tracks[ i ];\\n\\n\\t\\t\\t\\tduration = Math.max( duration, track.times[ track.times.length - 1 ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.duration = duration;\\n\\n\\t\\t},\\n\\n\\t\\ttrim: function () {\\n\\n\\t\\t\\tfor ( var i = 0; i < this.tracks.length; i ++ ) {\\n\\n\\t\\t\\t\\tthis.tracks[ i ].trim( 0, this.duration );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\toptimize: function () {\\n\\n\\t\\t\\tfor ( var i = 0; i < this.tracks.length; i ++ ) {\\n\\n\\t\\t\\t\\tthis.tracks[ i ].optimize();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction MaterialLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\t\\tthis.textures = {};\\n\\n\\t}\\n\\n\\tObject.assign( MaterialLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar loader = new FileLoader( scope.manager );\\n\\t\\t\\tloader.load( url, function ( text ) {\\n\\n\\t\\t\\t\\tonLoad( scope.parse( JSON.parse( text ) ) );\\n\\n\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t},\\n\\n\\t\\tsetTextures: function ( value ) {\\n\\n\\t\\t\\tthis.textures = value;\\n\\n\\t\\t},\\n\\n\\t\\tparse: function ( json ) {\\n\\n\\t\\t\\tvar textures = this.textures;\\n\\n\\t\\t\\tfunction getTexture( name ) {\\n\\n\\t\\t\\t\\tif ( textures[ name ] === undefined ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.MaterialLoader: Undefined texture', name );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn textures[ name ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar material = new Materials[ json.type ]();\\n\\n\\t\\t\\tif ( json.uuid !== undefined ) material.uuid = json.uuid;\\n\\t\\t\\tif ( json.name !== undefined ) material.name = json.name;\\n\\t\\t\\tif ( json.color !== undefined ) material.color.setHex( json.color );\\n\\t\\t\\tif ( json.roughness !== undefined ) material.roughness = json.roughness;\\n\\t\\t\\tif ( json.metalness !== undefined ) material.metalness = json.metalness;\\n\\t\\t\\tif ( json.emissive !== undefined ) material.emissive.setHex( json.emissive );\\n\\t\\t\\tif ( json.specular !== undefined ) material.specular.setHex( json.specular );\\n\\t\\t\\tif ( json.shininess !== undefined ) material.shininess = json.shininess;\\n\\t\\t\\tif ( json.clearCoat !== undefined ) material.clearCoat = json.clearCoat;\\n\\t\\t\\tif ( json.clearCoatRoughness !== undefined ) material.clearCoatRoughness = json.clearCoatRoughness;\\n\\t\\t\\tif ( json.uniforms !== undefined ) material.uniforms = json.uniforms;\\n\\t\\t\\tif ( json.vertexShader !== undefined ) material.vertexShader = json.vertexShader;\\n\\t\\t\\tif ( json.fragmentShader !== undefined ) material.fragmentShader = json.fragmentShader;\\n\\t\\t\\tif ( json.vertexColors !== undefined ) material.vertexColors = json.vertexColors;\\n\\t\\t\\tif ( json.fog !== undefined ) material.fog = json.fog;\\n\\t\\t\\tif ( json.flatShading !== undefined ) material.flatShading = json.flatShading;\\n\\t\\t\\tif ( json.blending !== undefined ) material.blending = json.blending;\\n\\t\\t\\tif ( json.side !== undefined ) material.side = json.side;\\n\\t\\t\\tif ( json.opacity !== undefined ) material.opacity = json.opacity;\\n\\t\\t\\tif ( json.transparent !== undefined ) material.transparent = json.transparent;\\n\\t\\t\\tif ( json.alphaTest !== undefined ) material.alphaTest = json.alphaTest;\\n\\t\\t\\tif ( json.depthTest !== undefined ) material.depthTest = json.depthTest;\\n\\t\\t\\tif ( json.depthWrite !== undefined ) material.depthWrite = json.depthWrite;\\n\\t\\t\\tif ( json.colorWrite !== undefined ) material.colorWrite = json.colorWrite;\\n\\t\\t\\tif ( json.wireframe !== undefined ) material.wireframe = json.wireframe;\\n\\t\\t\\tif ( json.wireframeLinewidth !== undefined ) material.wireframeLinewidth = json.wireframeLinewidth;\\n\\t\\t\\tif ( json.wireframeLinecap !== undefined ) material.wireframeLinecap = json.wireframeLinecap;\\n\\t\\t\\tif ( json.wireframeLinejoin !== undefined ) material.wireframeLinejoin = json.wireframeLinejoin;\\n\\n\\t\\t\\tif ( json.rotation !== undefined ) material.rotation = json.rotation;\\n\\n\\t\\t\\tif ( json.linewidth !== 1 ) material.linewidth = json.linewidth;\\n\\t\\t\\tif ( json.dashSize !== undefined ) material.dashSize = json.dashSize;\\n\\t\\t\\tif ( json.gapSize !== undefined ) material.gapSize = json.gapSize;\\n\\t\\t\\tif ( json.scale !== undefined ) material.scale = json.scale;\\n\\n\\t\\t\\tif ( json.skinning !== undefined ) material.skinning = json.skinning;\\n\\t\\t\\tif ( json.morphTargets !== undefined ) material.morphTargets = json.morphTargets;\\n\\t\\t\\tif ( json.dithering !== undefined ) material.dithering = json.dithering;\\n\\n\\t\\t\\tif ( json.visible !== undefined ) material.visible = json.visible;\\n\\t\\t\\tif ( json.userData !== undefined ) material.userData = json.userData;\\n\\n\\t\\t\\t// Deprecated\\n\\n\\t\\t\\tif ( json.shading !== undefined ) material.flatShading = json.shading === 1; // THREE.FlatShading\\n\\n\\t\\t\\t// for PointsMaterial\\n\\n\\t\\t\\tif ( json.size !== undefined ) material.size = json.size;\\n\\t\\t\\tif ( json.sizeAttenuation !== undefined ) material.sizeAttenuation = json.sizeAttenuation;\\n\\n\\t\\t\\t// maps\\n\\n\\t\\t\\tif ( json.map !== undefined ) material.map = getTexture( json.map );\\n\\n\\t\\t\\tif ( json.alphaMap !== undefined ) {\\n\\n\\t\\t\\t\\tmaterial.alphaMap = getTexture( json.alphaMap );\\n\\t\\t\\t\\tmaterial.transparent = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( json.bumpMap !== undefined ) material.bumpMap = getTexture( json.bumpMap );\\n\\t\\t\\tif ( json.bumpScale !== undefined ) material.bumpScale = json.bumpScale;\\n\\n\\t\\t\\tif ( json.normalMap !== undefined ) material.normalMap = getTexture( json.normalMap );\\n\\t\\t\\tif ( json.normalScale !== undefined ) {\\n\\n\\t\\t\\t\\tvar normalScale = json.normalScale;\\n\\n\\t\\t\\t\\tif ( Array.isArray( normalScale ) === false ) {\\n\\n\\t\\t\\t\\t\\t// Blender exporter used to export a scalar. See #7459\\n\\n\\t\\t\\t\\t\\tnormalScale = [ normalScale, normalScale ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tmaterial.normalScale = new Vector2().fromArray( normalScale );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( json.displacementMap !== undefined ) material.displacementMap = getTexture( json.displacementMap );\\n\\t\\t\\tif ( json.displacementScale !== undefined ) material.displacementScale = json.displacementScale;\\n\\t\\t\\tif ( json.displacementBias !== undefined ) material.displacementBias = json.displacementBias;\\n\\n\\t\\t\\tif ( json.roughnessMap !== undefined ) material.roughnessMap = getTexture( json.roughnessMap );\\n\\t\\t\\tif ( json.metalnessMap !== undefined ) material.metalnessMap = getTexture( json.metalnessMap );\\n\\n\\t\\t\\tif ( json.emissiveMap !== undefined ) material.emissiveMap = getTexture( json.emissiveMap );\\n\\t\\t\\tif ( json.emissiveIntensity !== undefined ) material.emissiveIntensity = json.emissiveIntensity;\\n\\n\\t\\t\\tif ( json.specularMap !== undefined ) material.specularMap = getTexture( json.specularMap );\\n\\n\\t\\t\\tif ( json.envMap !== undefined ) material.envMap = getTexture( json.envMap );\\n\\n\\t\\t\\tif ( json.reflectivity !== undefined ) material.reflectivity = json.reflectivity;\\n\\n\\t\\t\\tif ( json.lightMap !== undefined ) material.lightMap = getTexture( json.lightMap );\\n\\t\\t\\tif ( json.lightMapIntensity !== undefined ) material.lightMapIntensity = json.lightMapIntensity;\\n\\n\\t\\t\\tif ( json.aoMap !== undefined ) material.aoMap = getTexture( json.aoMap );\\n\\t\\t\\tif ( json.aoMapIntensity !== undefined ) material.aoMapIntensity = json.aoMapIntensity;\\n\\n\\t\\t\\tif ( json.gradientMap !== undefined ) material.gradientMap = getTexture( json.gradientMap );\\n\\n\\t\\t\\treturn material;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction BufferGeometryLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t}\\n\\n\\tObject.assign( BufferGeometryLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar loader = new FileLoader( scope.manager );\\n\\t\\t\\tloader.load( url, function ( text ) {\\n\\n\\t\\t\\t\\tonLoad( scope.parse( JSON.parse( text ) ) );\\n\\n\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t},\\n\\n\\t\\tparse: function ( json ) {\\n\\n\\t\\t\\tvar geometry = new BufferGeometry();\\n\\n\\t\\t\\tvar index = json.data.index;\\n\\n\\t\\t\\tif ( index !== undefined ) {\\n\\n\\t\\t\\t\\tvar typedArray = new TYPED_ARRAYS[ index.type ]( index.array );\\n\\t\\t\\t\\tgeometry.setIndex( new BufferAttribute( typedArray, 1 ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar attributes = json.data.attributes;\\n\\n\\t\\t\\tfor ( var key in attributes ) {\\n\\n\\t\\t\\t\\tvar attribute = attributes[ key ];\\n\\t\\t\\t\\tvar typedArray = new TYPED_ARRAYS[ attribute.type ]( attribute.array );\\n\\n\\t\\t\\t\\tgeometry.addAttribute( key, new BufferAttribute( typedArray, attribute.itemSize, attribute.normalized ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar groups = json.data.groups || json.data.drawcalls || json.data.offsets;\\n\\n\\t\\t\\tif ( groups !== undefined ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0, n = groups.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\tvar group = groups[ i ];\\n\\n\\t\\t\\t\\t\\tgeometry.addGroup( group.start, group.count, group.materialIndex );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar boundingSphere = json.data.boundingSphere;\\n\\n\\t\\t\\tif ( boundingSphere !== undefined ) {\\n\\n\\t\\t\\t\\tvar center = new Vector3();\\n\\n\\t\\t\\t\\tif ( boundingSphere.center !== undefined ) {\\n\\n\\t\\t\\t\\t\\tcenter.fromArray( boundingSphere.center );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometry.boundingSphere = new Sphere( center, boundingSphere.radius );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn geometry;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tvar TYPED_ARRAYS = {\\n\\t\\tInt8Array: Int8Array,\\n\\t\\tUint8Array: Uint8Array,\\n\\t\\t// Workaround for IE11 pre KB2929437. See #11440\\n\\t\\tUint8ClampedArray: typeof Uint8ClampedArray !== 'undefined' ? Uint8ClampedArray : Uint8Array,\\n\\t\\tInt16Array: Int16Array,\\n\\t\\tUint16Array: Uint16Array,\\n\\t\\tInt32Array: Int32Array,\\n\\t\\tUint32Array: Uint32Array,\\n\\t\\tFloat32Array: Float32Array,\\n\\t\\tFloat64Array: Float64Array\\n\\t};\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction Loader() {\\n\\n\\t\\tthis.onLoadStart = function () {};\\n\\t\\tthis.onLoadProgress = function () {};\\n\\t\\tthis.onLoadComplete = function () {};\\n\\n\\t}\\n\\n\\tLoader.Handlers = {\\n\\n\\t\\thandlers: [],\\n\\n\\t\\tadd: function ( regex, loader ) {\\n\\n\\t\\t\\tthis.handlers.push( regex, loader );\\n\\n\\t\\t},\\n\\n\\t\\tget: function ( file ) {\\n\\n\\t\\t\\tvar handlers = this.handlers;\\n\\n\\t\\t\\tfor ( var i = 0, l = handlers.length; i < l; i += 2 ) {\\n\\n\\t\\t\\t\\tvar regex = handlers[ i ];\\n\\t\\t\\t\\tvar loader = handlers[ i + 1 ];\\n\\n\\t\\t\\t\\tif ( regex.test( file ) ) {\\n\\n\\t\\t\\t\\t\\treturn loader;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn null;\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\tObject.assign( Loader.prototype, {\\n\\n\\t\\tcrossOrigin: undefined,\\n\\n\\t\\tinitMaterials: function ( materials, texturePath, crossOrigin ) {\\n\\n\\t\\t\\tvar array = [];\\n\\n\\t\\t\\tfor ( var i = 0; i < materials.length; ++ i ) {\\n\\n\\t\\t\\t\\tarray[ i ] = this.createMaterial( materials[ i ], texturePath, crossOrigin );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn array;\\n\\n\\t\\t},\\n\\n\\t\\tcreateMaterial: ( function () {\\n\\n\\t\\t\\tvar BlendingMode = {\\n\\t\\t\\t\\tNoBlending: NoBlending,\\n\\t\\t\\t\\tNormalBlending: NormalBlending,\\n\\t\\t\\t\\tAdditiveBlending: AdditiveBlending,\\n\\t\\t\\t\\tSubtractiveBlending: SubtractiveBlending,\\n\\t\\t\\t\\tMultiplyBlending: MultiplyBlending,\\n\\t\\t\\t\\tCustomBlending: CustomBlending\\n\\t\\t\\t};\\n\\n\\t\\t\\tvar color = new Color();\\n\\t\\t\\tvar textureLoader = new TextureLoader();\\n\\t\\t\\tvar materialLoader = new MaterialLoader();\\n\\n\\t\\t\\treturn function createMaterial( m, texturePath, crossOrigin ) {\\n\\n\\t\\t\\t\\t// convert from old material format\\n\\n\\t\\t\\t\\tvar textures = {};\\n\\n\\t\\t\\t\\tfunction loadTexture( path, repeat, offset, wrap, anisotropy ) {\\n\\n\\t\\t\\t\\t\\tvar fullPath = texturePath + path;\\n\\t\\t\\t\\t\\tvar loader = Loader.Handlers.get( fullPath );\\n\\n\\t\\t\\t\\t\\tvar texture;\\n\\n\\t\\t\\t\\t\\tif ( loader !== null ) {\\n\\n\\t\\t\\t\\t\\t\\ttexture = loader.load( fullPath );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\ttextureLoader.setCrossOrigin( crossOrigin );\\n\\t\\t\\t\\t\\t\\ttexture = textureLoader.load( fullPath );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( repeat !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\ttexture.repeat.fromArray( repeat );\\n\\n\\t\\t\\t\\t\\t\\tif ( repeat[ 0 ] !== 1 ) texture.wrapS = RepeatWrapping;\\n\\t\\t\\t\\t\\t\\tif ( repeat[ 1 ] !== 1 ) texture.wrapT = RepeatWrapping;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( offset !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\ttexture.offset.fromArray( offset );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( wrap !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( wrap[ 0 ] === 'repeat' ) texture.wrapS = RepeatWrapping;\\n\\t\\t\\t\\t\\t\\tif ( wrap[ 0 ] === 'mirror' ) texture.wrapS = MirroredRepeatWrapping;\\n\\n\\t\\t\\t\\t\\t\\tif ( wrap[ 1 ] === 'repeat' ) texture.wrapT = RepeatWrapping;\\n\\t\\t\\t\\t\\t\\tif ( wrap[ 1 ] === 'mirror' ) texture.wrapT = MirroredRepeatWrapping;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( anisotropy !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\ttexture.anisotropy = anisotropy;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tvar uuid = _Math.generateUUID();\\n\\n\\t\\t\\t\\t\\ttextures[ uuid ] = texture;\\n\\n\\t\\t\\t\\t\\treturn uuid;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t//\\n\\n\\t\\t\\t\\tvar json = {\\n\\t\\t\\t\\t\\tuuid: _Math.generateUUID(),\\n\\t\\t\\t\\t\\ttype: 'MeshLambertMaterial'\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\tfor ( var name in m ) {\\n\\n\\t\\t\\t\\t\\tvar value = m[ name ];\\n\\n\\t\\t\\t\\t\\tswitch ( name ) {\\n\\n\\t\\t\\t\\t\\t\\tcase 'DbgColor':\\n\\t\\t\\t\\t\\t\\tcase 'DbgIndex':\\n\\t\\t\\t\\t\\t\\tcase 'opticalDensity':\\n\\t\\t\\t\\t\\t\\tcase 'illumination':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'DbgName':\\n\\t\\t\\t\\t\\t\\t\\tjson.name = value;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'blending':\\n\\t\\t\\t\\t\\t\\t\\tjson.blending = BlendingMode[ value ];\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'colorAmbient':\\n\\t\\t\\t\\t\\t\\tcase 'mapAmbient':\\n\\t\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.Loader.createMaterial:', name, 'is no longer supported.' );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'colorDiffuse':\\n\\t\\t\\t\\t\\t\\t\\tjson.color = color.fromArray( value ).getHex();\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'colorSpecular':\\n\\t\\t\\t\\t\\t\\t\\tjson.specular = color.fromArray( value ).getHex();\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'colorEmissive':\\n\\t\\t\\t\\t\\t\\t\\tjson.emissive = color.fromArray( value ).getHex();\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'specularCoef':\\n\\t\\t\\t\\t\\t\\t\\tjson.shininess = value;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'shading':\\n\\t\\t\\t\\t\\t\\t\\tif ( value.toLowerCase() === 'basic' ) json.type = 'MeshBasicMaterial';\\n\\t\\t\\t\\t\\t\\t\\tif ( value.toLowerCase() === 'phong' ) json.type = 'MeshPhongMaterial';\\n\\t\\t\\t\\t\\t\\t\\tif ( value.toLowerCase() === 'standard' ) json.type = 'MeshStandardMaterial';\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapDiffuse':\\n\\t\\t\\t\\t\\t\\t\\tjson.map = loadTexture( value, m.mapDiffuseRepeat, m.mapDiffuseOffset, m.mapDiffuseWrap, m.mapDiffuseAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapDiffuseRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapDiffuseOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapDiffuseWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapDiffuseAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapEmissive':\\n\\t\\t\\t\\t\\t\\t\\tjson.emissiveMap = loadTexture( value, m.mapEmissiveRepeat, m.mapEmissiveOffset, m.mapEmissiveWrap, m.mapEmissiveAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapEmissiveRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapEmissiveOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapEmissiveWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapEmissiveAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapLight':\\n\\t\\t\\t\\t\\t\\t\\tjson.lightMap = loadTexture( value, m.mapLightRepeat, m.mapLightOffset, m.mapLightWrap, m.mapLightAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapLightRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapLightOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapLightWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapLightAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapAO':\\n\\t\\t\\t\\t\\t\\t\\tjson.aoMap = loadTexture( value, m.mapAORepeat, m.mapAOOffset, m.mapAOWrap, m.mapAOAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapAORepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapAOOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapAOWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapAOAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapBump':\\n\\t\\t\\t\\t\\t\\t\\tjson.bumpMap = loadTexture( value, m.mapBumpRepeat, m.mapBumpOffset, m.mapBumpWrap, m.mapBumpAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapBumpScale':\\n\\t\\t\\t\\t\\t\\t\\tjson.bumpScale = value;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapBumpRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapBumpOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapBumpWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapBumpAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapNormal':\\n\\t\\t\\t\\t\\t\\t\\tjson.normalMap = loadTexture( value, m.mapNormalRepeat, m.mapNormalOffset, m.mapNormalWrap, m.mapNormalAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapNormalFactor':\\n\\t\\t\\t\\t\\t\\t\\tjson.normalScale = [ value, value ];\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapNormalRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapNormalOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapNormalWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapNormalAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapSpecular':\\n\\t\\t\\t\\t\\t\\t\\tjson.specularMap = loadTexture( value, m.mapSpecularRepeat, m.mapSpecularOffset, m.mapSpecularWrap, m.mapSpecularAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapSpecularRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapSpecularOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapSpecularWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapSpecularAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapMetalness':\\n\\t\\t\\t\\t\\t\\t\\tjson.metalnessMap = loadTexture( value, m.mapMetalnessRepeat, m.mapMetalnessOffset, m.mapMetalnessWrap, m.mapMetalnessAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapMetalnessRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapMetalnessOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapMetalnessWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapMetalnessAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapRoughness':\\n\\t\\t\\t\\t\\t\\t\\tjson.roughnessMap = loadTexture( value, m.mapRoughnessRepeat, m.mapRoughnessOffset, m.mapRoughnessWrap, m.mapRoughnessAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapRoughnessRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapRoughnessOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapRoughnessWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapRoughnessAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapAlpha':\\n\\t\\t\\t\\t\\t\\t\\tjson.alphaMap = loadTexture( value, m.mapAlphaRepeat, m.mapAlphaOffset, m.mapAlphaWrap, m.mapAlphaAnisotropy );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'mapAlphaRepeat':\\n\\t\\t\\t\\t\\t\\tcase 'mapAlphaOffset':\\n\\t\\t\\t\\t\\t\\tcase 'mapAlphaWrap':\\n\\t\\t\\t\\t\\t\\tcase 'mapAlphaAnisotropy':\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'flipSided':\\n\\t\\t\\t\\t\\t\\t\\tjson.side = BackSide;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'doubleSided':\\n\\t\\t\\t\\t\\t\\t\\tjson.side = DoubleSide;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'transparency':\\n\\t\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.Loader.createMaterial: transparency has been renamed to opacity' );\\n\\t\\t\\t\\t\\t\\t\\tjson.opacity = value;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'depthTest':\\n\\t\\t\\t\\t\\t\\tcase 'depthWrite':\\n\\t\\t\\t\\t\\t\\tcase 'colorWrite':\\n\\t\\t\\t\\t\\t\\tcase 'opacity':\\n\\t\\t\\t\\t\\t\\tcase 'reflectivity':\\n\\t\\t\\t\\t\\t\\tcase 'transparent':\\n\\t\\t\\t\\t\\t\\tcase 'visible':\\n\\t\\t\\t\\t\\t\\tcase 'wireframe':\\n\\t\\t\\t\\t\\t\\t\\tjson[ name ] = value;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tcase 'vertexColors':\\n\\t\\t\\t\\t\\t\\t\\tif ( value === true ) json.vertexColors = VertexColors;\\n\\t\\t\\t\\t\\t\\t\\tif ( value === 'face' ) json.vertexColors = FaceColors;\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\t\\t\\t\\t\\t\\tdefault:\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.Loader.createMaterial: Unsupported', name, value );\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( json.type === 'MeshBasicMaterial' ) delete json.emissive;\\n\\t\\t\\t\\tif ( json.type !== 'MeshPhongMaterial' ) delete json.specular;\\n\\n\\t\\t\\t\\tif ( json.opacity < 1 ) json.transparent = true;\\n\\n\\t\\t\\t\\tmaterialLoader.setTextures( textures );\\n\\n\\t\\t\\t\\treturn materialLoader.parse( json );\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )()\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author Don McCurdy / https://www.donmccurdy.com\\n\\t */\\n\\n\\tvar LoaderUtils = {\\n\\n\\t\\tdecodeText: function ( array ) {\\n\\n\\t\\t\\tif ( typeof TextDecoder !== 'undefined' ) {\\n\\n\\t\\t\\t\\treturn new TextDecoder().decode( array );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// Avoid the String.fromCharCode.apply(null, array) shortcut, which\\n\\t\\t\\t// throws a \\\"maximum call stack size exceeded\\\" error for large arrays.\\n\\n\\t\\t\\tvar s = '';\\n\\n\\t\\t\\tfor ( var i = 0, il = array.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\t// Implicitly assumes little-endian.\\n\\t\\t\\t\\ts += String.fromCharCode( array[ i ] );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn s;\\n\\n\\t\\t},\\n\\n\\t\\textractUrlBase: function ( url ) {\\n\\n\\t\\t\\tvar parts = url.split( '/' );\\n\\n\\t\\t\\tif ( parts.length === 1 ) return './';\\n\\n\\t\\t\\tparts.pop();\\n\\n\\t\\t\\treturn parts.join( '/' ) + '/';\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction JSONLoader( manager ) {\\n\\n\\t\\tif ( typeof manager === 'boolean' ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.JSONLoader: showStatus parameter has been removed from constructor.' );\\n\\t\\t\\tmanager = undefined;\\n\\n\\t\\t}\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t\\tthis.withCredentials = false;\\n\\n\\t}\\n\\n\\tObject.assign( JSONLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar texturePath = this.texturePath && ( typeof this.texturePath === 'string' ) ? this.texturePath : LoaderUtils.extractUrlBase( url );\\n\\n\\t\\t\\tvar loader = new FileLoader( this.manager );\\n\\t\\t\\tloader.setWithCredentials( this.withCredentials );\\n\\t\\t\\tloader.load( url, function ( text ) {\\n\\n\\t\\t\\t\\tvar json = JSON.parse( text );\\n\\t\\t\\t\\tvar metadata = json.metadata;\\n\\n\\t\\t\\t\\tif ( metadata !== undefined ) {\\n\\n\\t\\t\\t\\t\\tvar type = metadata.type;\\n\\n\\t\\t\\t\\t\\tif ( type !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( type.toLowerCase() === 'object' ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.JSONLoader: ' + url + ' should be loaded with THREE.ObjectLoader instead.' );\\n\\t\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tif ( type.toLowerCase() === 'scene' ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.JSONLoader: ' + url + ' should be loaded with THREE.SceneLoader instead.' );\\n\\t\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar object = scope.parse( json, texturePath );\\n\\t\\t\\t\\tonLoad( object.geometry, object.materials );\\n\\n\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t},\\n\\n\\t\\tsetTexturePath: function ( value ) {\\n\\n\\t\\t\\tthis.texturePath = value;\\n\\n\\t\\t},\\n\\n\\t\\tparse: ( function () {\\n\\n\\t\\t\\tfunction parseModel( json, geometry ) {\\n\\n\\t\\t\\t\\tfunction isBitSet( value, position ) {\\n\\n\\t\\t\\t\\t\\treturn value & ( 1 << position );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar i, j, fi,\\n\\n\\t\\t\\t\\t\\toffset, zLength,\\n\\n\\t\\t\\t\\t\\tcolorIndex, normalIndex, uvIndex, materialIndex,\\n\\n\\t\\t\\t\\t\\ttype,\\n\\t\\t\\t\\t\\tisQuad,\\n\\t\\t\\t\\t\\thasMaterial,\\n\\t\\t\\t\\t\\thasFaceVertexUv,\\n\\t\\t\\t\\t\\thasFaceNormal, hasFaceVertexNormal,\\n\\t\\t\\t\\t\\thasFaceColor, hasFaceVertexColor,\\n\\n\\t\\t\\t\\t\\tvertex, face, faceA, faceB, hex, normal,\\n\\n\\t\\t\\t\\t\\tuvLayer, uv, u, v,\\n\\n\\t\\t\\t\\t\\tfaces = json.faces,\\n\\t\\t\\t\\t\\tvertices = json.vertices,\\n\\t\\t\\t\\t\\tnormals = json.normals,\\n\\t\\t\\t\\t\\tcolors = json.colors,\\n\\n\\t\\t\\t\\t\\tscale = json.scale,\\n\\n\\t\\t\\t\\t\\tnUvLayers = 0;\\n\\n\\n\\t\\t\\t\\tif ( json.uvs !== undefined ) {\\n\\n\\t\\t\\t\\t\\t// disregard empty arrays\\n\\n\\t\\t\\t\\t\\tfor ( i = 0; i < json.uvs.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( json.uvs[ i ].length ) nUvLayers ++;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tfor ( i = 0; i < nUvLayers; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tgeometry.faceVertexUvs[ i ] = [];\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\toffset = 0;\\n\\t\\t\\t\\tzLength = vertices.length;\\n\\n\\t\\t\\t\\twhile ( offset < zLength ) {\\n\\n\\t\\t\\t\\t\\tvertex = new Vector3();\\n\\n\\t\\t\\t\\t\\tvertex.x = vertices[ offset ++ ] * scale;\\n\\t\\t\\t\\t\\tvertex.y = vertices[ offset ++ ] * scale;\\n\\t\\t\\t\\t\\tvertex.z = vertices[ offset ++ ] * scale;\\n\\n\\t\\t\\t\\t\\tgeometry.vertices.push( vertex );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\toffset = 0;\\n\\t\\t\\t\\tzLength = faces.length;\\n\\n\\t\\t\\t\\twhile ( offset < zLength ) {\\n\\n\\t\\t\\t\\t\\ttype = faces[ offset ++ ];\\n\\n\\t\\t\\t\\t\\tisQuad = isBitSet( type, 0 );\\n\\t\\t\\t\\t\\thasMaterial = isBitSet( type, 1 );\\n\\t\\t\\t\\t\\thasFaceVertexUv = isBitSet( type, 3 );\\n\\t\\t\\t\\t\\thasFaceNormal = isBitSet( type, 4 );\\n\\t\\t\\t\\t\\thasFaceVertexNormal = isBitSet( type, 5 );\\n\\t\\t\\t\\t\\thasFaceColor = isBitSet( type, 6 );\\n\\t\\t\\t\\t\\thasFaceVertexColor = isBitSet( type, 7 );\\n\\n\\t\\t\\t\\t\\t// console.log(\\\"type\\\", type, \\\"bits\\\", isQuad, hasMaterial, hasFaceVertexUv, hasFaceNormal, hasFaceVertexNormal, hasFaceColor, hasFaceVertexColor);\\n\\n\\t\\t\\t\\t\\tif ( isQuad ) {\\n\\n\\t\\t\\t\\t\\t\\tfaceA = new Face3();\\n\\t\\t\\t\\t\\t\\tfaceA.a = faces[ offset ];\\n\\t\\t\\t\\t\\t\\tfaceA.b = faces[ offset + 1 ];\\n\\t\\t\\t\\t\\t\\tfaceA.c = faces[ offset + 3 ];\\n\\n\\t\\t\\t\\t\\t\\tfaceB = new Face3();\\n\\t\\t\\t\\t\\t\\tfaceB.a = faces[ offset + 1 ];\\n\\t\\t\\t\\t\\t\\tfaceB.b = faces[ offset + 2 ];\\n\\t\\t\\t\\t\\t\\tfaceB.c = faces[ offset + 3 ];\\n\\n\\t\\t\\t\\t\\t\\toffset += 4;\\n\\n\\t\\t\\t\\t\\t\\tif ( hasMaterial ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tmaterialIndex = faces[ offset ++ ];\\n\\t\\t\\t\\t\\t\\t\\tfaceA.materialIndex = materialIndex;\\n\\t\\t\\t\\t\\t\\t\\tfaceB.materialIndex = materialIndex;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t// to get face <=> uv index correspondence\\n\\n\\t\\t\\t\\t\\t\\tfi = geometry.faces.length;\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceVertexUv ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( i = 0; i < nUvLayers; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tuvLayer = json.uvs[ i ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgeometry.faceVertexUvs[ i ][ fi ] = [];\\n\\t\\t\\t\\t\\t\\t\\t\\tgeometry.faceVertexUvs[ i ][ fi + 1 ] = [];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tfor ( j = 0; j < 4; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tuvIndex = faces[ offset ++ ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tu = uvLayer[ uvIndex * 2 ];\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tv = uvLayer[ uvIndex * 2 + 1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tuv = new Vector2( u, v );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif ( j !== 2 ) geometry.faceVertexUvs[ i ][ fi ].push( uv );\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif ( j !== 0 ) geometry.faceVertexUvs[ i ][ fi + 1 ].push( uv );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceNormal ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tnormalIndex = faces[ offset ++ ] * 3;\\n\\n\\t\\t\\t\\t\\t\\t\\tfaceA.normal.set(\\n\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ++ ],\\n\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ++ ],\\n\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ]\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tfaceB.normal.copy( faceA.normal );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceVertexNormal ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( i = 0; i < 4; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tnormalIndex = faces[ offset ++ ] * 3;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tnormal = new Vector3(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ++ ],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ++ ],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ]\\n\\t\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( i !== 2 ) faceA.vertexNormals.push( normal );\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( i !== 0 ) faceB.vertexNormals.push( normal );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceColor ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tcolorIndex = faces[ offset ++ ];\\n\\t\\t\\t\\t\\t\\t\\thex = colors[ colorIndex ];\\n\\n\\t\\t\\t\\t\\t\\t\\tfaceA.color.setHex( hex );\\n\\t\\t\\t\\t\\t\\t\\tfaceB.color.setHex( hex );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceVertexColor ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( i = 0; i < 4; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcolorIndex = faces[ offset ++ ];\\n\\t\\t\\t\\t\\t\\t\\t\\thex = colors[ colorIndex ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( i !== 2 ) faceA.vertexColors.push( new Color( hex ) );\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( i !== 0 ) faceB.vertexColors.push( new Color( hex ) );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tgeometry.faces.push( faceA );\\n\\t\\t\\t\\t\\t\\tgeometry.faces.push( faceB );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tface = new Face3();\\n\\t\\t\\t\\t\\t\\tface.a = faces[ offset ++ ];\\n\\t\\t\\t\\t\\t\\tface.b = faces[ offset ++ ];\\n\\t\\t\\t\\t\\t\\tface.c = faces[ offset ++ ];\\n\\n\\t\\t\\t\\t\\t\\tif ( hasMaterial ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tmaterialIndex = faces[ offset ++ ];\\n\\t\\t\\t\\t\\t\\t\\tface.materialIndex = materialIndex;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t// to get face <=> uv index correspondence\\n\\n\\t\\t\\t\\t\\t\\tfi = geometry.faces.length;\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceVertexUv ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( i = 0; i < nUvLayers; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tuvLayer = json.uvs[ i ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgeometry.faceVertexUvs[ i ][ fi ] = [];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tfor ( j = 0; j < 3; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tuvIndex = faces[ offset ++ ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tu = uvLayer[ uvIndex * 2 ];\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tv = uvLayer[ uvIndex * 2 + 1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tuv = new Vector2( u, v );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tgeometry.faceVertexUvs[ i ][ fi ].push( uv );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceNormal ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tnormalIndex = faces[ offset ++ ] * 3;\\n\\n\\t\\t\\t\\t\\t\\t\\tface.normal.set(\\n\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ++ ],\\n\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ++ ],\\n\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ]\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceVertexNormal ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( i = 0; i < 3; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tnormalIndex = faces[ offset ++ ] * 3;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tnormal = new Vector3(\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ++ ],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ++ ],\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tnormals[ normalIndex ]\\n\\t\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tface.vertexNormals.push( normal );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceColor ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tcolorIndex = faces[ offset ++ ];\\n\\t\\t\\t\\t\\t\\t\\tface.color.setHex( colors[ colorIndex ] );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\n\\t\\t\\t\\t\\t\\tif ( hasFaceVertexColor ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( i = 0; i < 3; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcolorIndex = faces[ offset ++ ];\\n\\t\\t\\t\\t\\t\\t\\t\\tface.vertexColors.push( new Color( colors[ colorIndex ] ) );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tgeometry.faces.push( face );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction parseSkin( json, geometry ) {\\n\\n\\t\\t\\t\\tvar influencesPerVertex = ( json.influencesPerVertex !== undefined ) ? json.influencesPerVertex : 2;\\n\\n\\t\\t\\t\\tif ( json.skinWeights ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, l = json.skinWeights.length; i < l; i += influencesPerVertex ) {\\n\\n\\t\\t\\t\\t\\t\\tvar x = json.skinWeights[ i ];\\n\\t\\t\\t\\t\\t\\tvar y = ( influencesPerVertex > 1 ) ? json.skinWeights[ i + 1 ] : 0;\\n\\t\\t\\t\\t\\t\\tvar z = ( influencesPerVertex > 2 ) ? json.skinWeights[ i + 2 ] : 0;\\n\\t\\t\\t\\t\\t\\tvar w = ( influencesPerVertex > 3 ) ? json.skinWeights[ i + 3 ] : 0;\\n\\n\\t\\t\\t\\t\\t\\tgeometry.skinWeights.push( new Vector4( x, y, z, w ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( json.skinIndices ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, l = json.skinIndices.length; i < l; i += influencesPerVertex ) {\\n\\n\\t\\t\\t\\t\\t\\tvar a = json.skinIndices[ i ];\\n\\t\\t\\t\\t\\t\\tvar b = ( influencesPerVertex > 1 ) ? json.skinIndices[ i + 1 ] : 0;\\n\\t\\t\\t\\t\\t\\tvar c = ( influencesPerVertex > 2 ) ? json.skinIndices[ i + 2 ] : 0;\\n\\t\\t\\t\\t\\t\\tvar d = ( influencesPerVertex > 3 ) ? json.skinIndices[ i + 3 ] : 0;\\n\\n\\t\\t\\t\\t\\t\\tgeometry.skinIndices.push( new Vector4( a, b, c, d ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tgeometry.bones = json.bones;\\n\\n\\t\\t\\t\\tif ( geometry.bones && geometry.bones.length > 0 && ( geometry.skinWeights.length !== geometry.skinIndices.length || geometry.skinIndices.length !== geometry.vertices.length ) ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'When skinning, number of vertices (' + geometry.vertices.length + '), skinIndices (' +\\n\\t\\t\\t\\t\\t\\tgeometry.skinIndices.length + '), and skinWeights (' + geometry.skinWeights.length + ') should match.' );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction parseMorphing( json, geometry ) {\\n\\n\\t\\t\\t\\tvar scale = json.scale;\\n\\n\\t\\t\\t\\tif ( json.morphTargets !== undefined ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, l = json.morphTargets.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tgeometry.morphTargets[ i ] = {};\\n\\t\\t\\t\\t\\t\\tgeometry.morphTargets[ i ].name = json.morphTargets[ i ].name;\\n\\t\\t\\t\\t\\t\\tgeometry.morphTargets[ i ].vertices = [];\\n\\n\\t\\t\\t\\t\\t\\tvar dstVertices = geometry.morphTargets[ i ].vertices;\\n\\t\\t\\t\\t\\t\\tvar srcVertices = json.morphTargets[ i ].vertices;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var v = 0, vl = srcVertices.length; v < vl; v += 3 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar vertex = new Vector3();\\n\\t\\t\\t\\t\\t\\t\\tvertex.x = srcVertices[ v ] * scale;\\n\\t\\t\\t\\t\\t\\t\\tvertex.y = srcVertices[ v + 1 ] * scale;\\n\\t\\t\\t\\t\\t\\t\\tvertex.z = srcVertices[ v + 2 ] * scale;\\n\\n\\t\\t\\t\\t\\t\\t\\tdstVertices.push( vertex );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( json.morphColors !== undefined && json.morphColors.length > 0 ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.JSONLoader: \\\"morphColors\\\" no longer supported. Using them as face colors.' );\\n\\n\\t\\t\\t\\t\\tvar faces = geometry.faces;\\n\\t\\t\\t\\t\\tvar morphColors = json.morphColors[ 0 ].colors;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, l = faces.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tfaces[ i ].color.fromArray( morphColors, i * 3 );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction parseAnimations( json, geometry ) {\\n\\n\\t\\t\\t\\tvar outputAnimations = [];\\n\\n\\t\\t\\t\\t// parse old style Bone/Hierarchy animations\\n\\t\\t\\t\\tvar animations = [];\\n\\n\\t\\t\\t\\tif ( json.animation !== undefined ) {\\n\\n\\t\\t\\t\\t\\tanimations.push( json.animation );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( json.animations !== undefined ) {\\n\\n\\t\\t\\t\\t\\tif ( json.animations.length ) {\\n\\n\\t\\t\\t\\t\\t\\tanimations = animations.concat( json.animations );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tanimations.push( json.animations );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < animations.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar clip = AnimationClip.parseAnimation( animations[ i ], geometry.bones );\\n\\t\\t\\t\\t\\tif ( clip ) outputAnimations.push( clip );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// parse implicit morph animations\\n\\t\\t\\t\\tif ( geometry.morphTargets ) {\\n\\n\\t\\t\\t\\t\\t// TODO: Figure out what an appropraite FPS is for morph target animations -- defaulting to 10, but really it is completely arbitrary.\\n\\t\\t\\t\\t\\tvar morphAnimationClips = AnimationClip.CreateClipsFromMorphTargetSequences( geometry.morphTargets, 10 );\\n\\t\\t\\t\\t\\toutputAnimations = outputAnimations.concat( morphAnimationClips );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( outputAnimations.length > 0 ) geometry.animations = outputAnimations;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn function ( json, texturePath ) {\\n\\n\\t\\t\\t\\tif ( json.data !== undefined ) {\\n\\n\\t\\t\\t\\t\\t// Geometry 4.0 spec\\n\\t\\t\\t\\t\\tjson = json.data;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( json.scale !== undefined ) {\\n\\n\\t\\t\\t\\t\\tjson.scale = 1.0 / json.scale;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tjson.scale = 1.0;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar geometry = new Geometry();\\n\\n\\t\\t\\t\\tparseModel( json, geometry );\\n\\t\\t\\t\\tparseSkin( json, geometry );\\n\\t\\t\\t\\tparseMorphing( json, geometry );\\n\\t\\t\\t\\tparseAnimations( json, geometry );\\n\\n\\t\\t\\t\\tgeometry.computeFaceNormals();\\n\\t\\t\\t\\tgeometry.computeBoundingSphere();\\n\\n\\t\\t\\t\\tif ( json.materials === undefined || json.materials.length === 0 ) {\\n\\n\\t\\t\\t\\t\\treturn { geometry: geometry };\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tvar materials = Loader.prototype.initMaterials( json.materials, texturePath, this.crossOrigin );\\n\\n\\t\\t\\t\\t\\treturn { geometry: geometry, materials: materials };\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )()\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction ObjectLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\t\\tthis.texturePath = '';\\n\\n\\t}\\n\\n\\tObject.assign( ObjectLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tif ( this.texturePath === '' ) {\\n\\n\\t\\t\\t\\tthis.texturePath = url.substring( 0, url.lastIndexOf( '/' ) + 1 );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar loader = new FileLoader( scope.manager );\\n\\t\\t\\tloader.load( url, function ( text ) {\\n\\n\\t\\t\\t\\tvar json = null;\\n\\n\\t\\t\\t\\ttry {\\n\\n\\t\\t\\t\\t\\tjson = JSON.parse( text );\\n\\n\\t\\t\\t\\t} catch ( error ) {\\n\\n\\t\\t\\t\\t\\tif ( onError !== undefined ) onError( error );\\n\\n\\t\\t\\t\\t\\tconsole.error( 'THREE:ObjectLoader: Can\\\\'t parse ' + url + '.', error.message );\\n\\n\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar metadata = json.metadata;\\n\\n\\t\\t\\t\\tif ( metadata === undefined || metadata.type === undefined || metadata.type.toLowerCase() === 'geometry' ) {\\n\\n\\t\\t\\t\\t\\tconsole.error( 'THREE.ObjectLoader: Can\\\\'t load ' + url + '. Use THREE.JSONLoader instead.' );\\n\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tscope.parse( json, onLoad );\\n\\n\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t},\\n\\n\\t\\tsetTexturePath: function ( value ) {\\n\\n\\t\\t\\tthis.texturePath = value;\\n\\n\\t\\t},\\n\\n\\t\\tsetCrossOrigin: function ( value ) {\\n\\n\\t\\t\\tthis.crossOrigin = value;\\n\\n\\t\\t},\\n\\n\\t\\tparse: function ( json, onLoad ) {\\n\\n\\t\\t\\tvar shapes = this.parseShape( json.shapes );\\n\\t\\t\\tvar geometries = this.parseGeometries( json.geometries, shapes );\\n\\n\\t\\t\\tvar images = this.parseImages( json.images, function () {\\n\\n\\t\\t\\t\\tif ( onLoad !== undefined ) onLoad( object );\\n\\n\\t\\t\\t} );\\n\\n\\t\\t\\tvar textures = this.parseTextures( json.textures, images );\\n\\t\\t\\tvar materials = this.parseMaterials( json.materials, textures );\\n\\n\\t\\t\\tvar object = this.parseObject( json.object, geometries, materials );\\n\\n\\t\\t\\tif ( json.animations ) {\\n\\n\\t\\t\\t\\tobject.animations = this.parseAnimations( json.animations );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( json.images === undefined || json.images.length === 0 ) {\\n\\n\\t\\t\\t\\tif ( onLoad !== undefined ) onLoad( object );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn object;\\n\\n\\t\\t},\\n\\n\\t\\tparseShape: function ( json ) {\\n\\n\\t\\t\\tvar shapes = {};\\n\\n\\t\\t\\tif ( json !== undefined ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = json.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar shape = new Shape().fromJSON( json[ i ] );\\n\\n\\t\\t\\t\\t\\tshapes[ shape.uuid ] = shape;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn shapes;\\n\\n\\t\\t},\\n\\n\\t\\tparseGeometries: function ( json, shapes ) {\\n\\n\\t\\t\\tvar geometries = {};\\n\\n\\t\\t\\tif ( json !== undefined ) {\\n\\n\\t\\t\\t\\tvar geometryLoader = new JSONLoader();\\n\\t\\t\\t\\tvar bufferGeometryLoader = new BufferGeometryLoader();\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = json.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar geometry;\\n\\t\\t\\t\\t\\tvar data = json[ i ];\\n\\n\\t\\t\\t\\t\\tswitch ( data.type ) {\\n\\n\\t\\t\\t\\t\\t\\tcase 'PlaneGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'PlaneBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.width,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.height,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.widthSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.heightSegments\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'BoxGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'BoxBufferGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'CubeGeometry': // backwards compatible\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.width,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.height,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.depth,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.widthSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.heightSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.depthSegments\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'CircleGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'CircleBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.segments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaStart,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaLength\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'CylinderGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'CylinderBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radiusTop,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radiusBottom,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.height,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radialSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.heightSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.openEnded,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaStart,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaLength\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'ConeGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'ConeBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.height,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radialSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.heightSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.openEnded,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaStart,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaLength\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'SphereGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'SphereBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.widthSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.heightSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.phiStart,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.phiLength,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaStart,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaLength\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'DodecahedronGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'DodecahedronBufferGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'IcosahedronGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'IcosahedronBufferGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'OctahedronGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'OctahedronBufferGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'TetrahedronGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'TetrahedronBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.detail\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'RingGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'RingBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.innerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.outerRadius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.phiSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaStart,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.thetaLength\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'TorusGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'TorusBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.tube,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radialSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.tubularSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.arc\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'TorusKnotGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'TorusKnotBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.tube,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.tubularSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radialSegments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.p,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.q\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'LatheGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'LatheBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.points,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.segments,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.phiStart,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.phiLength\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'PolyhedronGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'PolyhedronBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.vertices,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.indices,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.radius,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.details\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'ShapeGeometry':\\n\\t\\t\\t\\t\\t\\tcase 'ShapeBufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tvar geometryShapes = [];\\n\\n\\t\\t\\t\\t\\t\\t\\tfor ( var i = 0, l = data.shapes.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tvar shape = shapes[ data.shapes[ i ] ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tgeometryShapes.push( shape );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = new Geometries[ data.type ](\\n\\t\\t\\t\\t\\t\\t\\t\\tgeometryShapes,\\n\\t\\t\\t\\t\\t\\t\\t\\tdata.curveSegments\\n\\t\\t\\t\\t\\t\\t\\t);\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'BufferGeometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = bufferGeometryLoader.parse( data );\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tcase 'Geometry':\\n\\n\\t\\t\\t\\t\\t\\t\\tgeometry = geometryLoader.parse( data, this.texturePath ).geometry;\\n\\n\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\tdefault:\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.ObjectLoader: Unsupported geometry type \\\"' + data.type + '\\\"' );\\n\\n\\t\\t\\t\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tgeometry.uuid = data.uuid;\\n\\n\\t\\t\\t\\t\\tif ( data.name !== undefined ) geometry.name = data.name;\\n\\n\\t\\t\\t\\t\\tgeometries[ data.uuid ] = geometry;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn geometries;\\n\\n\\t\\t},\\n\\n\\t\\tparseMaterials: function ( json, textures ) {\\n\\n\\t\\t\\tvar materials = {};\\n\\n\\t\\t\\tif ( json !== undefined ) {\\n\\n\\t\\t\\t\\tvar loader = new MaterialLoader();\\n\\t\\t\\t\\tloader.setTextures( textures );\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = json.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar data = json[ i ];\\n\\n\\t\\t\\t\\t\\tif ( data.type === 'MultiMaterial' ) {\\n\\n\\t\\t\\t\\t\\t\\t// Deprecated\\n\\n\\t\\t\\t\\t\\t\\tvar array = [];\\n\\n\\t\\t\\t\\t\\t\\tfor ( var j = 0; j < data.materials.length; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tarray.push( loader.parse( data.materials[ j ] ) );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tmaterials[ data.uuid ] = array;\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tmaterials[ data.uuid ] = loader.parse( data );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn materials;\\n\\n\\t\\t},\\n\\n\\t\\tparseAnimations: function ( json ) {\\n\\n\\t\\t\\tvar animations = [];\\n\\n\\t\\t\\tfor ( var i = 0; i < json.length; i ++ ) {\\n\\n\\t\\t\\t\\tvar clip = AnimationClip.parse( json[ i ] );\\n\\n\\t\\t\\t\\tanimations.push( clip );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn animations;\\n\\n\\t\\t},\\n\\n\\t\\tparseImages: function ( json, onLoad ) {\\n\\n\\t\\t\\tvar scope = this;\\n\\t\\t\\tvar images = {};\\n\\n\\t\\t\\tfunction loadImage( url ) {\\n\\n\\t\\t\\t\\tscope.manager.itemStart( url );\\n\\n\\t\\t\\t\\treturn loader.load( url, function () {\\n\\n\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t\\t}, undefined, function () {\\n\\n\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\t\\t\\t\\t\\tscope.manager.itemError( url );\\n\\n\\t\\t\\t\\t} );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( json !== undefined && json.length > 0 ) {\\n\\n\\t\\t\\t\\tvar manager = new LoadingManager( onLoad );\\n\\n\\t\\t\\t\\tvar loader = new ImageLoader( manager );\\n\\t\\t\\t\\tloader.setCrossOrigin( this.crossOrigin );\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = json.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar image = json[ i ];\\n\\t\\t\\t\\t\\tvar path = /^(\\\\/\\\\/)|([a-z]+:(\\\\/\\\\/)?)/i.test( image.url ) ? image.url : scope.texturePath + image.url;\\n\\n\\t\\t\\t\\t\\timages[ image.uuid ] = loadImage( path );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn images;\\n\\n\\t\\t},\\n\\n\\t\\tparseTextures: function ( json, images ) {\\n\\n\\t\\t\\tfunction parseConstant( value, type ) {\\n\\n\\t\\t\\t\\tif ( typeof value === 'number' ) return value;\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.ObjectLoader.parseTexture: Constant should be in numeric form.', value );\\n\\n\\t\\t\\t\\treturn type[ value ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar textures = {};\\n\\n\\t\\t\\tif ( json !== undefined ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = json.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar data = json[ i ];\\n\\n\\t\\t\\t\\t\\tif ( data.image === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.ObjectLoader: No \\\"image\\\" specified for', data.uuid );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( images[ data.image ] === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.ObjectLoader: Undefined image', data.image );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tvar texture = new Texture( images[ data.image ] );\\n\\t\\t\\t\\t\\ttexture.needsUpdate = true;\\n\\n\\t\\t\\t\\t\\ttexture.uuid = data.uuid;\\n\\n\\t\\t\\t\\t\\tif ( data.name !== undefined ) texture.name = data.name;\\n\\n\\t\\t\\t\\t\\tif ( data.mapping !== undefined ) texture.mapping = parseConstant( data.mapping, TEXTURE_MAPPING );\\n\\n\\t\\t\\t\\t\\tif ( data.offset !== undefined ) texture.offset.fromArray( data.offset );\\n\\t\\t\\t\\t\\tif ( data.repeat !== undefined ) texture.repeat.fromArray( data.repeat );\\n\\t\\t\\t\\t\\tif ( data.center !== undefined ) texture.center.fromArray( data.center );\\n\\t\\t\\t\\t\\tif ( data.rotation !== undefined ) texture.rotation = data.rotation;\\n\\n\\t\\t\\t\\t\\tif ( data.wrap !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\ttexture.wrapS = parseConstant( data.wrap[ 0 ], TEXTURE_WRAPPING );\\n\\t\\t\\t\\t\\t\\ttexture.wrapT = parseConstant( data.wrap[ 1 ], TEXTURE_WRAPPING );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( data.minFilter !== undefined ) texture.minFilter = parseConstant( data.minFilter, TEXTURE_FILTER );\\n\\t\\t\\t\\t\\tif ( data.magFilter !== undefined ) texture.magFilter = parseConstant( data.magFilter, TEXTURE_FILTER );\\n\\t\\t\\t\\t\\tif ( data.anisotropy !== undefined ) texture.anisotropy = data.anisotropy;\\n\\n\\t\\t\\t\\t\\tif ( data.flipY !== undefined ) texture.flipY = data.flipY;\\n\\n\\t\\t\\t\\t\\ttextures[ data.uuid ] = texture;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn textures;\\n\\n\\t\\t},\\n\\n\\t\\tparseObject: function () {\\n\\n\\t\\t\\tvar matrix = new Matrix4();\\n\\n\\t\\t\\treturn function parseObject( data, geometries, materials ) {\\n\\n\\t\\t\\t\\tvar object;\\n\\n\\t\\t\\t\\tfunction getGeometry( name ) {\\n\\n\\t\\t\\t\\t\\tif ( geometries[ name ] === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.ObjectLoader: Undefined geometry', name );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\treturn geometries[ name ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfunction getMaterial( name ) {\\n\\n\\t\\t\\t\\t\\tif ( name === undefined ) return undefined;\\n\\n\\t\\t\\t\\t\\tif ( Array.isArray( name ) ) {\\n\\n\\t\\t\\t\\t\\t\\tvar array = [];\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0, l = name.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar uuid = name[ i ];\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( materials[ uuid ] === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.ObjectLoader: Undefined material', uuid );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\tarray.push( materials[ uuid ] );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\treturn array;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( materials[ name ] === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.ObjectLoader: Undefined material', name );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\treturn materials[ name ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tswitch ( data.type ) {\\n\\n\\t\\t\\t\\t\\tcase 'Scene':\\n\\n\\t\\t\\t\\t\\t\\tobject = new Scene();\\n\\n\\t\\t\\t\\t\\t\\tif ( data.background !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( Number.isInteger( data.background ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tobject.background = new Color( data.background );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tif ( data.fog !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( data.fog.type === 'Fog' ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tobject.fog = new Fog( data.fog.color, data.fog.near, data.fog.far );\\n\\n\\t\\t\\t\\t\\t\\t\\t} else if ( data.fog.type === 'FogExp2' ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tobject.fog = new FogExp2( data.fog.color, data.fog.density );\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'PerspectiveCamera':\\n\\n\\t\\t\\t\\t\\t\\tobject = new PerspectiveCamera( data.fov, data.aspect, data.near, data.far );\\n\\n\\t\\t\\t\\t\\t\\tif ( data.focus !== undefined ) object.focus = data.focus;\\n\\t\\t\\t\\t\\t\\tif ( data.zoom !== undefined ) object.zoom = data.zoom;\\n\\t\\t\\t\\t\\t\\tif ( data.filmGauge !== undefined ) object.filmGauge = data.filmGauge;\\n\\t\\t\\t\\t\\t\\tif ( data.filmOffset !== undefined ) object.filmOffset = data.filmOffset;\\n\\t\\t\\t\\t\\t\\tif ( data.view !== undefined ) object.view = Object.assign( {}, data.view );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'OrthographicCamera':\\n\\n\\t\\t\\t\\t\\t\\tobject = new OrthographicCamera( data.left, data.right, data.top, data.bottom, data.near, data.far );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'AmbientLight':\\n\\n\\t\\t\\t\\t\\t\\tobject = new AmbientLight( data.color, data.intensity );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'DirectionalLight':\\n\\n\\t\\t\\t\\t\\t\\tobject = new DirectionalLight( data.color, data.intensity );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'PointLight':\\n\\n\\t\\t\\t\\t\\t\\tobject = new PointLight( data.color, data.intensity, data.distance, data.decay );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'RectAreaLight':\\n\\n\\t\\t\\t\\t\\t\\tobject = new RectAreaLight( data.color, data.intensity, data.width, data.height );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'SpotLight':\\n\\n\\t\\t\\t\\t\\t\\tobject = new SpotLight( data.color, data.intensity, data.distance, data.angle, data.penumbra, data.decay );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'HemisphereLight':\\n\\n\\t\\t\\t\\t\\t\\tobject = new HemisphereLight( data.color, data.groundColor, data.intensity );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'SkinnedMesh':\\n\\n\\t\\t\\t\\t\\t\\tconsole.warn( 'THREE.ObjectLoader.parseObject() does not support SkinnedMesh yet.' );\\n\\n\\t\\t\\t\\t\\tcase 'Mesh':\\n\\n\\t\\t\\t\\t\\t\\tvar geometry = getGeometry( data.geometry );\\n\\t\\t\\t\\t\\t\\tvar material = getMaterial( data.material );\\n\\n\\t\\t\\t\\t\\t\\tif ( geometry.bones && geometry.bones.length > 0 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tobject = new SkinnedMesh( geometry, material );\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tobject = new Mesh( geometry, material );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'LOD':\\n\\n\\t\\t\\t\\t\\t\\tobject = new LOD();\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'Line':\\n\\n\\t\\t\\t\\t\\t\\tobject = new Line( getGeometry( data.geometry ), getMaterial( data.material ), data.mode );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'LineLoop':\\n\\n\\t\\t\\t\\t\\t\\tobject = new LineLoop( getGeometry( data.geometry ), getMaterial( data.material ) );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'LineSegments':\\n\\n\\t\\t\\t\\t\\t\\tobject = new LineSegments( getGeometry( data.geometry ), getMaterial( data.material ) );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'PointCloud':\\n\\t\\t\\t\\t\\tcase 'Points':\\n\\n\\t\\t\\t\\t\\t\\tobject = new Points( getGeometry( data.geometry ), getMaterial( data.material ) );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'Sprite':\\n\\n\\t\\t\\t\\t\\t\\tobject = new Sprite( getMaterial( data.material ) );\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'Group':\\n\\n\\t\\t\\t\\t\\t\\tobject = new Group();\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tdefault:\\n\\n\\t\\t\\t\\t\\t\\tobject = new Object3D();\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tobject.uuid = data.uuid;\\n\\n\\t\\t\\t\\tif ( data.name !== undefined ) object.name = data.name;\\n\\t\\t\\t\\tif ( data.matrix !== undefined ) {\\n\\n\\t\\t\\t\\t\\tmatrix.fromArray( data.matrix );\\n\\t\\t\\t\\t\\tmatrix.decompose( object.position, object.quaternion, object.scale );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tif ( data.position !== undefined ) object.position.fromArray( data.position );\\n\\t\\t\\t\\t\\tif ( data.rotation !== undefined ) object.rotation.fromArray( data.rotation );\\n\\t\\t\\t\\t\\tif ( data.quaternion !== undefined ) object.quaternion.fromArray( data.quaternion );\\n\\t\\t\\t\\t\\tif ( data.scale !== undefined ) object.scale.fromArray( data.scale );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( data.castShadow !== undefined ) object.castShadow = data.castShadow;\\n\\t\\t\\t\\tif ( data.receiveShadow !== undefined ) object.receiveShadow = data.receiveShadow;\\n\\n\\t\\t\\t\\tif ( data.shadow ) {\\n\\n\\t\\t\\t\\t\\tif ( data.shadow.bias !== undefined ) object.shadow.bias = data.shadow.bias;\\n\\t\\t\\t\\t\\tif ( data.shadow.radius !== undefined ) object.shadow.radius = data.shadow.radius;\\n\\t\\t\\t\\t\\tif ( data.shadow.mapSize !== undefined ) object.shadow.mapSize.fromArray( data.shadow.mapSize );\\n\\t\\t\\t\\t\\tif ( data.shadow.camera !== undefined ) object.shadow.camera = this.parseObject( data.shadow.camera );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( data.visible !== undefined ) object.visible = data.visible;\\n\\t\\t\\t\\tif ( data.userData !== undefined ) object.userData = data.userData;\\n\\n\\t\\t\\t\\tif ( data.children !== undefined ) {\\n\\n\\t\\t\\t\\t\\tvar children = data.children;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < children.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tobject.add( this.parseObject( children[ i ], geometries, materials ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( data.type === 'LOD' ) {\\n\\n\\t\\t\\t\\t\\tvar levels = data.levels;\\n\\n\\t\\t\\t\\t\\tfor ( var l = 0; l < levels.length; l ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar level = levels[ l ];\\n\\t\\t\\t\\t\\t\\tvar child = object.getObjectByProperty( 'uuid', level.object );\\n\\n\\t\\t\\t\\t\\t\\tif ( child !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tobject.addLevel( child, level.distance );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn object;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}()\\n\\n\\t} );\\n\\n\\tvar TEXTURE_MAPPING = {\\n\\t\\tUVMapping: UVMapping,\\n\\t\\tCubeReflectionMapping: CubeReflectionMapping,\\n\\t\\tCubeRefractionMapping: CubeRefractionMapping,\\n\\t\\tEquirectangularReflectionMapping: EquirectangularReflectionMapping,\\n\\t\\tEquirectangularRefractionMapping: EquirectangularRefractionMapping,\\n\\t\\tSphericalReflectionMapping: SphericalReflectionMapping,\\n\\t\\tCubeUVReflectionMapping: CubeUVReflectionMapping,\\n\\t\\tCubeUVRefractionMapping: CubeUVRefractionMapping\\n\\t};\\n\\n\\tvar TEXTURE_WRAPPING = {\\n\\t\\tRepeatWrapping: RepeatWrapping,\\n\\t\\tClampToEdgeWrapping: ClampToEdgeWrapping,\\n\\t\\tMirroredRepeatWrapping: MirroredRepeatWrapping\\n\\t};\\n\\n\\tvar TEXTURE_FILTER = {\\n\\t\\tNearestFilter: NearestFilter,\\n\\t\\tNearestMipMapNearestFilter: NearestMipMapNearestFilter,\\n\\t\\tNearestMipMapLinearFilter: NearestMipMapLinearFilter,\\n\\t\\tLinearFilter: LinearFilter,\\n\\t\\tLinearMipMapNearestFilter: LinearMipMapNearestFilter,\\n\\t\\tLinearMipMapLinearFilter: LinearMipMapLinearFilter\\n\\t};\\n\\n\\t/**\\n\\t * @author thespite / http://clicktorelease.com/\\n\\t */\\n\\n\\tfunction ImageBitmapLoader( manager ) {\\n\\n\\t\\tif ( typeof createImageBitmap === 'undefined' ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.ImageBitmapLoader: createImageBitmap() not supported.' );\\n\\n\\t\\t}\\n\\n\\t\\tif ( typeof fetch === 'undefined' ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.ImageBitmapLoader: fetch() not supported.' );\\n\\n\\t\\t}\\n\\n\\t\\tthis.manager = manager !== undefined ? manager : DefaultLoadingManager;\\n\\t\\tthis.options = undefined;\\n\\n\\t}\\n\\n\\tImageBitmapLoader.prototype = {\\n\\n\\t\\tconstructor: ImageBitmapLoader,\\n\\n\\t\\tsetOptions: function setOptions( options ) {\\n\\n\\t\\t\\tthis.options = options;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tload: function load( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tif ( url === undefined ) url = '';\\n\\n\\t\\t\\tif ( this.path !== undefined ) url = this.path + url;\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar cached = Cache.get( url );\\n\\n\\t\\t\\tif ( cached !== undefined ) {\\n\\n\\t\\t\\t\\tscope.manager.itemStart( url );\\n\\n\\t\\t\\t\\tsetTimeout( function () {\\n\\n\\t\\t\\t\\t\\tif ( onLoad ) onLoad( cached );\\n\\n\\t\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t\\t}, 0 );\\n\\n\\t\\t\\t\\treturn cached;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfetch( url ).then( function ( res ) {\\n\\n\\t\\t\\t\\treturn res.blob();\\n\\n\\t\\t\\t} ).then( function ( blob ) {\\n\\n\\t\\t\\t\\treturn createImageBitmap( blob, scope.options );\\n\\n\\t\\t\\t} ).then( function ( imageBitmap ) {\\n\\n\\t\\t\\t\\tCache.add( url, imageBitmap );\\n\\n\\t\\t\\t\\tif ( onLoad ) onLoad( imageBitmap );\\n\\n\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\n\\t\\t\\t} ).catch( function ( e ) {\\n\\n\\t\\t\\t\\tif ( onError ) onError( e );\\n\\n\\t\\t\\t\\tscope.manager.itemEnd( url );\\n\\t\\t\\t\\tscope.manager.itemError( url );\\n\\n\\t\\t\\t} );\\n\\n\\t\\t},\\n\\n\\t\\tsetCrossOrigin: function ( /* value */ ) {\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetPath: function ( value ) {\\n\\n\\t\\t\\tthis.path = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t * minimal class for proxing functions to Path. Replaces old \\\"extractSubpaths()\\\"\\n\\t **/\\n\\n\\tfunction ShapePath() {\\n\\n\\t\\tthis.type = 'ShapePath';\\n\\n\\t\\tthis.subPaths = [];\\n\\t\\tthis.currentPath = null;\\n\\n\\t}\\n\\n\\tObject.assign( ShapePath.prototype, {\\n\\n\\t\\tmoveTo: function ( x, y ) {\\n\\n\\t\\t\\tthis.currentPath = new Path();\\n\\t\\t\\tthis.subPaths.push( this.currentPath );\\n\\t\\t\\tthis.currentPath.moveTo( x, y );\\n\\n\\t\\t},\\n\\n\\t\\tlineTo: function ( x, y ) {\\n\\n\\t\\t\\tthis.currentPath.lineTo( x, y );\\n\\n\\t\\t},\\n\\n\\t\\tquadraticCurveTo: function ( aCPx, aCPy, aX, aY ) {\\n\\n\\t\\t\\tthis.currentPath.quadraticCurveTo( aCPx, aCPy, aX, aY );\\n\\n\\t\\t},\\n\\n\\t\\tbezierCurveTo: function ( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY ) {\\n\\n\\t\\t\\tthis.currentPath.bezierCurveTo( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY );\\n\\n\\t\\t},\\n\\n\\t\\tsplineThru: function ( pts ) {\\n\\n\\t\\t\\tthis.currentPath.splineThru( pts );\\n\\n\\t\\t},\\n\\n\\t\\ttoShapes: function ( isCCW, noHoles ) {\\n\\n\\t\\t\\tfunction toShapesNoHoles( inSubpaths ) {\\n\\n\\t\\t\\t\\tvar shapes = [];\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = inSubpaths.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar tmpPath = inSubpaths[ i ];\\n\\n\\t\\t\\t\\t\\tvar tmpShape = new Shape();\\n\\t\\t\\t\\t\\ttmpShape.curves = tmpPath.curves;\\n\\n\\t\\t\\t\\t\\tshapes.push( tmpShape );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn shapes;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction isPointInsidePolygon( inPt, inPolygon ) {\\n\\n\\t\\t\\t\\tvar polyLen = inPolygon.length;\\n\\n\\t\\t\\t\\t// inPt on polygon contour => immediate success    or\\n\\t\\t\\t\\t// toggling of inside/outside at every single! intersection point of an edge\\n\\t\\t\\t\\t//  with the horizontal line through inPt, left of inPt\\n\\t\\t\\t\\t//  not counting lowerY endpoints of edges and whole edges on that line\\n\\t\\t\\t\\tvar inside = false;\\n\\t\\t\\t\\tfor ( var p = polyLen - 1, q = 0; q < polyLen; p = q ++ ) {\\n\\n\\t\\t\\t\\t\\tvar edgeLowPt = inPolygon[ p ];\\n\\t\\t\\t\\t\\tvar edgeHighPt = inPolygon[ q ];\\n\\n\\t\\t\\t\\t\\tvar edgeDx = edgeHighPt.x - edgeLowPt.x;\\n\\t\\t\\t\\t\\tvar edgeDy = edgeHighPt.y - edgeLowPt.y;\\n\\n\\t\\t\\t\\t\\tif ( Math.abs( edgeDy ) > Number.EPSILON ) {\\n\\n\\t\\t\\t\\t\\t\\t// not parallel\\n\\t\\t\\t\\t\\t\\tif ( edgeDy < 0 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tedgeLowPt = inPolygon[ q ]; edgeDx = - edgeDx;\\n\\t\\t\\t\\t\\t\\t\\tedgeHighPt = inPolygon[ p ]; edgeDy = - edgeDy;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\tif ( ( inPt.y < edgeLowPt.y ) || ( inPt.y > edgeHighPt.y ) ) \\t\\tcontinue;\\n\\n\\t\\t\\t\\t\\t\\tif ( inPt.y === edgeLowPt.y ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( inPt.x === edgeLowPt.x )\\t\\treturn\\ttrue;\\t\\t// inPt is on contour ?\\n\\t\\t\\t\\t\\t\\t\\t// continue;\\t\\t\\t\\t// no intersection or edgeLowPt => doesn't count !!!\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar perpEdge = edgeDy * ( inPt.x - edgeLowPt.x ) - edgeDx * ( inPt.y - edgeLowPt.y );\\n\\t\\t\\t\\t\\t\\t\\tif ( perpEdge === 0 )\\t\\t\\t\\treturn\\ttrue;\\t\\t// inPt is on contour ?\\n\\t\\t\\t\\t\\t\\t\\tif ( perpEdge < 0 ) \\t\\t\\t\\tcontinue;\\n\\t\\t\\t\\t\\t\\t\\tinside = ! inside;\\t\\t// true intersection left of inPt\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t// parallel or collinear\\n\\t\\t\\t\\t\\t\\tif ( inPt.y !== edgeLowPt.y ) \\t\\tcontinue;\\t\\t\\t// parallel\\n\\t\\t\\t\\t\\t\\t// edge lies on the same horizontal line as inPt\\n\\t\\t\\t\\t\\t\\tif ( ( ( edgeHighPt.x <= inPt.x ) && ( inPt.x <= edgeLowPt.x ) ) ||\\n\\t\\t\\t\\t\\t\\t\\t ( ( edgeLowPt.x <= inPt.x ) && ( inPt.x <= edgeHighPt.x ) ) )\\t\\treturn\\ttrue;\\t// inPt: Point on contour !\\n\\t\\t\\t\\t\\t\\t// continue;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn\\tinside;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar isClockWise = ShapeUtils.isClockWise;\\n\\n\\t\\t\\tvar subPaths = this.subPaths;\\n\\t\\t\\tif ( subPaths.length === 0 ) return [];\\n\\n\\t\\t\\tif ( noHoles === true )\\treturn\\ttoShapesNoHoles( subPaths );\\n\\n\\n\\t\\t\\tvar solid, tmpPath, tmpShape, shapes = [];\\n\\n\\t\\t\\tif ( subPaths.length === 1 ) {\\n\\n\\t\\t\\t\\ttmpPath = subPaths[ 0 ];\\n\\t\\t\\t\\ttmpShape = new Shape();\\n\\t\\t\\t\\ttmpShape.curves = tmpPath.curves;\\n\\t\\t\\t\\tshapes.push( tmpShape );\\n\\t\\t\\t\\treturn shapes;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar holesFirst = ! isClockWise( subPaths[ 0 ].getPoints() );\\n\\t\\t\\tholesFirst = isCCW ? ! holesFirst : holesFirst;\\n\\n\\t\\t\\t// console.log(\\\"Holes first\\\", holesFirst);\\n\\n\\t\\t\\tvar betterShapeHoles = [];\\n\\t\\t\\tvar newShapes = [];\\n\\t\\t\\tvar newShapeHoles = [];\\n\\t\\t\\tvar mainIdx = 0;\\n\\t\\t\\tvar tmpPoints;\\n\\n\\t\\t\\tnewShapes[ mainIdx ] = undefined;\\n\\t\\t\\tnewShapeHoles[ mainIdx ] = [];\\n\\n\\t\\t\\tfor ( var i = 0, l = subPaths.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\ttmpPath = subPaths[ i ];\\n\\t\\t\\t\\ttmpPoints = tmpPath.getPoints();\\n\\t\\t\\t\\tsolid = isClockWise( tmpPoints );\\n\\t\\t\\t\\tsolid = isCCW ? ! solid : solid;\\n\\n\\t\\t\\t\\tif ( solid ) {\\n\\n\\t\\t\\t\\t\\tif ( ( ! holesFirst ) && ( newShapes[ mainIdx ] ) )\\tmainIdx ++;\\n\\n\\t\\t\\t\\t\\tnewShapes[ mainIdx ] = { s: new Shape(), p: tmpPoints };\\n\\t\\t\\t\\t\\tnewShapes[ mainIdx ].s.curves = tmpPath.curves;\\n\\n\\t\\t\\t\\t\\tif ( holesFirst )\\tmainIdx ++;\\n\\t\\t\\t\\t\\tnewShapeHoles[ mainIdx ] = [];\\n\\n\\t\\t\\t\\t\\t//console.log('cw', i);\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tnewShapeHoles[ mainIdx ].push( { h: tmpPath, p: tmpPoints[ 0 ] } );\\n\\n\\t\\t\\t\\t\\t//console.log('ccw', i);\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// only Holes? -> probably all Shapes with wrong orientation\\n\\t\\t\\tif ( ! newShapes[ 0 ] )\\treturn\\ttoShapesNoHoles( subPaths );\\n\\n\\n\\t\\t\\tif ( newShapes.length > 1 ) {\\n\\n\\t\\t\\t\\tvar ambiguous = false;\\n\\t\\t\\t\\tvar toChange = [];\\n\\n\\t\\t\\t\\tfor ( var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) {\\n\\n\\t\\t\\t\\t\\tbetterShapeHoles[ sIdx ] = [];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tfor ( var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) {\\n\\n\\t\\t\\t\\t\\tvar sho = newShapeHoles[ sIdx ];\\n\\n\\t\\t\\t\\t\\tfor ( var hIdx = 0; hIdx < sho.length; hIdx ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar ho = sho[ hIdx ];\\n\\t\\t\\t\\t\\t\\tvar hole_unassigned = true;\\n\\n\\t\\t\\t\\t\\t\\tfor ( var s2Idx = 0; s2Idx < newShapes.length; s2Idx ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( isPointInsidePolygon( ho.p, newShapes[ s2Idx ].p ) ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( sIdx !== s2Idx )\\ttoChange.push( { froms: sIdx, tos: s2Idx, hole: hIdx } );\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( hole_unassigned ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\thole_unassigned = false;\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tbetterShapeHoles[ s2Idx ].push( ho );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tambiguous = true;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\t\\tif ( hole_unassigned ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tbetterShapeHoles[ sIdx ].push( ho );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\t\\t\\t\\t// console.log(\\\"ambiguous: \\\", ambiguous);\\n\\t\\t\\t\\tif ( toChange.length > 0 ) {\\n\\n\\t\\t\\t\\t\\t// console.log(\\\"to change: \\\", toChange);\\n\\t\\t\\t\\t\\tif ( ! ambiguous )\\tnewShapeHoles = betterShapeHoles;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar tmpHoles;\\n\\n\\t\\t\\tfor ( var i = 0, il = newShapes.length; i < il; i ++ ) {\\n\\n\\t\\t\\t\\ttmpShape = newShapes[ i ].s;\\n\\t\\t\\t\\tshapes.push( tmpShape );\\n\\t\\t\\t\\ttmpHoles = newShapeHoles[ i ];\\n\\n\\t\\t\\t\\tfor ( var j = 0, jl = tmpHoles.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\ttmpShape.holes.push( tmpHoles[ j ].h );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//console.log(\\\"shape\\\", shapes);\\n\\n\\t\\t\\treturn shapes;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author zz85 / http://www.lab4games.net/zz85/blog\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Font( data ) {\\n\\n\\t\\tthis.type = 'Font';\\n\\n\\t\\tthis.data = data;\\n\\n\\t}\\n\\n\\tObject.assign( Font.prototype, {\\n\\n\\t\\tisFont: true,\\n\\n\\t\\tgenerateShapes: function ( text, size, divisions ) {\\n\\n\\t\\t\\tfunction createPaths( text ) {\\n\\n\\t\\t\\t\\tvar chars = String( text ).split( '' );\\n\\t\\t\\t\\tvar scale = size / data.resolution;\\n\\t\\t\\t\\tvar line_height = ( data.boundingBox.yMax - data.boundingBox.yMin + data.underlineThickness ) * scale;\\n\\n\\t\\t\\t\\tvar offsetX = 0, offsetY = 0;\\n\\n\\t\\t\\t\\tvar paths = [];\\n\\n\\t\\t\\t\\tfor ( var i = 0; i < chars.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar char = chars[ i ];\\n\\n\\t\\t\\t\\t\\tif ( char === '\\\\n' ) {\\n\\n\\t\\t\\t\\t\\t\\toffsetX = 0;\\n\\t\\t\\t\\t\\t\\toffsetY -= line_height;\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tvar ret = createPath( char, scale, offsetX, offsetY );\\n\\t\\t\\t\\t\\t\\toffsetX += ret.offsetX;\\n\\t\\t\\t\\t\\t\\tpaths.push( ret.path );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn paths;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfunction createPath( c, scale, offsetX, offsetY ) {\\n\\n\\t\\t\\t\\tvar glyph = data.glyphs[ c ] || data.glyphs[ '?' ];\\n\\n\\t\\t\\t\\tif ( ! glyph ) return;\\n\\n\\t\\t\\t\\tvar path = new ShapePath();\\n\\n\\t\\t\\t\\tvar pts = [];\\n\\t\\t\\t\\tvar x, y, cpx, cpy, cpx0, cpy0, cpx1, cpy1, cpx2, cpy2, laste;\\n\\n\\t\\t\\t\\tif ( glyph.o ) {\\n\\n\\t\\t\\t\\t\\tvar outline = glyph._cachedOutline || ( glyph._cachedOutline = glyph.o.split( ' ' ) );\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, l = outline.length; i < l; ) {\\n\\n\\t\\t\\t\\t\\t\\tvar action = outline[ i ++ ];\\n\\n\\t\\t\\t\\t\\t\\tswitch ( action ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tcase 'm': // moveTo\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tx = outline[ i ++ ] * scale + offsetX;\\n\\t\\t\\t\\t\\t\\t\\t\\ty = outline[ i ++ ] * scale + offsetY;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tpath.moveTo( x, y );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\tcase 'l': // lineTo\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tx = outline[ i ++ ] * scale + offsetX;\\n\\t\\t\\t\\t\\t\\t\\t\\ty = outline[ i ++ ] * scale + offsetY;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tpath.lineTo( x, y );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\tcase 'q': // quadraticCurveTo\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcpx = outline[ i ++ ] * scale + offsetX;\\n\\t\\t\\t\\t\\t\\t\\t\\tcpy = outline[ i ++ ] * scale + offsetY;\\n\\t\\t\\t\\t\\t\\t\\t\\tcpx1 = outline[ i ++ ] * scale + offsetX;\\n\\t\\t\\t\\t\\t\\t\\t\\tcpy1 = outline[ i ++ ] * scale + offsetY;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tpath.quadraticCurveTo( cpx1, cpy1, cpx, cpy );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tlaste = pts[ pts.length - 1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( laste ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcpx0 = laste.x;\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcpy0 = laste.y;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\tcase 'b': // bezierCurveTo\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tcpx = outline[ i ++ ] * scale + offsetX;\\n\\t\\t\\t\\t\\t\\t\\t\\tcpy = outline[ i ++ ] * scale + offsetY;\\n\\t\\t\\t\\t\\t\\t\\t\\tcpx1 = outline[ i ++ ] * scale + offsetX;\\n\\t\\t\\t\\t\\t\\t\\t\\tcpy1 = outline[ i ++ ] * scale + offsetY;\\n\\t\\t\\t\\t\\t\\t\\t\\tcpx2 = outline[ i ++ ] * scale + offsetX;\\n\\t\\t\\t\\t\\t\\t\\t\\tcpy2 = outline[ i ++ ] * scale + offsetY;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tpath.bezierCurveTo( cpx1, cpy1, cpx2, cpy2, cpx, cpy );\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tlaste = pts[ pts.length - 1 ];\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tif ( laste ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcpx0 = laste.x;\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tcpy0 = laste.y;\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\n\\n\\t\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn { offsetX: glyph.ha * scale, path: path };\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tif ( size === undefined ) size = 100;\\n\\t\\t\\tif ( divisions === undefined ) divisions = 4;\\n\\n\\t\\t\\tvar data = this.data;\\n\\n\\t\\t\\tvar paths = createPaths( text );\\n\\t\\t\\tvar shapes = [];\\n\\n\\t\\t\\tfor ( var p = 0, pl = paths.length; p < pl; p ++ ) {\\n\\n\\t\\t\\t\\tArray.prototype.push.apply( shapes, paths[ p ].toShapes() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn shapes;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction FontLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t}\\n\\n\\tObject.assign( FontLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tvar loader = new FileLoader( this.manager );\\n\\t\\t\\tloader.setPath( this.path );\\n\\t\\t\\tloader.load( url, function ( text ) {\\n\\n\\t\\t\\t\\tvar json;\\n\\n\\t\\t\\t\\ttry {\\n\\n\\t\\t\\t\\t\\tjson = JSON.parse( text );\\n\\n\\t\\t\\t\\t} catch ( e ) {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.FontLoader: typeface.js support is being deprecated. Use typeface.json instead.' );\\n\\t\\t\\t\\t\\tjson = JSON.parse( text.substring( 65, text.length - 2 ) );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar font = scope.parse( json );\\n\\n\\t\\t\\t\\tif ( onLoad ) onLoad( font );\\n\\n\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t},\\n\\n\\t\\tparse: function ( json ) {\\n\\n\\t\\t\\treturn new Font( json );\\n\\n\\t\\t},\\n\\n\\t\\tsetPath: function ( value ) {\\n\\n\\t\\t\\tthis.path = value;\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tvar context;\\n\\n\\tvar AudioContext = {\\n\\n\\t\\tgetContext: function () {\\n\\n\\t\\t\\tif ( context === undefined ) {\\n\\n\\t\\t\\t\\tcontext = new ( window.AudioContext || window.webkitAudioContext )();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn context;\\n\\n\\t\\t},\\n\\n\\t\\tsetContext: function ( value ) {\\n\\n\\t\\t\\tcontext = value;\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author Reece Aaron Lecrivain / http://reecenotes.com/\\n\\t */\\n\\n\\tfunction AudioLoader( manager ) {\\n\\n\\t\\tthis.manager = ( manager !== undefined ) ? manager : DefaultLoadingManager;\\n\\n\\t}\\n\\n\\tObject.assign( AudioLoader.prototype, {\\n\\n\\t\\tload: function ( url, onLoad, onProgress, onError ) {\\n\\n\\t\\t\\tvar loader = new FileLoader( this.manager );\\n\\t\\t\\tloader.setResponseType( 'arraybuffer' );\\n\\t\\t\\tloader.load( url, function ( buffer ) {\\n\\n\\t\\t\\t\\tvar context = AudioContext.getContext();\\n\\n\\t\\t\\t\\tcontext.decodeAudioData( buffer, function ( audioBuffer ) {\\n\\n\\t\\t\\t\\t\\tonLoad( audioBuffer );\\n\\n\\t\\t\\t\\t} );\\n\\n\\t\\t\\t}, onProgress, onError );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction StereoCamera() {\\n\\n\\t\\tthis.type = 'StereoCamera';\\n\\n\\t\\tthis.aspect = 1;\\n\\n\\t\\tthis.eyeSep = 0.064;\\n\\n\\t\\tthis.cameraL = new PerspectiveCamera();\\n\\t\\tthis.cameraL.layers.enable( 1 );\\n\\t\\tthis.cameraL.matrixAutoUpdate = false;\\n\\n\\t\\tthis.cameraR = new PerspectiveCamera();\\n\\t\\tthis.cameraR.layers.enable( 2 );\\n\\t\\tthis.cameraR.matrixAutoUpdate = false;\\n\\n\\t}\\n\\n\\tObject.assign( StereoCamera.prototype, {\\n\\n\\t\\tupdate: ( function () {\\n\\n\\t\\t\\tvar instance, focus, fov, aspect, near, far, zoom, eyeSep;\\n\\n\\t\\t\\tvar eyeRight = new Matrix4();\\n\\t\\t\\tvar eyeLeft = new Matrix4();\\n\\n\\t\\t\\treturn function update( camera ) {\\n\\n\\t\\t\\t\\tvar needsUpdate = instance !== this || focus !== camera.focus || fov !== camera.fov ||\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\taspect !== camera.aspect * this.aspect || near !== camera.near ||\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tfar !== camera.far || zoom !== camera.zoom || eyeSep !== this.eyeSep;\\n\\n\\t\\t\\t\\tif ( needsUpdate ) {\\n\\n\\t\\t\\t\\t\\tinstance = this;\\n\\t\\t\\t\\t\\tfocus = camera.focus;\\n\\t\\t\\t\\t\\tfov = camera.fov;\\n\\t\\t\\t\\t\\taspect = camera.aspect * this.aspect;\\n\\t\\t\\t\\t\\tnear = camera.near;\\n\\t\\t\\t\\t\\tfar = camera.far;\\n\\t\\t\\t\\t\\tzoom = camera.zoom;\\n\\n\\t\\t\\t\\t\\t// Off-axis stereoscopic effect based on\\n\\t\\t\\t\\t\\t// http://paulbourke.net/stereographics/stereorender/\\n\\n\\t\\t\\t\\t\\tvar projectionMatrix = camera.projectionMatrix.clone();\\n\\t\\t\\t\\t\\teyeSep = this.eyeSep / 2;\\n\\t\\t\\t\\t\\tvar eyeSepOnProjection = eyeSep * near / focus;\\n\\t\\t\\t\\t\\tvar ymax = ( near * Math.tan( _Math.DEG2RAD * fov * 0.5 ) ) / zoom;\\n\\t\\t\\t\\t\\tvar xmin, xmax;\\n\\n\\t\\t\\t\\t\\t// translate xOffset\\n\\n\\t\\t\\t\\t\\teyeLeft.elements[ 12 ] = - eyeSep;\\n\\t\\t\\t\\t\\teyeRight.elements[ 12 ] = eyeSep;\\n\\n\\t\\t\\t\\t\\t// for left eye\\n\\n\\t\\t\\t\\t\\txmin = - ymax * aspect + eyeSepOnProjection;\\n\\t\\t\\t\\t\\txmax = ymax * aspect + eyeSepOnProjection;\\n\\n\\t\\t\\t\\t\\tprojectionMatrix.elements[ 0 ] = 2 * near / ( xmax - xmin );\\n\\t\\t\\t\\t\\tprojectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin );\\n\\n\\t\\t\\t\\t\\tthis.cameraL.projectionMatrix.copy( projectionMatrix );\\n\\n\\t\\t\\t\\t\\t// for right eye\\n\\n\\t\\t\\t\\t\\txmin = - ymax * aspect - eyeSepOnProjection;\\n\\t\\t\\t\\t\\txmax = ymax * aspect - eyeSepOnProjection;\\n\\n\\t\\t\\t\\t\\tprojectionMatrix.elements[ 0 ] = 2 * near / ( xmax - xmin );\\n\\t\\t\\t\\t\\tprojectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin );\\n\\n\\t\\t\\t\\t\\tthis.cameraR.projectionMatrix.copy( projectionMatrix );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.cameraL.matrixWorld.copy( camera.matrixWorld ).multiply( eyeLeft );\\n\\t\\t\\t\\tthis.cameraR.matrixWorld.copy( camera.matrixWorld ).multiply( eyeRight );\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )()\\n\\n\\t} );\\n\\n\\t/**\\n\\t * Camera for rendering cube maps\\n\\t *\\t- renders scene into axis-aligned cube\\n\\t *\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction CubeCamera( near, far, cubeResolution ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'CubeCamera';\\n\\n\\t\\tvar fov = 90, aspect = 1;\\n\\n\\t\\tvar cameraPX = new PerspectiveCamera( fov, aspect, near, far );\\n\\t\\tcameraPX.up.set( 0, - 1, 0 );\\n\\t\\tcameraPX.lookAt( new Vector3( 1, 0, 0 ) );\\n\\t\\tthis.add( cameraPX );\\n\\n\\t\\tvar cameraNX = new PerspectiveCamera( fov, aspect, near, far );\\n\\t\\tcameraNX.up.set( 0, - 1, 0 );\\n\\t\\tcameraNX.lookAt( new Vector3( - 1, 0, 0 ) );\\n\\t\\tthis.add( cameraNX );\\n\\n\\t\\tvar cameraPY = new PerspectiveCamera( fov, aspect, near, far );\\n\\t\\tcameraPY.up.set( 0, 0, 1 );\\n\\t\\tcameraPY.lookAt( new Vector3( 0, 1, 0 ) );\\n\\t\\tthis.add( cameraPY );\\n\\n\\t\\tvar cameraNY = new PerspectiveCamera( fov, aspect, near, far );\\n\\t\\tcameraNY.up.set( 0, 0, - 1 );\\n\\t\\tcameraNY.lookAt( new Vector3( 0, - 1, 0 ) );\\n\\t\\tthis.add( cameraNY );\\n\\n\\t\\tvar cameraPZ = new PerspectiveCamera( fov, aspect, near, far );\\n\\t\\tcameraPZ.up.set( 0, - 1, 0 );\\n\\t\\tcameraPZ.lookAt( new Vector3( 0, 0, 1 ) );\\n\\t\\tthis.add( cameraPZ );\\n\\n\\t\\tvar cameraNZ = new PerspectiveCamera( fov, aspect, near, far );\\n\\t\\tcameraNZ.up.set( 0, - 1, 0 );\\n\\t\\tcameraNZ.lookAt( new Vector3( 0, 0, - 1 ) );\\n\\t\\tthis.add( cameraNZ );\\n\\n\\t\\tvar options = { format: RGBFormat, magFilter: LinearFilter, minFilter: LinearFilter };\\n\\n\\t\\tthis.renderTarget = new WebGLRenderTargetCube( cubeResolution, cubeResolution, options );\\n\\t\\tthis.renderTarget.texture.name = \\\"CubeCamera\\\";\\n\\n\\t\\tthis.update = function ( renderer, scene ) {\\n\\n\\t\\t\\tif ( this.parent === null ) this.updateMatrixWorld();\\n\\n\\t\\t\\tvar renderTarget = this.renderTarget;\\n\\t\\t\\tvar generateMipmaps = renderTarget.texture.generateMipmaps;\\n\\n\\t\\t\\trenderTarget.texture.generateMipmaps = false;\\n\\n\\t\\t\\trenderTarget.activeCubeFace = 0;\\n\\t\\t\\trenderer.render( scene, cameraPX, renderTarget );\\n\\n\\t\\t\\trenderTarget.activeCubeFace = 1;\\n\\t\\t\\trenderer.render( scene, cameraNX, renderTarget );\\n\\n\\t\\t\\trenderTarget.activeCubeFace = 2;\\n\\t\\t\\trenderer.render( scene, cameraPY, renderTarget );\\n\\n\\t\\t\\trenderTarget.activeCubeFace = 3;\\n\\t\\t\\trenderer.render( scene, cameraNY, renderTarget );\\n\\n\\t\\t\\trenderTarget.activeCubeFace = 4;\\n\\t\\t\\trenderer.render( scene, cameraPZ, renderTarget );\\n\\n\\t\\t\\trenderTarget.texture.generateMipmaps = generateMipmaps;\\n\\n\\t\\t\\trenderTarget.activeCubeFace = 5;\\n\\t\\t\\trenderer.render( scene, cameraNZ, renderTarget );\\n\\n\\t\\t\\trenderer.setRenderTarget( null );\\n\\n\\t\\t};\\n\\n\\t\\tthis.clear = function ( renderer, color, depth, stencil ) {\\n\\n\\t\\t\\tvar renderTarget = this.renderTarget;\\n\\n\\t\\t\\tfor ( var i = 0; i < 6; i ++ ) {\\n\\n\\t\\t\\t\\trenderTarget.activeCubeFace = i;\\n\\t\\t\\t\\trenderer.setRenderTarget( renderTarget );\\n\\n\\t\\t\\t\\trenderer.clear( color, depth, stencil );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\trenderer.setRenderTarget( null );\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\tCubeCamera.prototype = Object.create( Object3D.prototype );\\n\\tCubeCamera.prototype.constructor = CubeCamera;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction AudioListener() {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'AudioListener';\\n\\n\\t\\tthis.context = AudioContext.getContext();\\n\\n\\t\\tthis.gain = this.context.createGain();\\n\\t\\tthis.gain.connect( this.context.destination );\\n\\n\\t\\tthis.filter = null;\\n\\n\\t}\\n\\n\\tAudioListener.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: AudioListener,\\n\\n\\t\\tgetInput: function () {\\n\\n\\t\\t\\treturn this.gain;\\n\\n\\t\\t},\\n\\n\\t\\tremoveFilter: function ( ) {\\n\\n\\t\\t\\tif ( this.filter !== null ) {\\n\\n\\t\\t\\t\\tthis.gain.disconnect( this.filter );\\n\\t\\t\\t\\tthis.filter.disconnect( this.context.destination );\\n\\t\\t\\t\\tthis.gain.connect( this.context.destination );\\n\\t\\t\\t\\tthis.filter = null;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tgetFilter: function () {\\n\\n\\t\\t\\treturn this.filter;\\n\\n\\t\\t},\\n\\n\\t\\tsetFilter: function ( value ) {\\n\\n\\t\\t\\tif ( this.filter !== null ) {\\n\\n\\t\\t\\t\\tthis.gain.disconnect( this.filter );\\n\\t\\t\\t\\tthis.filter.disconnect( this.context.destination );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.gain.disconnect( this.context.destination );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.filter = value;\\n\\t\\t\\tthis.gain.connect( this.filter );\\n\\t\\t\\tthis.filter.connect( this.context.destination );\\n\\n\\t\\t},\\n\\n\\t\\tgetMasterVolume: function () {\\n\\n\\t\\t\\treturn this.gain.gain.value;\\n\\n\\t\\t},\\n\\n\\t\\tsetMasterVolume: function ( value ) {\\n\\n\\t\\t\\tthis.gain.gain.value = value;\\n\\n\\t\\t},\\n\\n\\t\\tupdateMatrixWorld: ( function () {\\n\\n\\t\\t\\tvar position = new Vector3();\\n\\t\\t\\tvar quaternion = new Quaternion();\\n\\t\\t\\tvar scale = new Vector3();\\n\\n\\t\\t\\tvar orientation = new Vector3();\\n\\n\\t\\t\\treturn function updateMatrixWorld( force ) {\\n\\n\\t\\t\\t\\tObject3D.prototype.updateMatrixWorld.call( this, force );\\n\\n\\t\\t\\t\\tvar listener = this.context.listener;\\n\\t\\t\\t\\tvar up = this.up;\\n\\n\\t\\t\\t\\tthis.matrixWorld.decompose( position, quaternion, scale );\\n\\n\\t\\t\\t\\torientation.set( 0, 0, - 1 ).applyQuaternion( quaternion );\\n\\n\\t\\t\\t\\tif ( listener.positionX ) {\\n\\n\\t\\t\\t\\t\\tlistener.positionX.setValueAtTime( position.x, this.context.currentTime );\\n\\t\\t\\t\\t\\tlistener.positionY.setValueAtTime( position.y, this.context.currentTime );\\n\\t\\t\\t\\t\\tlistener.positionZ.setValueAtTime( position.z, this.context.currentTime );\\n\\t\\t\\t\\t\\tlistener.forwardX.setValueAtTime( orientation.x, this.context.currentTime );\\n\\t\\t\\t\\t\\tlistener.forwardY.setValueAtTime( orientation.y, this.context.currentTime );\\n\\t\\t\\t\\t\\tlistener.forwardZ.setValueAtTime( orientation.z, this.context.currentTime );\\n\\t\\t\\t\\t\\tlistener.upX.setValueAtTime( up.x, this.context.currentTime );\\n\\t\\t\\t\\t\\tlistener.upY.setValueAtTime( up.y, this.context.currentTime );\\n\\t\\t\\t\\t\\tlistener.upZ.setValueAtTime( up.z, this.context.currentTime );\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tlistener.setPosition( position.x, position.y, position.z );\\n\\t\\t\\t\\t\\tlistener.setOrientation( orientation.x, orientation.y, orientation.z, up.x, up.y, up.z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )()\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Reece Aaron Lecrivain / http://reecenotes.com/\\n\\t */\\n\\n\\tfunction Audio( listener ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.type = 'Audio';\\n\\n\\t\\tthis.context = listener.context;\\n\\n\\t\\tthis.gain = this.context.createGain();\\n\\t\\tthis.gain.connect( listener.getInput() );\\n\\n\\t\\tthis.autoplay = false;\\n\\n\\t\\tthis.buffer = null;\\n\\t\\tthis.loop = false;\\n\\t\\tthis.startTime = 0;\\n\\t\\tthis.offset = 0;\\n\\t\\tthis.playbackRate = 1;\\n\\t\\tthis.isPlaying = false;\\n\\t\\tthis.hasPlaybackControl = true;\\n\\t\\tthis.sourceType = 'empty';\\n\\n\\t\\tthis.filters = [];\\n\\n\\t}\\n\\n\\tAudio.prototype = Object.assign( Object.create( Object3D.prototype ), {\\n\\n\\t\\tconstructor: Audio,\\n\\n\\t\\tgetOutput: function () {\\n\\n\\t\\t\\treturn this.gain;\\n\\n\\t\\t},\\n\\n\\t\\tsetNodeSource: function ( audioNode ) {\\n\\n\\t\\t\\tthis.hasPlaybackControl = false;\\n\\t\\t\\tthis.sourceType = 'audioNode';\\n\\t\\t\\tthis.source = audioNode;\\n\\t\\t\\tthis.connect();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetBuffer: function ( audioBuffer ) {\\n\\n\\t\\t\\tthis.buffer = audioBuffer;\\n\\t\\t\\tthis.sourceType = 'buffer';\\n\\n\\t\\t\\tif ( this.autoplay ) this.play();\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tplay: function () {\\n\\n\\t\\t\\tif ( this.isPlaying === true ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Audio: Audio is already playing.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.hasPlaybackControl === false ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar source = this.context.createBufferSource();\\n\\n\\t\\t\\tsource.buffer = this.buffer;\\n\\t\\t\\tsource.loop = this.loop;\\n\\t\\t\\tsource.onended = this.onEnded.bind( this );\\n\\t\\t\\tsource.playbackRate.setValueAtTime( this.playbackRate, this.startTime );\\n\\t\\t\\tthis.startTime = this.context.currentTime;\\n\\t\\t\\tsource.start( this.startTime, this.offset );\\n\\n\\t\\t\\tthis.isPlaying = true;\\n\\n\\t\\t\\tthis.source = source;\\n\\n\\t\\t\\treturn this.connect();\\n\\n\\t\\t},\\n\\n\\t\\tpause: function () {\\n\\n\\t\\t\\tif ( this.hasPlaybackControl === false ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.isPlaying === true ) {\\n\\n\\t\\t\\t\\tthis.source.stop();\\n\\t\\t\\t\\tthis.offset += ( this.context.currentTime - this.startTime ) * this.playbackRate;\\n\\t\\t\\t\\tthis.isPlaying = false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tstop: function () {\\n\\n\\t\\t\\tif ( this.hasPlaybackControl === false ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.source.stop();\\n\\t\\t\\tthis.offset = 0;\\n\\t\\t\\tthis.isPlaying = false;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tconnect: function () {\\n\\n\\t\\t\\tif ( this.filters.length > 0 ) {\\n\\n\\t\\t\\t\\tthis.source.connect( this.filters[ 0 ] );\\n\\n\\t\\t\\t\\tfor ( var i = 1, l = this.filters.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tthis.filters[ i - 1 ].connect( this.filters[ i ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.filters[ this.filters.length - 1 ].connect( this.getOutput() );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.source.connect( this.getOutput() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tdisconnect: function () {\\n\\n\\t\\t\\tif ( this.filters.length > 0 ) {\\n\\n\\t\\t\\t\\tthis.source.disconnect( this.filters[ 0 ] );\\n\\n\\t\\t\\t\\tfor ( var i = 1, l = this.filters.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tthis.filters[ i - 1 ].disconnect( this.filters[ i ] );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis.filters[ this.filters.length - 1 ].disconnect( this.getOutput() );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.source.disconnect( this.getOutput() );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetFilters: function () {\\n\\n\\t\\t\\treturn this.filters;\\n\\n\\t\\t},\\n\\n\\t\\tsetFilters: function ( value ) {\\n\\n\\t\\t\\tif ( ! value ) value = [];\\n\\n\\t\\t\\tif ( this.isPlaying === true ) {\\n\\n\\t\\t\\t\\tthis.disconnect();\\n\\t\\t\\t\\tthis.filters = value;\\n\\t\\t\\t\\tthis.connect();\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.filters = value;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetFilter: function () {\\n\\n\\t\\t\\treturn this.getFilters()[ 0 ];\\n\\n\\t\\t},\\n\\n\\t\\tsetFilter: function ( filter ) {\\n\\n\\t\\t\\treturn this.setFilters( filter ? [ filter ] : [] );\\n\\n\\t\\t},\\n\\n\\t\\tsetPlaybackRate: function ( value ) {\\n\\n\\t\\t\\tif ( this.hasPlaybackControl === false ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.playbackRate = value;\\n\\n\\t\\t\\tif ( this.isPlaying === true ) {\\n\\n\\t\\t\\t\\tthis.source.playbackRate.setValueAtTime( this.playbackRate, this.context.currentTime );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetPlaybackRate: function () {\\n\\n\\t\\t\\treturn this.playbackRate;\\n\\n\\t\\t},\\n\\n\\t\\tonEnded: function () {\\n\\n\\t\\t\\tthis.isPlaying = false;\\n\\n\\t\\t},\\n\\n\\t\\tgetLoop: function () {\\n\\n\\t\\t\\tif ( this.hasPlaybackControl === false ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\\n\\t\\t\\t\\treturn false;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this.loop;\\n\\n\\t\\t},\\n\\n\\t\\tsetLoop: function ( value ) {\\n\\n\\t\\t\\tif ( this.hasPlaybackControl === false ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Audio: this Audio has no playback control.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.loop = value;\\n\\n\\t\\t\\tif ( this.isPlaying === true ) {\\n\\n\\t\\t\\t\\tthis.source.loop = this.loop;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetVolume: function () {\\n\\n\\t\\t\\treturn this.gain.gain.value;\\n\\n\\t\\t},\\n\\n\\t\\tsetVolume: function ( value ) {\\n\\n\\t\\t\\tthis.gain.gain.value = value;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction PositionalAudio( listener ) {\\n\\n\\t\\tAudio.call( this, listener );\\n\\n\\t\\tthis.panner = this.context.createPanner();\\n\\t\\tthis.panner.connect( this.gain );\\n\\n\\t}\\n\\n\\tPositionalAudio.prototype = Object.assign( Object.create( Audio.prototype ), {\\n\\n\\t\\tconstructor: PositionalAudio,\\n\\n\\t\\tgetOutput: function () {\\n\\n\\t\\t\\treturn this.panner;\\n\\n\\t\\t},\\n\\n\\t\\tgetRefDistance: function () {\\n\\n\\t\\t\\treturn this.panner.refDistance;\\n\\n\\t\\t},\\n\\n\\t\\tsetRefDistance: function ( value ) {\\n\\n\\t\\t\\tthis.panner.refDistance = value;\\n\\n\\t\\t},\\n\\n\\t\\tgetRolloffFactor: function () {\\n\\n\\t\\t\\treturn this.panner.rolloffFactor;\\n\\n\\t\\t},\\n\\n\\t\\tsetRolloffFactor: function ( value ) {\\n\\n\\t\\t\\tthis.panner.rolloffFactor = value;\\n\\n\\t\\t},\\n\\n\\t\\tgetDistanceModel: function () {\\n\\n\\t\\t\\treturn this.panner.distanceModel;\\n\\n\\t\\t},\\n\\n\\t\\tsetDistanceModel: function ( value ) {\\n\\n\\t\\t\\tthis.panner.distanceModel = value;\\n\\n\\t\\t},\\n\\n\\t\\tgetMaxDistance: function () {\\n\\n\\t\\t\\treturn this.panner.maxDistance;\\n\\n\\t\\t},\\n\\n\\t\\tsetMaxDistance: function ( value ) {\\n\\n\\t\\t\\tthis.panner.maxDistance = value;\\n\\n\\t\\t},\\n\\n\\t\\tupdateMatrixWorld: ( function () {\\n\\n\\t\\t\\tvar position = new Vector3();\\n\\n\\t\\t\\treturn function updateMatrixWorld( force ) {\\n\\n\\t\\t\\t\\tObject3D.prototype.updateMatrixWorld.call( this, force );\\n\\n\\t\\t\\t\\tposition.setFromMatrixPosition( this.matrixWorld );\\n\\n\\t\\t\\t\\tthis.panner.setPosition( position.x, position.y, position.z );\\n\\n\\t\\t\\t};\\n\\n\\t\\t} )()\\n\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction AudioAnalyser( audio, fftSize ) {\\n\\n\\t\\tthis.analyser = audio.context.createAnalyser();\\n\\t\\tthis.analyser.fftSize = fftSize !== undefined ? fftSize : 2048;\\n\\n\\t\\tthis.data = new Uint8Array( this.analyser.frequencyBinCount );\\n\\n\\t\\taudio.getOutput().connect( this.analyser );\\n\\n\\t}\\n\\n\\tObject.assign( AudioAnalyser.prototype, {\\n\\n\\t\\tgetFrequencyData: function () {\\n\\n\\t\\t\\tthis.analyser.getByteFrequencyData( this.data );\\n\\n\\t\\t\\treturn this.data;\\n\\n\\t\\t},\\n\\n\\t\\tgetAverageFrequency: function () {\\n\\n\\t\\t\\tvar value = 0, data = this.getFrequencyData();\\n\\n\\t\\t\\tfor ( var i = 0; i < data.length; i ++ ) {\\n\\n\\t\\t\\t\\tvalue += data[ i ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn value / data.length;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * Buffered scene graph property that allows weighted accumulation.\\n\\t *\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction PropertyMixer( binding, typeName, valueSize ) {\\n\\n\\t\\tthis.binding = binding;\\n\\t\\tthis.valueSize = valueSize;\\n\\n\\t\\tvar bufferType = Float64Array,\\n\\t\\t\\tmixFunction;\\n\\n\\t\\tswitch ( typeName ) {\\n\\n\\t\\t\\tcase 'quaternion':\\n\\t\\t\\t\\tmixFunction = this._slerp;\\n\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\tcase 'string':\\n\\t\\t\\tcase 'bool':\\n\\t\\t\\t\\tbufferType = Array;\\n\\t\\t\\t\\tmixFunction = this._select;\\n\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\tdefault:\\n\\t\\t\\t\\tmixFunction = this._lerp;\\n\\n\\t\\t}\\n\\n\\t\\tthis.buffer = new bufferType( valueSize * 4 );\\n\\t\\t// layout: [ incoming | accu0 | accu1 | orig ]\\n\\t\\t//\\n\\t\\t// interpolators can use .buffer as their .result\\n\\t\\t// the data then goes to 'incoming'\\n\\t\\t//\\n\\t\\t// 'accu0' and 'accu1' are used frame-interleaved for\\n\\t\\t// the cumulative result and are compared to detect\\n\\t\\t// changes\\n\\t\\t//\\n\\t\\t// 'orig' stores the original state of the property\\n\\n\\t\\tthis._mixBufferRegion = mixFunction;\\n\\n\\t\\tthis.cumulativeWeight = 0;\\n\\n\\t\\tthis.useCount = 0;\\n\\t\\tthis.referenceCount = 0;\\n\\n\\t}\\n\\n\\tObject.assign( PropertyMixer.prototype, {\\n\\n\\t\\t// accumulate data in the 'incoming' region into 'accu<i>'\\n\\t\\taccumulate: function ( accuIndex, weight ) {\\n\\n\\t\\t\\t// note: happily accumulating nothing when weight = 0, the caller knows\\n\\t\\t\\t// the weight and shouldn't have made the call in the first place\\n\\n\\t\\t\\tvar buffer = this.buffer,\\n\\t\\t\\t\\tstride = this.valueSize,\\n\\t\\t\\t\\toffset = accuIndex * stride + stride,\\n\\n\\t\\t\\t\\tcurrentWeight = this.cumulativeWeight;\\n\\n\\t\\t\\tif ( currentWeight === 0 ) {\\n\\n\\t\\t\\t\\t// accuN := incoming * weight\\n\\n\\t\\t\\t\\tfor ( var i = 0; i !== stride; ++ i ) {\\n\\n\\t\\t\\t\\t\\tbuffer[ offset + i ] = buffer[ i ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tcurrentWeight = weight;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// accuN := accuN + incoming * weight\\n\\n\\t\\t\\t\\tcurrentWeight += weight;\\n\\t\\t\\t\\tvar mix = weight / currentWeight;\\n\\t\\t\\t\\tthis._mixBufferRegion( buffer, offset, 0, mix, stride );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.cumulativeWeight = currentWeight;\\n\\n\\t\\t},\\n\\n\\t\\t// apply the state of 'accu<i>' to the binding when accus differ\\n\\t\\tapply: function ( accuIndex ) {\\n\\n\\t\\t\\tvar stride = this.valueSize,\\n\\t\\t\\t\\tbuffer = this.buffer,\\n\\t\\t\\t\\toffset = accuIndex * stride + stride,\\n\\n\\t\\t\\t\\tweight = this.cumulativeWeight,\\n\\n\\t\\t\\t\\tbinding = this.binding;\\n\\n\\t\\t\\tthis.cumulativeWeight = 0;\\n\\n\\t\\t\\tif ( weight < 1 ) {\\n\\n\\t\\t\\t\\t// accuN := accuN + original * ( 1 - cumulativeWeight )\\n\\n\\t\\t\\t\\tvar originalValueOffset = stride * 3;\\n\\n\\t\\t\\t\\tthis._mixBufferRegion(\\n\\t\\t\\t\\t\\tbuffer, offset, originalValueOffset, 1 - weight, stride );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = stride, e = stride + stride; i !== e; ++ i ) {\\n\\n\\t\\t\\t\\tif ( buffer[ i ] !== buffer[ i + stride ] ) {\\n\\n\\t\\t\\t\\t\\t// value has changed -> update scene graph\\n\\n\\t\\t\\t\\t\\tbinding.setValue( buffer, offset );\\n\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t// remember the state of the bound property and copy it to both accus\\n\\t\\tsaveOriginalState: function () {\\n\\n\\t\\t\\tvar binding = this.binding;\\n\\n\\t\\t\\tvar buffer = this.buffer,\\n\\t\\t\\t\\tstride = this.valueSize,\\n\\n\\t\\t\\t\\toriginalValueOffset = stride * 3;\\n\\n\\t\\t\\tbinding.getValue( buffer, originalValueOffset );\\n\\n\\t\\t\\t// accu[0..1] := orig -- initially detect changes against the original\\n\\t\\t\\tfor ( var i = stride, e = originalValueOffset; i !== e; ++ i ) {\\n\\n\\t\\t\\t\\tbuffer[ i ] = buffer[ originalValueOffset + ( i % stride ) ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.cumulativeWeight = 0;\\n\\n\\t\\t},\\n\\n\\t\\t// apply the state previously taken via 'saveOriginalState' to the binding\\n\\t\\trestoreOriginalState: function () {\\n\\n\\t\\t\\tvar originalValueOffset = this.valueSize * 3;\\n\\t\\t\\tthis.binding.setValue( this.buffer, originalValueOffset );\\n\\n\\t\\t},\\n\\n\\n\\t\\t// mix functions\\n\\n\\t\\t_select: function ( buffer, dstOffset, srcOffset, t, stride ) {\\n\\n\\t\\t\\tif ( t >= 0.5 ) {\\n\\n\\t\\t\\t\\tfor ( var i = 0; i !== stride; ++ i ) {\\n\\n\\t\\t\\t\\t\\tbuffer[ dstOffset + i ] = buffer[ srcOffset + i ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t_slerp: function ( buffer, dstOffset, srcOffset, t ) {\\n\\n\\t\\t\\tQuaternion.slerpFlat( buffer, dstOffset, buffer, dstOffset, buffer, srcOffset, t );\\n\\n\\t\\t},\\n\\n\\t\\t_lerp: function ( buffer, dstOffset, srcOffset, t, stride ) {\\n\\n\\t\\t\\tvar s = 1 - t;\\n\\n\\t\\t\\tfor ( var i = 0; i !== stride; ++ i ) {\\n\\n\\t\\t\\t\\tvar j = dstOffset + i;\\n\\n\\t\\t\\t\\tbuffer[ j ] = buffer[ j ] * s + buffer[ srcOffset + i ] * t;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * A reference to a real property in the scene graph.\\n\\t *\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction Composite( targetGroup, path, optionalParsedPath ) {\\n\\n\\t\\tvar parsedPath = optionalParsedPath || PropertyBinding.parseTrackName( path );\\n\\n\\t\\tthis._targetGroup = targetGroup;\\n\\t\\tthis._bindings = targetGroup.subscribe_( path, parsedPath );\\n\\n\\t}\\n\\n\\tObject.assign( Composite.prototype, {\\n\\n\\t\\tgetValue: function ( array, offset ) {\\n\\n\\t\\t\\tthis.bind(); // bind all binding\\n\\n\\t\\t\\tvar firstValidIndex = this._targetGroup.nCachedObjects_,\\n\\t\\t\\t\\tbinding = this._bindings[ firstValidIndex ];\\n\\n\\t\\t\\t// and only call .getValue on the first\\n\\t\\t\\tif ( binding !== undefined ) binding.getValue( array, offset );\\n\\n\\t\\t},\\n\\n\\t\\tsetValue: function ( array, offset ) {\\n\\n\\t\\t\\tvar bindings = this._bindings;\\n\\n\\t\\t\\tfor ( var i = this._targetGroup.nCachedObjects_,\\n\\t\\t\\t\\t\\t  n = bindings.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tbindings[ i ].setValue( array, offset );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tbind: function () {\\n\\n\\t\\t\\tvar bindings = this._bindings;\\n\\n\\t\\t\\tfor ( var i = this._targetGroup.nCachedObjects_,\\n\\t\\t\\t\\t\\t  n = bindings.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tbindings[ i ].bind();\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tunbind: function () {\\n\\n\\t\\t\\tvar bindings = this._bindings;\\n\\n\\t\\t\\tfor ( var i = this._targetGroup.nCachedObjects_,\\n\\t\\t\\t\\t\\t  n = bindings.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tbindings[ i ].unbind();\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\n\\tfunction PropertyBinding( rootNode, path, parsedPath ) {\\n\\n\\t\\tthis.path = path;\\n\\t\\tthis.parsedPath = parsedPath || PropertyBinding.parseTrackName( path );\\n\\n\\t\\tthis.node = PropertyBinding.findNode( rootNode, this.parsedPath.nodeName ) || rootNode;\\n\\n\\t\\tthis.rootNode = rootNode;\\n\\n\\t}\\n\\n\\tObject.assign( PropertyBinding, {\\n\\n\\t\\tComposite: Composite,\\n\\n\\t\\tcreate: function ( root, path, parsedPath ) {\\n\\n\\t\\t\\tif ( ! ( root && root.isAnimationObjectGroup ) ) {\\n\\n\\t\\t\\t\\treturn new PropertyBinding( root, path, parsedPath );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\treturn new PropertyBinding.Composite( root, path, parsedPath );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t/**\\n\\t\\t * Replaces spaces with underscores and removes unsupported characters from\\n\\t\\t * node names, to ensure compatibility with parseTrackName().\\n\\t\\t *\\n\\t\\t * @param  {string} name Node name to be sanitized.\\n\\t\\t * @return {string}\\n\\t\\t */\\n\\t\\tsanitizeNodeName: function ( name ) {\\n\\n\\t\\t\\treturn name.replace( /\\\\s/g, '_' ).replace( /[^\\\\w-]/g, '' );\\n\\n\\t\\t},\\n\\n\\t\\tparseTrackName: function () {\\n\\n\\t\\t\\t// Parent directories, delimited by '/' or ':'. Currently unused, but must\\n\\t\\t\\t// be matched to parse the rest of the track name.\\n\\t\\t\\tvar directoryRe = /((?:[\\\\w-]+[\\\\/:])*)/;\\n\\n\\t\\t\\t// Target node. May contain word characters (a-zA-Z0-9_) and '.' or '-'.\\n\\t\\t\\tvar nodeRe = /([\\\\w-\\\\.]+)?/;\\n\\n\\t\\t\\t// Object on target node, and accessor. Name may contain only word\\n\\t\\t\\t// characters. Accessor may contain any character except closing bracket.\\n\\t\\t\\tvar objectRe = /(?:\\\\.([\\\\w-]+)(?:\\\\[(.+)\\\\])?)?/;\\n\\n\\t\\t\\t// Property and accessor. May contain only word characters. Accessor may\\n\\t\\t\\t// contain any non-bracket characters.\\n\\t\\t\\tvar propertyRe = /\\\\.([\\\\w-]+)(?:\\\\[(.+)\\\\])?/;\\n\\n\\t\\t\\tvar trackRe = new RegExp( ''\\n\\t\\t\\t\\t+ '^'\\n\\t\\t\\t\\t+ directoryRe.source\\n\\t\\t\\t\\t+ nodeRe.source\\n\\t\\t\\t\\t+ objectRe.source\\n\\t\\t\\t\\t+ propertyRe.source\\n\\t\\t\\t\\t+ '$'\\n\\t\\t\\t);\\n\\n\\t\\t\\tvar supportedObjectNames = [ 'material', 'materials', 'bones' ];\\n\\n\\t\\t\\treturn function ( trackName ) {\\n\\n\\t\\t\\t\\tvar matches = trackRe.exec( trackName );\\n\\n\\t\\t\\t\\tif ( ! matches ) {\\n\\n\\t\\t\\t\\t\\tthrow new Error( 'PropertyBinding: Cannot parse trackName: ' + trackName );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar results = {\\n\\t\\t\\t\\t\\t// directoryName: matches[ 1 ], // (tschw) currently unused\\n\\t\\t\\t\\t\\tnodeName: matches[ 2 ],\\n\\t\\t\\t\\t\\tobjectName: matches[ 3 ],\\n\\t\\t\\t\\t\\tobjectIndex: matches[ 4 ],\\n\\t\\t\\t\\t\\tpropertyName: matches[ 5 ], // required\\n\\t\\t\\t\\t\\tpropertyIndex: matches[ 6 ]\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\tvar lastDot = results.nodeName && results.nodeName.lastIndexOf( '.' );\\n\\n\\t\\t\\t\\tif ( lastDot !== undefined && lastDot !== - 1 ) {\\n\\n\\t\\t\\t\\t\\tvar objectName = results.nodeName.substring( lastDot + 1 );\\n\\n\\t\\t\\t\\t\\t// Object names must be checked against a whitelist. Otherwise, there\\n\\t\\t\\t\\t\\t// is no way to parse 'foo.bar.baz': 'baz' must be a property, but\\n\\t\\t\\t\\t\\t// 'bar' could be the objectName, or part of a nodeName (which can\\n\\t\\t\\t\\t\\t// include '.' characters).\\n\\t\\t\\t\\t\\tif ( supportedObjectNames.indexOf( objectName ) !== - 1 ) {\\n\\n\\t\\t\\t\\t\\t\\tresults.nodeName = results.nodeName.substring( 0, lastDot );\\n\\t\\t\\t\\t\\t\\tresults.objectName = objectName;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( results.propertyName === null || results.propertyName.length === 0 ) {\\n\\n\\t\\t\\t\\t\\tthrow new Error( 'PropertyBinding: can not parse propertyName from trackName: ' + trackName );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\treturn results;\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\n\\t\\tfindNode: function ( root, nodeName ) {\\n\\n\\t\\t\\tif ( ! nodeName || nodeName === \\\"\\\" || nodeName === \\\"root\\\" || nodeName === \\\".\\\" || nodeName === - 1 || nodeName === root.name || nodeName === root.uuid ) {\\n\\n\\t\\t\\t\\treturn root;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// search into skeleton bones.\\n\\t\\t\\tif ( root.skeleton ) {\\n\\n\\t\\t\\t\\tvar searchSkeleton = function ( skeleton ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < skeleton.bones.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar bone = skeleton.bones[ i ];\\n\\n\\t\\t\\t\\t\\t\\tif ( bone.name === nodeName ) {\\n\\n\\t\\t\\t\\t\\t\\t\\treturn bone;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\tvar bone = searchSkeleton( root.skeleton );\\n\\n\\t\\t\\t\\tif ( bone ) {\\n\\n\\t\\t\\t\\t\\treturn bone;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// search into node subtree.\\n\\t\\t\\tif ( root.children ) {\\n\\n\\t\\t\\t\\tvar searchNodeSubtree = function ( children ) {\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0; i < children.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar childNode = children[ i ];\\n\\n\\t\\t\\t\\t\\t\\tif ( childNode.name === nodeName || childNode.uuid === nodeName ) {\\n\\n\\t\\t\\t\\t\\t\\t\\treturn childNode;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tvar result = searchNodeSubtree( childNode.children );\\n\\n\\t\\t\\t\\t\\t\\tif ( result ) return result;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\treturn null;\\n\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\tvar subTreeNode = searchNodeSubtree( root.children );\\n\\n\\t\\t\\t\\tif ( subTreeNode ) {\\n\\n\\t\\t\\t\\t\\treturn subTreeNode;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn null;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( PropertyBinding.prototype, { // prototype, continued\\n\\n\\t\\t// these are used to \\\"bind\\\" a nonexistent property\\n\\t\\t_getValue_unavailable: function () {},\\n\\t\\t_setValue_unavailable: function () {},\\n\\n\\t\\tBindingType: {\\n\\t\\t\\tDirect: 0,\\n\\t\\t\\tEntireArray: 1,\\n\\t\\t\\tArrayElement: 2,\\n\\t\\t\\tHasFromToArray: 3\\n\\t\\t},\\n\\n\\t\\tVersioning: {\\n\\t\\t\\tNone: 0,\\n\\t\\t\\tNeedsUpdate: 1,\\n\\t\\t\\tMatrixWorldNeedsUpdate: 2\\n\\t\\t},\\n\\n\\t\\tGetterByBindingType: [\\n\\n\\t\\t\\tfunction getValue_direct( buffer, offset ) {\\n\\n\\t\\t\\t\\tbuffer[ offset ] = this.node[ this.propertyName ];\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tfunction getValue_array( buffer, offset ) {\\n\\n\\t\\t\\t\\tvar source = this.resolvedProperty;\\n\\n\\t\\t\\t\\tfor ( var i = 0, n = source.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\tbuffer[ offset ++ ] = source[ i ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tfunction getValue_arrayElement( buffer, offset ) {\\n\\n\\t\\t\\t\\tbuffer[ offset ] = this.resolvedProperty[ this.propertyIndex ];\\n\\n\\t\\t\\t},\\n\\n\\t\\t\\tfunction getValue_toArray( buffer, offset ) {\\n\\n\\t\\t\\t\\tthis.resolvedProperty.toArray( buffer, offset );\\n\\n\\t\\t\\t}\\n\\n\\t\\t],\\n\\n\\t\\tSetterByBindingTypeAndVersioning: [\\n\\n\\t\\t\\t[\\n\\t\\t\\t\\t// Direct\\n\\n\\t\\t\\t\\tfunction setValue_direct( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.targetObject[ this.propertyName ] = buffer[ offset ];\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfunction setValue_direct_setNeedsUpdate( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.targetObject[ this.propertyName ] = buffer[ offset ];\\n\\t\\t\\t\\t\\tthis.targetObject.needsUpdate = true;\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfunction setValue_direct_setMatrixWorldNeedsUpdate( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.targetObject[ this.propertyName ] = buffer[ offset ];\\n\\t\\t\\t\\t\\tthis.targetObject.matrixWorldNeedsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t], [\\n\\n\\t\\t\\t\\t// EntireArray\\n\\n\\t\\t\\t\\tfunction setValue_array( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tvar dest = this.resolvedProperty;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, n = dest.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\t\\tdest[ i ] = buffer[ offset ++ ];\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfunction setValue_array_setNeedsUpdate( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tvar dest = this.resolvedProperty;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, n = dest.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\t\\tdest[ i ] = buffer[ offset ++ ];\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tthis.targetObject.needsUpdate = true;\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfunction setValue_array_setMatrixWorldNeedsUpdate( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tvar dest = this.resolvedProperty;\\n\\n\\t\\t\\t\\t\\tfor ( var i = 0, n = dest.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\t\\tdest[ i ] = buffer[ offset ++ ];\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tthis.targetObject.matrixWorldNeedsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t], [\\n\\n\\t\\t\\t\\t// ArrayElement\\n\\n\\t\\t\\t\\tfunction setValue_arrayElement( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfunction setValue_arrayElement_setNeedsUpdate( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];\\n\\t\\t\\t\\t\\tthis.targetObject.needsUpdate = true;\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfunction setValue_arrayElement_setMatrixWorldNeedsUpdate( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];\\n\\t\\t\\t\\t\\tthis.targetObject.matrixWorldNeedsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t], [\\n\\n\\t\\t\\t\\t// HasToFromArray\\n\\n\\t\\t\\t\\tfunction setValue_fromArray( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.resolvedProperty.fromArray( buffer, offset );\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfunction setValue_fromArray_setNeedsUpdate( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.resolvedProperty.fromArray( buffer, offset );\\n\\t\\t\\t\\t\\tthis.targetObject.needsUpdate = true;\\n\\n\\t\\t\\t\\t},\\n\\n\\t\\t\\t\\tfunction setValue_fromArray_setMatrixWorldNeedsUpdate( buffer, offset ) {\\n\\n\\t\\t\\t\\t\\tthis.resolvedProperty.fromArray( buffer, offset );\\n\\t\\t\\t\\t\\tthis.targetObject.matrixWorldNeedsUpdate = true;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t]\\n\\n\\t\\t],\\n\\n\\t\\tgetValue: function getValue_unbound( targetArray, offset ) {\\n\\n\\t\\t\\tthis.bind();\\n\\t\\t\\tthis.getValue( targetArray, offset );\\n\\n\\t\\t\\t// Note: This class uses a State pattern on a per-method basis:\\n\\t\\t\\t// 'bind' sets 'this.getValue' / 'setValue' and shadows the\\n\\t\\t\\t// prototype version of these methods with one that represents\\n\\t\\t\\t// the bound state. When the property is not found, the methods\\n\\t\\t\\t// become no-ops.\\n\\n\\t\\t},\\n\\n\\t\\tsetValue: function getValue_unbound( sourceArray, offset ) {\\n\\n\\t\\t\\tthis.bind();\\n\\t\\t\\tthis.setValue( sourceArray, offset );\\n\\n\\t\\t},\\n\\n\\t\\t// create getter / setter pair for a property in the scene graph\\n\\t\\tbind: function () {\\n\\n\\t\\t\\tvar targetObject = this.node,\\n\\t\\t\\t\\tparsedPath = this.parsedPath,\\n\\n\\t\\t\\t\\tobjectName = parsedPath.objectName,\\n\\t\\t\\t\\tpropertyName = parsedPath.propertyName,\\n\\t\\t\\t\\tpropertyIndex = parsedPath.propertyIndex;\\n\\n\\t\\t\\tif ( ! targetObject ) {\\n\\n\\t\\t\\t\\ttargetObject = PropertyBinding.findNode( this.rootNode, parsedPath.nodeName ) || this.rootNode;\\n\\n\\t\\t\\t\\tthis.node = targetObject;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// set fail state so we can just 'return' on error\\n\\t\\t\\tthis.getValue = this._getValue_unavailable;\\n\\t\\t\\tthis.setValue = this._setValue_unavailable;\\n\\n\\t\\t\\t// ensure there is a value node\\n\\t\\t\\tif ( ! targetObject ) {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Trying to update node for track: ' + this.path + ' but it wasn\\\\'t found.' );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( objectName ) {\\n\\n\\t\\t\\t\\tvar objectIndex = parsedPath.objectIndex;\\n\\n\\t\\t\\t\\t// special cases were we need to reach deeper into the hierarchy to get the face materials....\\n\\t\\t\\t\\tswitch ( objectName ) {\\n\\n\\t\\t\\t\\t\\tcase 'materials':\\n\\n\\t\\t\\t\\t\\t\\tif ( ! targetObject.material ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Can not bind to material as node does not have a material.', this );\\n\\t\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tif ( ! targetObject.material.materials ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Can not bind to material.materials as node.material does not have a materials array.', this );\\n\\t\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\ttargetObject = targetObject.material.materials;\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tcase 'bones':\\n\\n\\t\\t\\t\\t\\t\\tif ( ! targetObject.skeleton ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Can not bind to bones as node does not have a skeleton.', this );\\n\\t\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t// potential future optimization: skip this if propertyIndex is already an integer\\n\\t\\t\\t\\t\\t\\t// and convert the integer string to a true integer.\\n\\n\\t\\t\\t\\t\\t\\ttargetObject = targetObject.skeleton.bones;\\n\\n\\t\\t\\t\\t\\t\\t// support resolving morphTarget names into indices.\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0; i < targetObject.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( targetObject[ i ].name === objectIndex ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tobjectIndex = i;\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\tdefault:\\n\\n\\t\\t\\t\\t\\t\\tif ( targetObject[ objectName ] === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Can not bind to objectName of node undefined.', this );\\n\\t\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\ttargetObject = targetObject[ objectName ];\\n\\n\\t\\t\\t\\t}\\n\\n\\n\\t\\t\\t\\tif ( objectIndex !== undefined ) {\\n\\n\\t\\t\\t\\t\\tif ( targetObject[ objectIndex ] === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Trying to bind to objectIndex of objectName, but is undefined.', this, targetObject );\\n\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\ttargetObject = targetObject[ objectIndex ];\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// resolve property\\n\\t\\t\\tvar nodeProperty = targetObject[ propertyName ];\\n\\n\\t\\t\\tif ( nodeProperty === undefined ) {\\n\\n\\t\\t\\t\\tvar nodeName = parsedPath.nodeName;\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Trying to update property for track: ' + nodeName +\\n\\t\\t\\t\\t\\t'.' + propertyName + ' but it wasn\\\\'t found.', targetObject );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// determine versioning scheme\\n\\t\\t\\tvar versioning = this.Versioning.None;\\n\\n\\t\\t\\tif ( targetObject.needsUpdate !== undefined ) { // material\\n\\n\\t\\t\\t\\tversioning = this.Versioning.NeedsUpdate;\\n\\t\\t\\t\\tthis.targetObject = targetObject;\\n\\n\\t\\t\\t} else if ( targetObject.matrixWorldNeedsUpdate !== undefined ) { // node transform\\n\\n\\t\\t\\t\\tversioning = this.Versioning.MatrixWorldNeedsUpdate;\\n\\t\\t\\t\\tthis.targetObject = targetObject;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// determine how the property gets bound\\n\\t\\t\\tvar bindingType = this.BindingType.Direct;\\n\\n\\t\\t\\tif ( propertyIndex !== undefined ) {\\n\\n\\t\\t\\t\\t// access a sub element of the property array (only primitives are supported right now)\\n\\n\\t\\t\\t\\tif ( propertyName === \\\"morphTargetInfluences\\\" ) {\\n\\n\\t\\t\\t\\t\\t// potential optimization, skip this if propertyIndex is already an integer, and convert the integer string to a true integer.\\n\\n\\t\\t\\t\\t\\t// support resolving morphTarget names into indices.\\n\\t\\t\\t\\t\\tif ( ! targetObject.geometry ) {\\n\\n\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.', this );\\n\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tif ( targetObject.geometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\t\\t\\tif ( ! targetObject.geometry.morphAttributes ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphAttributes.', this );\\n\\t\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0; i < this.node.geometry.morphAttributes.position.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( targetObject.geometry.morphAttributes.position[ i ].name === propertyIndex ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tpropertyIndex = i;\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\tif ( ! targetObject.geometry.morphTargets ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tconsole.error( 'THREE.PropertyBinding: Can not bind to morphTargetInfluences because node does not have a geometry.morphTargets.', this );\\n\\t\\t\\t\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tfor ( var i = 0; i < this.node.geometry.morphTargets.length; i ++ ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tif ( targetObject.geometry.morphTargets[ i ].name === propertyIndex ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t\\tpropertyIndex = i;\\n\\t\\t\\t\\t\\t\\t\\t\\tbreak;\\n\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tbindingType = this.BindingType.ArrayElement;\\n\\n\\t\\t\\t\\tthis.resolvedProperty = nodeProperty;\\n\\t\\t\\t\\tthis.propertyIndex = propertyIndex;\\n\\n\\t\\t\\t} else if ( nodeProperty.fromArray !== undefined && nodeProperty.toArray !== undefined ) {\\n\\n\\t\\t\\t\\t// must use copy for Object3D.Euler/Quaternion\\n\\n\\t\\t\\t\\tbindingType = this.BindingType.HasFromToArray;\\n\\n\\t\\t\\t\\tthis.resolvedProperty = nodeProperty;\\n\\n\\t\\t\\t} else if ( Array.isArray( nodeProperty ) ) {\\n\\n\\t\\t\\t\\tbindingType = this.BindingType.EntireArray;\\n\\n\\t\\t\\t\\tthis.resolvedProperty = nodeProperty;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.propertyName = propertyName;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// select getter / setter\\n\\t\\t\\tthis.getValue = this.GetterByBindingType[ bindingType ];\\n\\t\\t\\tthis.setValue = this.SetterByBindingTypeAndVersioning[ bindingType ][ versioning ];\\n\\n\\t\\t},\\n\\n\\t\\tunbind: function () {\\n\\n\\t\\t\\tthis.node = null;\\n\\n\\t\\t\\t// back to the prototype version of getValue / setValue\\n\\t\\t\\t// note: avoiding to mutate the shape of 'this' via 'delete'\\n\\t\\t\\tthis.getValue = this._getValue_unbound;\\n\\t\\t\\tthis.setValue = this._setValue_unbound;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//!\\\\ DECLARE ALIAS AFTER assign prototype !\\n\\tObject.assign( PropertyBinding.prototype, {\\n\\n\\t\\t// initial state of these methods that calls 'bind'\\n\\t\\t_getValue_unbound: PropertyBinding.prototype.getValue,\\n\\t\\t_setValue_unbound: PropertyBinding.prototype.setValue,\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * A group of objects that receives a shared animation state.\\n\\t *\\n\\t * Usage:\\n\\t *\\n\\t * \\t-\\tAdd objects you would otherwise pass as 'root' to the\\n\\t * \\t\\tconstructor or the .clipAction method of AnimationMixer.\\n\\t *\\n\\t * \\t-\\tInstead pass this object as 'root'.\\n\\t *\\n\\t * \\t-\\tYou can also add and remove objects later when the mixer\\n\\t * \\t\\tis running.\\n\\t *\\n\\t * Note:\\n\\t *\\n\\t *  \\tObjects of this class appear as one object to the mixer,\\n\\t *  \\tso cache control of the individual objects must be done\\n\\t *  \\ton the group.\\n\\t *\\n\\t * Limitation:\\n\\t *\\n\\t * \\t- \\tThe animated properties must be compatible among the\\n\\t * \\t\\tall objects in the group.\\n\\t *\\n\\t *  -\\tA single property can either be controlled through a\\n\\t *  \\ttarget group or directly, but not both.\\n\\t *\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction AnimationObjectGroup() {\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\t// cached objects followed by the active ones\\n\\t\\tthis._objects = Array.prototype.slice.call( arguments );\\n\\n\\t\\tthis.nCachedObjects_ = 0;\\t\\t\\t// threshold\\n\\t\\t// note: read by PropertyBinding.Composite\\n\\n\\t\\tvar indices = {};\\n\\t\\tthis._indicesByUUID = indices;\\t\\t// for bookkeeping\\n\\n\\t\\tfor ( var i = 0, n = arguments.length; i !== n; ++ i ) {\\n\\n\\t\\t\\tindices[ arguments[ i ].uuid ] = i;\\n\\n\\t\\t}\\n\\n\\t\\tthis._paths = [];\\t\\t\\t\\t\\t// inside: string\\n\\t\\tthis._parsedPaths = [];\\t\\t\\t\\t// inside: { we don't care, here }\\n\\t\\tthis._bindings = []; \\t\\t\\t\\t// inside: Array< PropertyBinding >\\n\\t\\tthis._bindingsIndicesByPath = {}; \\t// inside: indices in these arrays\\n\\n\\t\\tvar scope = this;\\n\\n\\t\\tthis.stats = {\\n\\n\\t\\t\\tobjects: {\\n\\t\\t\\t\\tget total() {\\n\\n\\t\\t\\t\\t\\treturn scope._objects.length;\\n\\n\\t\\t\\t\\t},\\n\\t\\t\\t\\tget inUse() {\\n\\n\\t\\t\\t\\t\\treturn this.total - scope.nCachedObjects_;\\n\\n\\t\\t\\t\\t}\\n\\t\\t\\t},\\n\\t\\t\\tget bindingsPerObject() {\\n\\n\\t\\t\\t\\treturn scope._bindings.length;\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\tObject.assign( AnimationObjectGroup.prototype, {\\n\\n\\t\\tisAnimationObjectGroup: true,\\n\\n\\t\\tadd: function () {\\n\\n\\t\\t\\tvar objects = this._objects,\\n\\t\\t\\t\\tnObjects = objects.length,\\n\\t\\t\\t\\tnCachedObjects = this.nCachedObjects_,\\n\\t\\t\\t\\tindicesByUUID = this._indicesByUUID,\\n\\t\\t\\t\\tpaths = this._paths,\\n\\t\\t\\t\\tparsedPaths = this._parsedPaths,\\n\\t\\t\\t\\tbindings = this._bindings,\\n\\t\\t\\t\\tnBindings = bindings.length;\\n\\n\\t\\t\\tfor ( var i = 0, n = arguments.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tvar object = arguments[ i ],\\n\\t\\t\\t\\t\\tuuid = object.uuid,\\n\\t\\t\\t\\t\\tindex = indicesByUUID[ uuid ],\\n\\t\\t\\t\\t\\tknownObject = undefined;\\n\\n\\t\\t\\t\\tif ( index === undefined ) {\\n\\n\\t\\t\\t\\t\\t// unknown object -> add it to the ACTIVE region\\n\\n\\t\\t\\t\\t\\tindex = nObjects ++;\\n\\t\\t\\t\\t\\tindicesByUUID[ uuid ] = index;\\n\\t\\t\\t\\t\\tobjects.push( object );\\n\\n\\t\\t\\t\\t\\t// accounting is done, now do the same for all bindings\\n\\n\\t\\t\\t\\t\\tfor ( var j = 0, m = nBindings; j !== m; ++ j ) {\\n\\n\\t\\t\\t\\t\\t\\tbindings[ j ].push( new PropertyBinding( object, paths[ j ], parsedPaths[ j ] ) );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( index < nCachedObjects ) {\\n\\n\\t\\t\\t\\t\\tknownObject = objects[ index ];\\n\\n\\t\\t\\t\\t\\t// move existing object to the ACTIVE region\\n\\n\\t\\t\\t\\t\\tvar firstActiveIndex = -- nCachedObjects,\\n\\t\\t\\t\\t\\t\\tlastCachedObject = objects[ firstActiveIndex ];\\n\\n\\t\\t\\t\\t\\tindicesByUUID[ lastCachedObject.uuid ] = index;\\n\\t\\t\\t\\t\\tobjects[ index ] = lastCachedObject;\\n\\n\\t\\t\\t\\t\\tindicesByUUID[ uuid ] = firstActiveIndex;\\n\\t\\t\\t\\t\\tobjects[ firstActiveIndex ] = object;\\n\\n\\t\\t\\t\\t\\t// accounting is done, now do the same for all bindings\\n\\n\\t\\t\\t\\t\\tfor ( var j = 0, m = nBindings; j !== m; ++ j ) {\\n\\n\\t\\t\\t\\t\\t\\tvar bindingsForPath = bindings[ j ],\\n\\t\\t\\t\\t\\t\\t\\tlastCached = bindingsForPath[ firstActiveIndex ],\\n\\t\\t\\t\\t\\t\\t\\tbinding = bindingsForPath[ index ];\\n\\n\\t\\t\\t\\t\\t\\tbindingsForPath[ index ] = lastCached;\\n\\n\\t\\t\\t\\t\\t\\tif ( binding === undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// since we do not bother to create new bindings\\n\\t\\t\\t\\t\\t\\t\\t// for objects that are cached, the binding may\\n\\t\\t\\t\\t\\t\\t\\t// or may not exist\\n\\n\\t\\t\\t\\t\\t\\t\\tbinding = new PropertyBinding( object, paths[ j ], parsedPaths[ j ] );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tbindingsForPath[ firstActiveIndex ] = binding;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t} else if ( objects[ index ] !== knownObject ) {\\n\\n\\t\\t\\t\\t\\tconsole.error( 'THREE.AnimationObjectGroup: Different objects with the same UUID ' +\\n\\t\\t\\t\\t\\t\\t\\t'detected. Clean the caches or recreate your infrastructure when reloading scenes.' );\\n\\n\\t\\t\\t\\t} // else the object is already where we want it to be\\n\\n\\t\\t\\t} // for arguments\\n\\n\\t\\t\\tthis.nCachedObjects_ = nCachedObjects;\\n\\n\\t\\t},\\n\\n\\t\\tremove: function () {\\n\\n\\t\\t\\tvar objects = this._objects,\\n\\t\\t\\t\\tnCachedObjects = this.nCachedObjects_,\\n\\t\\t\\t\\tindicesByUUID = this._indicesByUUID,\\n\\t\\t\\t\\tbindings = this._bindings,\\n\\t\\t\\t\\tnBindings = bindings.length;\\n\\n\\t\\t\\tfor ( var i = 0, n = arguments.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tvar object = arguments[ i ],\\n\\t\\t\\t\\t\\tuuid = object.uuid,\\n\\t\\t\\t\\t\\tindex = indicesByUUID[ uuid ];\\n\\n\\t\\t\\t\\tif ( index !== undefined && index >= nCachedObjects ) {\\n\\n\\t\\t\\t\\t\\t// move existing object into the CACHED region\\n\\n\\t\\t\\t\\t\\tvar lastCachedIndex = nCachedObjects ++,\\n\\t\\t\\t\\t\\t\\tfirstActiveObject = objects[ lastCachedIndex ];\\n\\n\\t\\t\\t\\t\\tindicesByUUID[ firstActiveObject.uuid ] = index;\\n\\t\\t\\t\\t\\tobjects[ index ] = firstActiveObject;\\n\\n\\t\\t\\t\\t\\tindicesByUUID[ uuid ] = lastCachedIndex;\\n\\t\\t\\t\\t\\tobjects[ lastCachedIndex ] = object;\\n\\n\\t\\t\\t\\t\\t// accounting is done, now do the same for all bindings\\n\\n\\t\\t\\t\\t\\tfor ( var j = 0, m = nBindings; j !== m; ++ j ) {\\n\\n\\t\\t\\t\\t\\t\\tvar bindingsForPath = bindings[ j ],\\n\\t\\t\\t\\t\\t\\t\\tfirstActive = bindingsForPath[ lastCachedIndex ],\\n\\t\\t\\t\\t\\t\\t\\tbinding = bindingsForPath[ index ];\\n\\n\\t\\t\\t\\t\\t\\tbindingsForPath[ index ] = firstActive;\\n\\t\\t\\t\\t\\t\\tbindingsForPath[ lastCachedIndex ] = binding;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} // for arguments\\n\\n\\t\\t\\tthis.nCachedObjects_ = nCachedObjects;\\n\\n\\t\\t},\\n\\n\\t\\t// remove & forget\\n\\t\\tuncache: function () {\\n\\n\\t\\t\\tvar objects = this._objects,\\n\\t\\t\\t\\tnObjects = objects.length,\\n\\t\\t\\t\\tnCachedObjects = this.nCachedObjects_,\\n\\t\\t\\t\\tindicesByUUID = this._indicesByUUID,\\n\\t\\t\\t\\tbindings = this._bindings,\\n\\t\\t\\t\\tnBindings = bindings.length;\\n\\n\\t\\t\\tfor ( var i = 0, n = arguments.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tvar object = arguments[ i ],\\n\\t\\t\\t\\t\\tuuid = object.uuid,\\n\\t\\t\\t\\t\\tindex = indicesByUUID[ uuid ];\\n\\n\\t\\t\\t\\tif ( index !== undefined ) {\\n\\n\\t\\t\\t\\t\\tdelete indicesByUUID[ uuid ];\\n\\n\\t\\t\\t\\t\\tif ( index < nCachedObjects ) {\\n\\n\\t\\t\\t\\t\\t\\t// object is cached, shrink the CACHED region\\n\\n\\t\\t\\t\\t\\t\\tvar firstActiveIndex = -- nCachedObjects,\\n\\t\\t\\t\\t\\t\\t\\tlastCachedObject = objects[ firstActiveIndex ],\\n\\t\\t\\t\\t\\t\\t\\tlastIndex = -- nObjects,\\n\\t\\t\\t\\t\\t\\t\\tlastObject = objects[ lastIndex ];\\n\\n\\t\\t\\t\\t\\t\\t// last cached object takes this object's place\\n\\t\\t\\t\\t\\t\\tindicesByUUID[ lastCachedObject.uuid ] = index;\\n\\t\\t\\t\\t\\t\\tobjects[ index ] = lastCachedObject;\\n\\n\\t\\t\\t\\t\\t\\t// last object goes to the activated slot and pop\\n\\t\\t\\t\\t\\t\\tindicesByUUID[ lastObject.uuid ] = firstActiveIndex;\\n\\t\\t\\t\\t\\t\\tobjects[ firstActiveIndex ] = lastObject;\\n\\t\\t\\t\\t\\t\\tobjects.pop();\\n\\n\\t\\t\\t\\t\\t\\t// accounting is done, now do the same for all bindings\\n\\n\\t\\t\\t\\t\\t\\tfor ( var j = 0, m = nBindings; j !== m; ++ j ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar bindingsForPath = bindings[ j ],\\n\\t\\t\\t\\t\\t\\t\\t\\tlastCached = bindingsForPath[ firstActiveIndex ],\\n\\t\\t\\t\\t\\t\\t\\t\\tlast = bindingsForPath[ lastIndex ];\\n\\n\\t\\t\\t\\t\\t\\t\\tbindingsForPath[ index ] = lastCached;\\n\\t\\t\\t\\t\\t\\t\\tbindingsForPath[ firstActiveIndex ] = last;\\n\\t\\t\\t\\t\\t\\t\\tbindingsForPath.pop();\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t// object is active, just swap with the last and pop\\n\\n\\t\\t\\t\\t\\t\\tvar lastIndex = -- nObjects,\\n\\t\\t\\t\\t\\t\\t\\tlastObject = objects[ lastIndex ];\\n\\n\\t\\t\\t\\t\\t\\tindicesByUUID[ lastObject.uuid ] = index;\\n\\t\\t\\t\\t\\t\\tobjects[ index ] = lastObject;\\n\\t\\t\\t\\t\\t\\tobjects.pop();\\n\\n\\t\\t\\t\\t\\t\\t// accounting is done, now do the same for all bindings\\n\\n\\t\\t\\t\\t\\t\\tfor ( var j = 0, m = nBindings; j !== m; ++ j ) {\\n\\n\\t\\t\\t\\t\\t\\t\\tvar bindingsForPath = bindings[ j ];\\n\\n\\t\\t\\t\\t\\t\\t\\tbindingsForPath[ index ] = bindingsForPath[ lastIndex ];\\n\\t\\t\\t\\t\\t\\t\\tbindingsForPath.pop();\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t} // cached or active\\n\\n\\t\\t\\t\\t} // if object is known\\n\\n\\t\\t\\t} // for arguments\\n\\n\\t\\t\\tthis.nCachedObjects_ = nCachedObjects;\\n\\n\\t\\t},\\n\\n\\t\\t// Internal interface used by befriended PropertyBinding.Composite:\\n\\n\\t\\tsubscribe_: function ( path, parsedPath ) {\\n\\n\\t\\t\\t// returns an array of bindings for the given path that is changed\\n\\t\\t\\t// according to the contained objects in the group\\n\\n\\t\\t\\tvar indicesByPath = this._bindingsIndicesByPath,\\n\\t\\t\\t\\tindex = indicesByPath[ path ],\\n\\t\\t\\t\\tbindings = this._bindings;\\n\\n\\t\\t\\tif ( index !== undefined ) return bindings[ index ];\\n\\n\\t\\t\\tvar paths = this._paths,\\n\\t\\t\\t\\tparsedPaths = this._parsedPaths,\\n\\t\\t\\t\\tobjects = this._objects,\\n\\t\\t\\t\\tnObjects = objects.length,\\n\\t\\t\\t\\tnCachedObjects = this.nCachedObjects_,\\n\\t\\t\\t\\tbindingsForPath = new Array( nObjects );\\n\\n\\t\\t\\tindex = bindings.length;\\n\\n\\t\\t\\tindicesByPath[ path ] = index;\\n\\n\\t\\t\\tpaths.push( path );\\n\\t\\t\\tparsedPaths.push( parsedPath );\\n\\t\\t\\tbindings.push( bindingsForPath );\\n\\n\\t\\t\\tfor ( var i = nCachedObjects, n = objects.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tvar object = objects[ i ];\\n\\t\\t\\t\\tbindingsForPath[ i ] = new PropertyBinding( object, path, parsedPath );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn bindingsForPath;\\n\\n\\t\\t},\\n\\n\\t\\tunsubscribe_: function ( path ) {\\n\\n\\t\\t\\t// tells the group to forget about a property path and no longer\\n\\t\\t\\t// update the array previously obtained with 'subscribe_'\\n\\n\\t\\t\\tvar indicesByPath = this._bindingsIndicesByPath,\\n\\t\\t\\t\\tindex = indicesByPath[ path ];\\n\\n\\t\\t\\tif ( index !== undefined ) {\\n\\n\\t\\t\\t\\tvar paths = this._paths,\\n\\t\\t\\t\\t\\tparsedPaths = this._parsedPaths,\\n\\t\\t\\t\\t\\tbindings = this._bindings,\\n\\t\\t\\t\\t\\tlastBindingsIndex = bindings.length - 1,\\n\\t\\t\\t\\t\\tlastBindings = bindings[ lastBindingsIndex ],\\n\\t\\t\\t\\t\\tlastBindingsPath = path[ lastBindingsIndex ];\\n\\n\\t\\t\\t\\tindicesByPath[ lastBindingsPath ] = index;\\n\\n\\t\\t\\t\\tbindings[ index ] = lastBindings;\\n\\t\\t\\t\\tbindings.pop();\\n\\n\\t\\t\\t\\tparsedPaths[ index ] = parsedPaths[ lastBindingsIndex ];\\n\\t\\t\\t\\tparsedPaths.pop();\\n\\n\\t\\t\\t\\tpaths[ index ] = paths[ lastBindingsIndex ];\\n\\t\\t\\t\\tpaths.pop();\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * Action provided by AnimationMixer for scheduling clip playback on specific\\n\\t * objects.\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t *\\n\\t */\\n\\n\\tfunction AnimationAction( mixer, clip, localRoot ) {\\n\\n\\t\\tthis._mixer = mixer;\\n\\t\\tthis._clip = clip;\\n\\t\\tthis._localRoot = localRoot || null;\\n\\n\\t\\tvar tracks = clip.tracks,\\n\\t\\t\\tnTracks = tracks.length,\\n\\t\\t\\tinterpolants = new Array( nTracks );\\n\\n\\t\\tvar interpolantSettings = {\\n\\t\\t\\tendingStart: ZeroCurvatureEnding,\\n\\t\\t\\tendingEnd: ZeroCurvatureEnding\\n\\t\\t};\\n\\n\\t\\tfor ( var i = 0; i !== nTracks; ++ i ) {\\n\\n\\t\\t\\tvar interpolant = tracks[ i ].createInterpolant( null );\\n\\t\\t\\tinterpolants[ i ] = interpolant;\\n\\t\\t\\tinterpolant.settings = interpolantSettings;\\n\\n\\t\\t}\\n\\n\\t\\tthis._interpolantSettings = interpolantSettings;\\n\\n\\t\\tthis._interpolants = interpolants;\\t// bound by the mixer\\n\\n\\t\\t// inside: PropertyMixer (managed by the mixer)\\n\\t\\tthis._propertyBindings = new Array( nTracks );\\n\\n\\t\\tthis._cacheIndex = null;\\t\\t\\t// for the memory manager\\n\\t\\tthis._byClipCacheIndex = null;\\t\\t// for the memory manager\\n\\n\\t\\tthis._timeScaleInterpolant = null;\\n\\t\\tthis._weightInterpolant = null;\\n\\n\\t\\tthis.loop = LoopRepeat;\\n\\t\\tthis._loopCount = - 1;\\n\\n\\t\\t// global mixer time when the action is to be started\\n\\t\\t// it's set back to 'null' upon start of the action\\n\\t\\tthis._startTime = null;\\n\\n\\t\\t// scaled local time of the action\\n\\t\\t// gets clamped or wrapped to 0..clip.duration according to loop\\n\\t\\tthis.time = 0;\\n\\n\\t\\tthis.timeScale = 1;\\n\\t\\tthis._effectiveTimeScale = 1;\\n\\n\\t\\tthis.weight = 1;\\n\\t\\tthis._effectiveWeight = 1;\\n\\n\\t\\tthis.repetitions = Infinity; \\t\\t// no. of repetitions when looping\\n\\n\\t\\tthis.paused = false;\\t\\t\\t\\t// true -> zero effective time scale\\n\\t\\tthis.enabled = true;\\t\\t\\t\\t// false -> zero effective weight\\n\\n\\t\\tthis.clampWhenFinished \\t= false;\\t// keep feeding the last frame?\\n\\n\\t\\tthis.zeroSlopeAtStart \\t= true;\\t\\t// for smooth interpolation w/o separate\\n\\t\\tthis.zeroSlopeAtEnd\\t\\t= true;\\t\\t// clips for start, loop and end\\n\\n\\t}\\n\\n\\tObject.assign( AnimationAction.prototype, {\\n\\n\\t\\t// State & Scheduling\\n\\n\\t\\tplay: function () {\\n\\n\\t\\t\\tthis._mixer._activateAction( this );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tstop: function () {\\n\\n\\t\\t\\tthis._mixer._deactivateAction( this );\\n\\n\\t\\t\\treturn this.reset();\\n\\n\\t\\t},\\n\\n\\t\\treset: function () {\\n\\n\\t\\t\\tthis.paused = false;\\n\\t\\t\\tthis.enabled = true;\\n\\n\\t\\t\\tthis.time = 0;\\t\\t\\t// restart clip\\n\\t\\t\\tthis._loopCount = - 1;\\t// forget previous loops\\n\\t\\t\\tthis._startTime = null;\\t// forget scheduling\\n\\n\\t\\t\\treturn this.stopFading().stopWarping();\\n\\n\\t\\t},\\n\\n\\t\\tisRunning: function () {\\n\\n\\t\\t\\treturn this.enabled && ! this.paused && this.timeScale !== 0 &&\\n\\t\\t\\t\\t\\tthis._startTime === null && this._mixer._isActiveAction( this );\\n\\n\\t\\t},\\n\\n\\t\\t// return true when play has been called\\n\\t\\tisScheduled: function () {\\n\\n\\t\\t\\treturn this._mixer._isActiveAction( this );\\n\\n\\t\\t},\\n\\n\\t\\tstartAt: function ( time ) {\\n\\n\\t\\t\\tthis._startTime = time;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetLoop: function ( mode, repetitions ) {\\n\\n\\t\\t\\tthis.loop = mode;\\n\\t\\t\\tthis.repetitions = repetitions;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// Weight\\n\\n\\t\\t// set the weight stopping any scheduled fading\\n\\t\\t// although .enabled = false yields an effective weight of zero, this\\n\\t\\t// method does *not* change .enabled, because it would be confusing\\n\\t\\tsetEffectiveWeight: function ( weight ) {\\n\\n\\t\\t\\tthis.weight = weight;\\n\\n\\t\\t\\t// note: same logic as when updated at runtime\\n\\t\\t\\tthis._effectiveWeight = this.enabled ? weight : 0;\\n\\n\\t\\t\\treturn this.stopFading();\\n\\n\\t\\t},\\n\\n\\t\\t// return the weight considering fading and .enabled\\n\\t\\tgetEffectiveWeight: function () {\\n\\n\\t\\t\\treturn this._effectiveWeight;\\n\\n\\t\\t},\\n\\n\\t\\tfadeIn: function ( duration ) {\\n\\n\\t\\t\\treturn this._scheduleFading( duration, 0, 1 );\\n\\n\\t\\t},\\n\\n\\t\\tfadeOut: function ( duration ) {\\n\\n\\t\\t\\treturn this._scheduleFading( duration, 1, 0 );\\n\\n\\t\\t},\\n\\n\\t\\tcrossFadeFrom: function ( fadeOutAction, duration, warp ) {\\n\\n\\t\\t\\tfadeOutAction.fadeOut( duration );\\n\\t\\t\\tthis.fadeIn( duration );\\n\\n\\t\\t\\tif ( warp ) {\\n\\n\\t\\t\\t\\tvar fadeInDuration = this._clip.duration,\\n\\t\\t\\t\\t\\tfadeOutDuration = fadeOutAction._clip.duration,\\n\\n\\t\\t\\t\\t\\tstartEndRatio = fadeOutDuration / fadeInDuration,\\n\\t\\t\\t\\t\\tendStartRatio = fadeInDuration / fadeOutDuration;\\n\\n\\t\\t\\t\\tfadeOutAction.warp( 1.0, startEndRatio, duration );\\n\\t\\t\\t\\tthis.warp( endStartRatio, 1.0, duration );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcrossFadeTo: function ( fadeInAction, duration, warp ) {\\n\\n\\t\\t\\treturn fadeInAction.crossFadeFrom( this, duration, warp );\\n\\n\\t\\t},\\n\\n\\t\\tstopFading: function () {\\n\\n\\t\\t\\tvar weightInterpolant = this._weightInterpolant;\\n\\n\\t\\t\\tif ( weightInterpolant !== null ) {\\n\\n\\t\\t\\t\\tthis._weightInterpolant = null;\\n\\t\\t\\t\\tthis._mixer._takeBackControlInterpolant( weightInterpolant );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// Time Scale Control\\n\\n\\t\\t// set the time scale stopping any scheduled warping\\n\\t\\t// although .paused = true yields an effective time scale of zero, this\\n\\t\\t// method does *not* change .paused, because it would be confusing\\n\\t\\tsetEffectiveTimeScale: function ( timeScale ) {\\n\\n\\t\\t\\tthis.timeScale = timeScale;\\n\\t\\t\\tthis._effectiveTimeScale = this.paused ? 0 : timeScale;\\n\\n\\t\\t\\treturn this.stopWarping();\\n\\n\\t\\t},\\n\\n\\t\\t// return the time scale considering warping and .paused\\n\\t\\tgetEffectiveTimeScale: function () {\\n\\n\\t\\t\\treturn this._effectiveTimeScale;\\n\\n\\t\\t},\\n\\n\\t\\tsetDuration: function ( duration ) {\\n\\n\\t\\t\\tthis.timeScale = this._clip.duration / duration;\\n\\n\\t\\t\\treturn this.stopWarping();\\n\\n\\t\\t},\\n\\n\\t\\tsyncWith: function ( action ) {\\n\\n\\t\\t\\tthis.time = action.time;\\n\\t\\t\\tthis.timeScale = action.timeScale;\\n\\n\\t\\t\\treturn this.stopWarping();\\n\\n\\t\\t},\\n\\n\\t\\thalt: function ( duration ) {\\n\\n\\t\\t\\treturn this.warp( this._effectiveTimeScale, 0, duration );\\n\\n\\t\\t},\\n\\n\\t\\twarp: function ( startTimeScale, endTimeScale, duration ) {\\n\\n\\t\\t\\tvar mixer = this._mixer, now = mixer.time,\\n\\t\\t\\t\\tinterpolant = this._timeScaleInterpolant,\\n\\n\\t\\t\\t\\ttimeScale = this.timeScale;\\n\\n\\t\\t\\tif ( interpolant === null ) {\\n\\n\\t\\t\\t\\tinterpolant = mixer._lendControlInterpolant();\\n\\t\\t\\t\\tthis._timeScaleInterpolant = interpolant;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar times = interpolant.parameterPositions,\\n\\t\\t\\t\\tvalues = interpolant.sampleValues;\\n\\n\\t\\t\\ttimes[ 0 ] = now;\\n\\t\\t\\ttimes[ 1 ] = now + duration;\\n\\n\\t\\t\\tvalues[ 0 ] = startTimeScale / timeScale;\\n\\t\\t\\tvalues[ 1 ] = endTimeScale / timeScale;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tstopWarping: function () {\\n\\n\\t\\t\\tvar timeScaleInterpolant = this._timeScaleInterpolant;\\n\\n\\t\\t\\tif ( timeScaleInterpolant !== null ) {\\n\\n\\t\\t\\t\\tthis._timeScaleInterpolant = null;\\n\\t\\t\\t\\tthis._mixer._takeBackControlInterpolant( timeScaleInterpolant );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// Object Accessors\\n\\n\\t\\tgetMixer: function () {\\n\\n\\t\\t\\treturn this._mixer;\\n\\n\\t\\t},\\n\\n\\t\\tgetClip: function () {\\n\\n\\t\\t\\treturn this._clip;\\n\\n\\t\\t},\\n\\n\\t\\tgetRoot: function () {\\n\\n\\t\\t\\treturn this._localRoot || this._mixer._root;\\n\\n\\t\\t},\\n\\n\\t\\t// Interna\\n\\n\\t\\t_update: function ( time, deltaTime, timeDirection, accuIndex ) {\\n\\n\\t\\t\\t// called by the mixer\\n\\n\\t\\t\\tif ( ! this.enabled ) {\\n\\n\\t\\t\\t\\t// call ._updateWeight() to update ._effectiveWeight\\n\\n\\t\\t\\t\\tthis._updateWeight( time );\\n\\t\\t\\t\\treturn;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar startTime = this._startTime;\\n\\n\\t\\t\\tif ( startTime !== null ) {\\n\\n\\t\\t\\t\\t// check for scheduled start of action\\n\\n\\t\\t\\t\\tvar timeRunning = ( time - startTime ) * timeDirection;\\n\\t\\t\\t\\tif ( timeRunning < 0 || timeDirection === 0 ) {\\n\\n\\t\\t\\t\\t\\treturn; // yet to come / don't decide when delta = 0\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// start\\n\\n\\t\\t\\t\\tthis._startTime = null; // unschedule\\n\\t\\t\\t\\tdeltaTime = timeDirection * timeRunning;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// apply time scale and advance time\\n\\n\\t\\t\\tdeltaTime *= this._updateTimeScale( time );\\n\\t\\t\\tvar clipTime = this._updateTime( deltaTime );\\n\\n\\t\\t\\t// note: _updateTime may disable the action resulting in\\n\\t\\t\\t// an effective weight of 0\\n\\n\\t\\t\\tvar weight = this._updateWeight( time );\\n\\n\\t\\t\\tif ( weight > 0 ) {\\n\\n\\t\\t\\t\\tvar interpolants = this._interpolants;\\n\\t\\t\\t\\tvar propertyMixers = this._propertyBindings;\\n\\n\\t\\t\\t\\tfor ( var j = 0, m = interpolants.length; j !== m; ++ j ) {\\n\\n\\t\\t\\t\\t\\tinterpolants[ j ].evaluate( clipTime );\\n\\t\\t\\t\\t\\tpropertyMixers[ j ].accumulate( accuIndex, weight );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t_updateWeight: function ( time ) {\\n\\n\\t\\t\\tvar weight = 0;\\n\\n\\t\\t\\tif ( this.enabled ) {\\n\\n\\t\\t\\t\\tweight = this.weight;\\n\\t\\t\\t\\tvar interpolant = this._weightInterpolant;\\n\\n\\t\\t\\t\\tif ( interpolant !== null ) {\\n\\n\\t\\t\\t\\t\\tvar interpolantValue = interpolant.evaluate( time )[ 0 ];\\n\\n\\t\\t\\t\\t\\tweight *= interpolantValue;\\n\\n\\t\\t\\t\\t\\tif ( time > interpolant.parameterPositions[ 1 ] ) {\\n\\n\\t\\t\\t\\t\\t\\tthis.stopFading();\\n\\n\\t\\t\\t\\t\\t\\tif ( interpolantValue === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// faded out, disable\\n\\t\\t\\t\\t\\t\\t\\tthis.enabled = false;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis._effectiveWeight = weight;\\n\\t\\t\\treturn weight;\\n\\n\\t\\t},\\n\\n\\t\\t_updateTimeScale: function ( time ) {\\n\\n\\t\\t\\tvar timeScale = 0;\\n\\n\\t\\t\\tif ( ! this.paused ) {\\n\\n\\t\\t\\t\\ttimeScale = this.timeScale;\\n\\n\\t\\t\\t\\tvar interpolant = this._timeScaleInterpolant;\\n\\n\\t\\t\\t\\tif ( interpolant !== null ) {\\n\\n\\t\\t\\t\\t\\tvar interpolantValue = interpolant.evaluate( time )[ 0 ];\\n\\n\\t\\t\\t\\t\\ttimeScale *= interpolantValue;\\n\\n\\t\\t\\t\\t\\tif ( time > interpolant.parameterPositions[ 1 ] ) {\\n\\n\\t\\t\\t\\t\\t\\tthis.stopWarping();\\n\\n\\t\\t\\t\\t\\t\\tif ( timeScale === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// motion has halted, pause\\n\\t\\t\\t\\t\\t\\t\\tthis.paused = true;\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\t// warp done - apply final time scale\\n\\t\\t\\t\\t\\t\\t\\tthis.timeScale = timeScale;\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis._effectiveTimeScale = timeScale;\\n\\t\\t\\treturn timeScale;\\n\\n\\t\\t},\\n\\n\\t\\t_updateTime: function ( deltaTime ) {\\n\\n\\t\\t\\tvar time = this.time + deltaTime;\\n\\n\\t\\t\\tif ( deltaTime === 0 ) return time;\\n\\n\\t\\t\\tvar duration = this._clip.duration,\\n\\n\\t\\t\\t\\tloop = this.loop,\\n\\t\\t\\t\\tloopCount = this._loopCount;\\n\\n\\t\\t\\tif ( loop === LoopOnce ) {\\n\\n\\t\\t\\t\\tif ( loopCount === - 1 ) {\\n\\n\\t\\t\\t\\t\\t// just started\\n\\n\\t\\t\\t\\t\\tthis._loopCount = 0;\\n\\t\\t\\t\\t\\tthis._setEndings( true, true, false );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\thandle_stop: {\\n\\n\\t\\t\\t\\t\\tif ( time >= duration ) {\\n\\n\\t\\t\\t\\t\\t\\ttime = duration;\\n\\n\\t\\t\\t\\t\\t} else if ( time < 0 ) {\\n\\n\\t\\t\\t\\t\\t\\ttime = 0;\\n\\n\\t\\t\\t\\t\\t} else break handle_stop;\\n\\n\\t\\t\\t\\t\\tif ( this.clampWhenFinished ) this.paused = true;\\n\\t\\t\\t\\t\\telse this.enabled = false;\\n\\n\\t\\t\\t\\t\\tthis._mixer.dispatchEvent( {\\n\\t\\t\\t\\t\\t\\ttype: 'finished', action: this,\\n\\t\\t\\t\\t\\t\\tdirection: deltaTime < 0 ? - 1 : 1\\n\\t\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else { // repetitive Repeat or PingPong\\n\\n\\t\\t\\t\\tvar pingPong = ( loop === LoopPingPong );\\n\\n\\t\\t\\t\\tif ( loopCount === - 1 ) {\\n\\n\\t\\t\\t\\t\\t// just started\\n\\n\\t\\t\\t\\t\\tif ( deltaTime >= 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tloopCount = 0;\\n\\n\\t\\t\\t\\t\\t\\tthis._setEndings( true, this.repetitions === 0, pingPong );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t// when looping in reverse direction, the initial\\n\\t\\t\\t\\t\\t\\t// transition through zero counts as a repetition,\\n\\t\\t\\t\\t\\t\\t// so leave loopCount at -1\\n\\n\\t\\t\\t\\t\\t\\tthis._setEndings( this.repetitions === 0, true, pingPong );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( time >= duration || time < 0 ) {\\n\\n\\t\\t\\t\\t\\t// wrap around\\n\\n\\t\\t\\t\\t\\tvar loopDelta = Math.floor( time / duration ); // signed\\n\\t\\t\\t\\t\\ttime -= duration * loopDelta;\\n\\n\\t\\t\\t\\t\\tloopCount += Math.abs( loopDelta );\\n\\n\\t\\t\\t\\t\\tvar pending = this.repetitions - loopCount;\\n\\n\\t\\t\\t\\t\\tif ( pending < 0 ) {\\n\\n\\t\\t\\t\\t\\t\\t// have to stop (switch state, clamp time, fire event)\\n\\n\\t\\t\\t\\t\\t\\tif ( this.clampWhenFinished ) this.paused = true;\\n\\t\\t\\t\\t\\t\\telse this.enabled = false;\\n\\n\\t\\t\\t\\t\\t\\ttime = deltaTime > 0 ? duration : 0;\\n\\n\\t\\t\\t\\t\\t\\tthis._mixer.dispatchEvent( {\\n\\t\\t\\t\\t\\t\\t\\ttype: 'finished', action: this,\\n\\t\\t\\t\\t\\t\\t\\tdirection: deltaTime > 0 ? 1 : - 1\\n\\t\\t\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t// keep running\\n\\n\\t\\t\\t\\t\\t\\tif ( pending === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t// entering the last round\\n\\n\\t\\t\\t\\t\\t\\t\\tvar atStart = deltaTime < 0;\\n\\t\\t\\t\\t\\t\\t\\tthis._setEndings( atStart, ! atStart, pingPong );\\n\\n\\t\\t\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\t\\t\\tthis._setEndings( false, false, pingPong );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tthis._loopCount = loopCount;\\n\\n\\t\\t\\t\\t\\t\\tthis._mixer.dispatchEvent( {\\n\\t\\t\\t\\t\\t\\t\\ttype: 'loop', action: this, loopDelta: loopDelta\\n\\t\\t\\t\\t\\t\\t} );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( pingPong && ( loopCount & 1 ) === 1 ) {\\n\\n\\t\\t\\t\\t\\t// invert time for the \\\"pong round\\\"\\n\\n\\t\\t\\t\\t\\tthis.time = time;\\n\\t\\t\\t\\t\\treturn duration - time;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.time = time;\\n\\t\\t\\treturn time;\\n\\n\\t\\t},\\n\\n\\t\\t_setEndings: function ( atStart, atEnd, pingPong ) {\\n\\n\\t\\t\\tvar settings = this._interpolantSettings;\\n\\n\\t\\t\\tif ( pingPong ) {\\n\\n\\t\\t\\t\\tsettings.endingStart \\t= ZeroSlopeEnding;\\n\\t\\t\\t\\tsettings.endingEnd\\t\\t= ZeroSlopeEnding;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t// assuming for LoopOnce atStart == atEnd == true\\n\\n\\t\\t\\t\\tif ( atStart ) {\\n\\n\\t\\t\\t\\t\\tsettings.endingStart = this.zeroSlopeAtStart ? ZeroSlopeEnding : ZeroCurvatureEnding;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tsettings.endingStart = WrapAroundEnding;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tif ( atEnd ) {\\n\\n\\t\\t\\t\\t\\tsettings.endingEnd = this.zeroSlopeAtEnd ? ZeroSlopeEnding : ZeroCurvatureEnding;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tsettings.endingEnd \\t = WrapAroundEnding;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t_scheduleFading: function ( duration, weightNow, weightThen ) {\\n\\n\\t\\t\\tvar mixer = this._mixer, now = mixer.time,\\n\\t\\t\\t\\tinterpolant = this._weightInterpolant;\\n\\n\\t\\t\\tif ( interpolant === null ) {\\n\\n\\t\\t\\t\\tinterpolant = mixer._lendControlInterpolant();\\n\\t\\t\\t\\tthis._weightInterpolant = interpolant;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar times = interpolant.parameterPositions,\\n\\t\\t\\t\\tvalues = interpolant.sampleValues;\\n\\n\\t\\t\\ttimes[ 0 ] = now; \\t\\t\\t\\tvalues[ 0 ] = weightNow;\\n\\t\\t\\ttimes[ 1 ] = now + duration;\\tvalues[ 1 ] = weightThen;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t *\\n\\t * Player for AnimationClips.\\n\\t *\\n\\t *\\n\\t * @author Ben Houston / http://clara.io/\\n\\t * @author David Sarno / http://lighthaus.us/\\n\\t * @author tschw\\n\\t */\\n\\n\\tfunction AnimationMixer( root ) {\\n\\n\\t\\tthis._root = root;\\n\\t\\tthis._initMemoryManager();\\n\\t\\tthis._accuIndex = 0;\\n\\n\\t\\tthis.time = 0;\\n\\n\\t\\tthis.timeScale = 1.0;\\n\\n\\t}\\n\\n\\tAnimationMixer.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {\\n\\n\\t\\tconstructor: AnimationMixer,\\n\\n\\t\\t_bindAction: function ( action, prototypeAction ) {\\n\\n\\t\\t\\tvar root = action._localRoot || this._root,\\n\\t\\t\\t\\ttracks = action._clip.tracks,\\n\\t\\t\\t\\tnTracks = tracks.length,\\n\\t\\t\\t\\tbindings = action._propertyBindings,\\n\\t\\t\\t\\tinterpolants = action._interpolants,\\n\\t\\t\\t\\trootUuid = root.uuid,\\n\\t\\t\\t\\tbindingsByRoot = this._bindingsByRootAndName,\\n\\t\\t\\t\\tbindingsByName = bindingsByRoot[ rootUuid ];\\n\\n\\t\\t\\tif ( bindingsByName === undefined ) {\\n\\n\\t\\t\\t\\tbindingsByName = {};\\n\\t\\t\\t\\tbindingsByRoot[ rootUuid ] = bindingsByName;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = 0; i !== nTracks; ++ i ) {\\n\\n\\t\\t\\t\\tvar track = tracks[ i ],\\n\\t\\t\\t\\t\\ttrackName = track.name,\\n\\t\\t\\t\\t\\tbinding = bindingsByName[ trackName ];\\n\\n\\t\\t\\t\\tif ( binding !== undefined ) {\\n\\n\\t\\t\\t\\t\\tbindings[ i ] = binding;\\n\\n\\t\\t\\t\\t} else {\\n\\n\\t\\t\\t\\t\\tbinding = bindings[ i ];\\n\\n\\t\\t\\t\\t\\tif ( binding !== undefined ) {\\n\\n\\t\\t\\t\\t\\t\\t// existing binding, make sure the cache knows\\n\\n\\t\\t\\t\\t\\t\\tif ( binding._cacheIndex === null ) {\\n\\n\\t\\t\\t\\t\\t\\t\\t++ binding.referenceCount;\\n\\t\\t\\t\\t\\t\\t\\tthis._addInactiveBinding( binding, rootUuid, trackName );\\n\\n\\t\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\t\\tcontinue;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t\\tvar path = prototypeAction && prototypeAction.\\n\\t\\t\\t\\t\\t\\t_propertyBindings[ i ].binding.parsedPath;\\n\\n\\t\\t\\t\\t\\tbinding = new PropertyMixer(\\n\\t\\t\\t\\t\\t\\tPropertyBinding.create( root, trackName, path ),\\n\\t\\t\\t\\t\\t\\ttrack.ValueTypeName, track.getValueSize() );\\n\\n\\t\\t\\t\\t\\t++ binding.referenceCount;\\n\\t\\t\\t\\t\\tthis._addInactiveBinding( binding, rootUuid, trackName );\\n\\n\\t\\t\\t\\t\\tbindings[ i ] = binding;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tinterpolants[ i ].resultBuffer = binding.buffer;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t_activateAction: function ( action ) {\\n\\n\\t\\t\\tif ( ! this._isActiveAction( action ) ) {\\n\\n\\t\\t\\t\\tif ( action._cacheIndex === null ) {\\n\\n\\t\\t\\t\\t\\t// this action has been forgotten by the cache, but the user\\n\\t\\t\\t\\t\\t// appears to be still using it -> rebind\\n\\n\\t\\t\\t\\t\\tvar rootUuid = ( action._localRoot || this._root ).uuid,\\n\\t\\t\\t\\t\\t\\tclipUuid = action._clip.uuid,\\n\\t\\t\\t\\t\\t\\tactionsForClip = this._actionsByClip[ clipUuid ];\\n\\n\\t\\t\\t\\t\\tthis._bindAction( action,\\n\\t\\t\\t\\t\\t\\tactionsForClip && actionsForClip.knownActions[ 0 ] );\\n\\n\\t\\t\\t\\t\\tthis._addInactiveAction( action, clipUuid, rootUuid );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tvar bindings = action._propertyBindings;\\n\\n\\t\\t\\t\\t// increment reference counts / sort out state\\n\\t\\t\\t\\tfor ( var i = 0, n = bindings.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\tvar binding = bindings[ i ];\\n\\n\\t\\t\\t\\t\\tif ( binding.useCount ++ === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tthis._lendBinding( binding );\\n\\t\\t\\t\\t\\t\\tbinding.saveOriginalState();\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis._lendAction( action );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t_deactivateAction: function ( action ) {\\n\\n\\t\\t\\tif ( this._isActiveAction( action ) ) {\\n\\n\\t\\t\\t\\tvar bindings = action._propertyBindings;\\n\\n\\t\\t\\t\\t// decrement reference counts / sort out state\\n\\t\\t\\t\\tfor ( var i = 0, n = bindings.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\tvar binding = bindings[ i ];\\n\\n\\t\\t\\t\\t\\tif ( -- binding.useCount === 0 ) {\\n\\n\\t\\t\\t\\t\\t\\tbinding.restoreOriginalState();\\n\\t\\t\\t\\t\\t\\tthis._takeBackBinding( binding );\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tthis._takeBackAction( action );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t// Memory manager\\n\\n\\t\\t_initMemoryManager: function () {\\n\\n\\t\\t\\tthis._actions = []; // 'nActiveActions' followed by inactive ones\\n\\t\\t\\tthis._nActiveActions = 0;\\n\\n\\t\\t\\tthis._actionsByClip = {};\\n\\t\\t\\t// inside:\\n\\t\\t\\t// {\\n\\t\\t\\t// \\t\\tknownActions: Array< AnimationAction >\\t- used as prototypes\\n\\t\\t\\t// \\t\\tactionByRoot: AnimationAction\\t\\t\\t- lookup\\n\\t\\t\\t// }\\n\\n\\n\\t\\t\\tthis._bindings = []; // 'nActiveBindings' followed by inactive ones\\n\\t\\t\\tthis._nActiveBindings = 0;\\n\\n\\t\\t\\tthis._bindingsByRootAndName = {}; // inside: Map< name, PropertyMixer >\\n\\n\\n\\t\\t\\tthis._controlInterpolants = []; // same game as above\\n\\t\\t\\tthis._nActiveControlInterpolants = 0;\\n\\n\\t\\t\\tvar scope = this;\\n\\n\\t\\t\\tthis.stats = {\\n\\n\\t\\t\\t\\tactions: {\\n\\t\\t\\t\\t\\tget total() {\\n\\n\\t\\t\\t\\t\\t\\treturn scope._actions.length;\\n\\n\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\tget inUse() {\\n\\n\\t\\t\\t\\t\\t\\treturn scope._nActiveActions;\\n\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t},\\n\\t\\t\\t\\tbindings: {\\n\\t\\t\\t\\t\\tget total() {\\n\\n\\t\\t\\t\\t\\t\\treturn scope._bindings.length;\\n\\n\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\tget inUse() {\\n\\n\\t\\t\\t\\t\\t\\treturn scope._nActiveBindings;\\n\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t},\\n\\t\\t\\t\\tcontrolInterpolants: {\\n\\t\\t\\t\\t\\tget total() {\\n\\n\\t\\t\\t\\t\\t\\treturn scope._controlInterpolants.length;\\n\\n\\t\\t\\t\\t\\t},\\n\\t\\t\\t\\t\\tget inUse() {\\n\\n\\t\\t\\t\\t\\t\\treturn scope._nActiveControlInterpolants;\\n\\n\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t};\\n\\n\\t\\t},\\n\\n\\t\\t// Memory management for AnimationAction objects\\n\\n\\t\\t_isActiveAction: function ( action ) {\\n\\n\\t\\t\\tvar index = action._cacheIndex;\\n\\t\\t\\treturn index !== null && index < this._nActiveActions;\\n\\n\\t\\t},\\n\\n\\t\\t_addInactiveAction: function ( action, clipUuid, rootUuid ) {\\n\\n\\t\\t\\tvar actions = this._actions,\\n\\t\\t\\t\\tactionsByClip = this._actionsByClip,\\n\\t\\t\\t\\tactionsForClip = actionsByClip[ clipUuid ];\\n\\n\\t\\t\\tif ( actionsForClip === undefined ) {\\n\\n\\t\\t\\t\\tactionsForClip = {\\n\\n\\t\\t\\t\\t\\tknownActions: [ action ],\\n\\t\\t\\t\\t\\tactionByRoot: {}\\n\\n\\t\\t\\t\\t};\\n\\n\\t\\t\\t\\taction._byClipCacheIndex = 0;\\n\\n\\t\\t\\t\\tactionsByClip[ clipUuid ] = actionsForClip;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tvar knownActions = actionsForClip.knownActions;\\n\\n\\t\\t\\t\\taction._byClipCacheIndex = knownActions.length;\\n\\t\\t\\t\\tknownActions.push( action );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\taction._cacheIndex = actions.length;\\n\\t\\t\\tactions.push( action );\\n\\n\\t\\t\\tactionsForClip.actionByRoot[ rootUuid ] = action;\\n\\n\\t\\t},\\n\\n\\t\\t_removeInactiveAction: function ( action ) {\\n\\n\\t\\t\\tvar actions = this._actions,\\n\\t\\t\\t\\tlastInactiveAction = actions[ actions.length - 1 ],\\n\\t\\t\\t\\tcacheIndex = action._cacheIndex;\\n\\n\\t\\t\\tlastInactiveAction._cacheIndex = cacheIndex;\\n\\t\\t\\tactions[ cacheIndex ] = lastInactiveAction;\\n\\t\\t\\tactions.pop();\\n\\n\\t\\t\\taction._cacheIndex = null;\\n\\n\\n\\t\\t\\tvar clipUuid = action._clip.uuid,\\n\\t\\t\\t\\tactionsByClip = this._actionsByClip,\\n\\t\\t\\t\\tactionsForClip = actionsByClip[ clipUuid ],\\n\\t\\t\\t\\tknownActionsForClip = actionsForClip.knownActions,\\n\\n\\t\\t\\t\\tlastKnownAction =\\n\\t\\t\\t\\t\\tknownActionsForClip[ knownActionsForClip.length - 1 ],\\n\\n\\t\\t\\t\\tbyClipCacheIndex = action._byClipCacheIndex;\\n\\n\\t\\t\\tlastKnownAction._byClipCacheIndex = byClipCacheIndex;\\n\\t\\t\\tknownActionsForClip[ byClipCacheIndex ] = lastKnownAction;\\n\\t\\t\\tknownActionsForClip.pop();\\n\\n\\t\\t\\taction._byClipCacheIndex = null;\\n\\n\\n\\t\\t\\tvar actionByRoot = actionsForClip.actionByRoot,\\n\\t\\t\\t\\trootUuid = ( action._localRoot || this._root ).uuid;\\n\\n\\t\\t\\tdelete actionByRoot[ rootUuid ];\\n\\n\\t\\t\\tif ( knownActionsForClip.length === 0 ) {\\n\\n\\t\\t\\t\\tdelete actionsByClip[ clipUuid ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis._removeInactiveBindingsForAction( action );\\n\\n\\t\\t},\\n\\n\\t\\t_removeInactiveBindingsForAction: function ( action ) {\\n\\n\\t\\t\\tvar bindings = action._propertyBindings;\\n\\t\\t\\tfor ( var i = 0, n = bindings.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\tvar binding = bindings[ i ];\\n\\n\\t\\t\\t\\tif ( -- binding.referenceCount === 0 ) {\\n\\n\\t\\t\\t\\t\\tthis._removeInactiveBinding( binding );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t_lendAction: function ( action ) {\\n\\n\\t\\t\\t// [ active actions |  inactive actions  ]\\n\\t\\t\\t// [  active actions >| inactive actions ]\\n\\t\\t\\t//                 s        a\\n\\t\\t\\t//                  <-swap->\\n\\t\\t\\t//                 a        s\\n\\n\\t\\t\\tvar actions = this._actions,\\n\\t\\t\\t\\tprevIndex = action._cacheIndex,\\n\\n\\t\\t\\t\\tlastActiveIndex = this._nActiveActions ++,\\n\\n\\t\\t\\t\\tfirstInactiveAction = actions[ lastActiveIndex ];\\n\\n\\t\\t\\taction._cacheIndex = lastActiveIndex;\\n\\t\\t\\tactions[ lastActiveIndex ] = action;\\n\\n\\t\\t\\tfirstInactiveAction._cacheIndex = prevIndex;\\n\\t\\t\\tactions[ prevIndex ] = firstInactiveAction;\\n\\n\\t\\t},\\n\\n\\t\\t_takeBackAction: function ( action ) {\\n\\n\\t\\t\\t// [  active actions  | inactive actions ]\\n\\t\\t\\t// [ active actions |< inactive actions  ]\\n\\t\\t\\t//        a        s\\n\\t\\t\\t//         <-swap->\\n\\t\\t\\t//        s        a\\n\\n\\t\\t\\tvar actions = this._actions,\\n\\t\\t\\t\\tprevIndex = action._cacheIndex,\\n\\n\\t\\t\\t\\tfirstInactiveIndex = -- this._nActiveActions,\\n\\n\\t\\t\\t\\tlastActiveAction = actions[ firstInactiveIndex ];\\n\\n\\t\\t\\taction._cacheIndex = firstInactiveIndex;\\n\\t\\t\\tactions[ firstInactiveIndex ] = action;\\n\\n\\t\\t\\tlastActiveAction._cacheIndex = prevIndex;\\n\\t\\t\\tactions[ prevIndex ] = lastActiveAction;\\n\\n\\t\\t},\\n\\n\\t\\t// Memory management for PropertyMixer objects\\n\\n\\t\\t_addInactiveBinding: function ( binding, rootUuid, trackName ) {\\n\\n\\t\\t\\tvar bindingsByRoot = this._bindingsByRootAndName,\\n\\t\\t\\t\\tbindingByName = bindingsByRoot[ rootUuid ],\\n\\n\\t\\t\\t\\tbindings = this._bindings;\\n\\n\\t\\t\\tif ( bindingByName === undefined ) {\\n\\n\\t\\t\\t\\tbindingByName = {};\\n\\t\\t\\t\\tbindingsByRoot[ rootUuid ] = bindingByName;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tbindingByName[ trackName ] = binding;\\n\\n\\t\\t\\tbinding._cacheIndex = bindings.length;\\n\\t\\t\\tbindings.push( binding );\\n\\n\\t\\t},\\n\\n\\t\\t_removeInactiveBinding: function ( binding ) {\\n\\n\\t\\t\\tvar bindings = this._bindings,\\n\\t\\t\\t\\tpropBinding = binding.binding,\\n\\t\\t\\t\\trootUuid = propBinding.rootNode.uuid,\\n\\t\\t\\t\\ttrackName = propBinding.path,\\n\\t\\t\\t\\tbindingsByRoot = this._bindingsByRootAndName,\\n\\t\\t\\t\\tbindingByName = bindingsByRoot[ rootUuid ],\\n\\n\\t\\t\\t\\tlastInactiveBinding = bindings[ bindings.length - 1 ],\\n\\t\\t\\t\\tcacheIndex = binding._cacheIndex;\\n\\n\\t\\t\\tlastInactiveBinding._cacheIndex = cacheIndex;\\n\\t\\t\\tbindings[ cacheIndex ] = lastInactiveBinding;\\n\\t\\t\\tbindings.pop();\\n\\n\\t\\t\\tdelete bindingByName[ trackName ];\\n\\n\\t\\t\\tremove_empty_map: {\\n\\n\\t\\t\\t\\tfor ( var _ in bindingByName ) break remove_empty_map; // eslint-disable-line no-unused-vars\\n\\n\\t\\t\\t\\tdelete bindingsByRoot[ rootUuid ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t_lendBinding: function ( binding ) {\\n\\n\\t\\t\\tvar bindings = this._bindings,\\n\\t\\t\\t\\tprevIndex = binding._cacheIndex,\\n\\n\\t\\t\\t\\tlastActiveIndex = this._nActiveBindings ++,\\n\\n\\t\\t\\t\\tfirstInactiveBinding = bindings[ lastActiveIndex ];\\n\\n\\t\\t\\tbinding._cacheIndex = lastActiveIndex;\\n\\t\\t\\tbindings[ lastActiveIndex ] = binding;\\n\\n\\t\\t\\tfirstInactiveBinding._cacheIndex = prevIndex;\\n\\t\\t\\tbindings[ prevIndex ] = firstInactiveBinding;\\n\\n\\t\\t},\\n\\n\\t\\t_takeBackBinding: function ( binding ) {\\n\\n\\t\\t\\tvar bindings = this._bindings,\\n\\t\\t\\t\\tprevIndex = binding._cacheIndex,\\n\\n\\t\\t\\t\\tfirstInactiveIndex = -- this._nActiveBindings,\\n\\n\\t\\t\\t\\tlastActiveBinding = bindings[ firstInactiveIndex ];\\n\\n\\t\\t\\tbinding._cacheIndex = firstInactiveIndex;\\n\\t\\t\\tbindings[ firstInactiveIndex ] = binding;\\n\\n\\t\\t\\tlastActiveBinding._cacheIndex = prevIndex;\\n\\t\\t\\tbindings[ prevIndex ] = lastActiveBinding;\\n\\n\\t\\t},\\n\\n\\n\\t\\t// Memory management of Interpolants for weight and time scale\\n\\n\\t\\t_lendControlInterpolant: function () {\\n\\n\\t\\t\\tvar interpolants = this._controlInterpolants,\\n\\t\\t\\t\\tlastActiveIndex = this._nActiveControlInterpolants ++,\\n\\t\\t\\t\\tinterpolant = interpolants[ lastActiveIndex ];\\n\\n\\t\\t\\tif ( interpolant === undefined ) {\\n\\n\\t\\t\\t\\tinterpolant = new LinearInterpolant(\\n\\t\\t\\t\\t\\tnew Float32Array( 2 ), new Float32Array( 2 ),\\n\\t\\t\\t\\t\\t1, this._controlInterpolantsResultBuffer );\\n\\n\\t\\t\\t\\tinterpolant.__cacheIndex = lastActiveIndex;\\n\\t\\t\\t\\tinterpolants[ lastActiveIndex ] = interpolant;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn interpolant;\\n\\n\\t\\t},\\n\\n\\t\\t_takeBackControlInterpolant: function ( interpolant ) {\\n\\n\\t\\t\\tvar interpolants = this._controlInterpolants,\\n\\t\\t\\t\\tprevIndex = interpolant.__cacheIndex,\\n\\n\\t\\t\\t\\tfirstInactiveIndex = -- this._nActiveControlInterpolants,\\n\\n\\t\\t\\t\\tlastActiveInterpolant = interpolants[ firstInactiveIndex ];\\n\\n\\t\\t\\tinterpolant.__cacheIndex = firstInactiveIndex;\\n\\t\\t\\tinterpolants[ firstInactiveIndex ] = interpolant;\\n\\n\\t\\t\\tlastActiveInterpolant.__cacheIndex = prevIndex;\\n\\t\\t\\tinterpolants[ prevIndex ] = lastActiveInterpolant;\\n\\n\\t\\t},\\n\\n\\t\\t_controlInterpolantsResultBuffer: new Float32Array( 1 ),\\n\\n\\t\\t// return an action for a clip optionally using a custom root target\\n\\t\\t// object (this method allocates a lot of dynamic memory in case a\\n\\t\\t// previously unknown clip/root combination is specified)\\n\\t\\tclipAction: function ( clip, optionalRoot ) {\\n\\n\\t\\t\\tvar root = optionalRoot || this._root,\\n\\t\\t\\t\\trootUuid = root.uuid,\\n\\n\\t\\t\\t\\tclipObject = typeof clip === 'string' ?\\n\\t\\t\\t\\t\\tAnimationClip.findByName( root, clip ) : clip,\\n\\n\\t\\t\\t\\tclipUuid = clipObject !== null ? clipObject.uuid : clip,\\n\\n\\t\\t\\t\\tactionsForClip = this._actionsByClip[ clipUuid ],\\n\\t\\t\\t\\tprototypeAction = null;\\n\\n\\t\\t\\tif ( actionsForClip !== undefined ) {\\n\\n\\t\\t\\t\\tvar existingAction =\\n\\t\\t\\t\\t\\t\\tactionsForClip.actionByRoot[ rootUuid ];\\n\\n\\t\\t\\t\\tif ( existingAction !== undefined ) {\\n\\n\\t\\t\\t\\t\\treturn existingAction;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t// we know the clip, so we don't have to parse all\\n\\t\\t\\t\\t// the bindings again but can just copy\\n\\t\\t\\t\\tprototypeAction = actionsForClip.knownActions[ 0 ];\\n\\n\\t\\t\\t\\t// also, take the clip from the prototype action\\n\\t\\t\\t\\tif ( clipObject === null )\\n\\t\\t\\t\\t\\tclipObject = prototypeAction._clip;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// clip must be known when specified via string\\n\\t\\t\\tif ( clipObject === null ) return null;\\n\\n\\t\\t\\t// allocate all resources required to run it\\n\\t\\t\\tvar newAction = new AnimationAction( this, clipObject, optionalRoot );\\n\\n\\t\\t\\tthis._bindAction( newAction, prototypeAction );\\n\\n\\t\\t\\t// and make the action known to the memory manager\\n\\t\\t\\tthis._addInactiveAction( newAction, clipUuid, rootUuid );\\n\\n\\t\\t\\treturn newAction;\\n\\n\\t\\t},\\n\\n\\t\\t// get an existing action\\n\\t\\texistingAction: function ( clip, optionalRoot ) {\\n\\n\\t\\t\\tvar root = optionalRoot || this._root,\\n\\t\\t\\t\\trootUuid = root.uuid,\\n\\n\\t\\t\\t\\tclipObject = typeof clip === 'string' ?\\n\\t\\t\\t\\t\\tAnimationClip.findByName( root, clip ) : clip,\\n\\n\\t\\t\\t\\tclipUuid = clipObject ? clipObject.uuid : clip,\\n\\n\\t\\t\\t\\tactionsForClip = this._actionsByClip[ clipUuid ];\\n\\n\\t\\t\\tif ( actionsForClip !== undefined ) {\\n\\n\\t\\t\\t\\treturn actionsForClip.actionByRoot[ rootUuid ] || null;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn null;\\n\\n\\t\\t},\\n\\n\\t\\t// deactivates all previously scheduled actions\\n\\t\\tstopAllAction: function () {\\n\\n\\t\\t\\tvar actions = this._actions,\\n\\t\\t\\t\\tnActions = this._nActiveActions,\\n\\t\\t\\t\\tbindings = this._bindings,\\n\\t\\t\\t\\tnBindings = this._nActiveBindings;\\n\\n\\t\\t\\tthis._nActiveActions = 0;\\n\\t\\t\\tthis._nActiveBindings = 0;\\n\\n\\t\\t\\tfor ( var i = 0; i !== nActions; ++ i ) {\\n\\n\\t\\t\\t\\tactions[ i ].reset();\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = 0; i !== nBindings; ++ i ) {\\n\\n\\t\\t\\t\\tbindings[ i ].useCount = 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// advance the time and update apply the animation\\n\\t\\tupdate: function ( deltaTime ) {\\n\\n\\t\\t\\tdeltaTime *= this.timeScale;\\n\\n\\t\\t\\tvar actions = this._actions,\\n\\t\\t\\t\\tnActions = this._nActiveActions,\\n\\n\\t\\t\\t\\ttime = this.time += deltaTime,\\n\\t\\t\\t\\ttimeDirection = Math.sign( deltaTime ),\\n\\n\\t\\t\\t\\taccuIndex = this._accuIndex ^= 1;\\n\\n\\t\\t\\t// run active actions\\n\\n\\t\\t\\tfor ( var i = 0; i !== nActions; ++ i ) {\\n\\n\\t\\t\\t\\tvar action = actions[ i ];\\n\\n\\t\\t\\t\\taction._update( time, deltaTime, timeDirection, accuIndex );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\t// update scene graph\\n\\n\\t\\t\\tvar bindings = this._bindings,\\n\\t\\t\\t\\tnBindings = this._nActiveBindings;\\n\\n\\t\\t\\tfor ( var i = 0; i !== nBindings; ++ i ) {\\n\\n\\t\\t\\t\\tbindings[ i ].apply( accuIndex );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// return this mixer's root target object\\n\\t\\tgetRoot: function () {\\n\\n\\t\\t\\treturn this._root;\\n\\n\\t\\t},\\n\\n\\t\\t// free all resources specific to a particular clip\\n\\t\\tuncacheClip: function ( clip ) {\\n\\n\\t\\t\\tvar actions = this._actions,\\n\\t\\t\\t\\tclipUuid = clip.uuid,\\n\\t\\t\\t\\tactionsByClip = this._actionsByClip,\\n\\t\\t\\t\\tactionsForClip = actionsByClip[ clipUuid ];\\n\\n\\t\\t\\tif ( actionsForClip !== undefined ) {\\n\\n\\t\\t\\t\\t// note: just calling _removeInactiveAction would mess up the\\n\\t\\t\\t\\t// iteration state and also require updating the state we can\\n\\t\\t\\t\\t// just throw away\\n\\n\\t\\t\\t\\tvar actionsToRemove = actionsForClip.knownActions;\\n\\n\\t\\t\\t\\tfor ( var i = 0, n = actionsToRemove.length; i !== n; ++ i ) {\\n\\n\\t\\t\\t\\t\\tvar action = actionsToRemove[ i ];\\n\\n\\t\\t\\t\\t\\tthis._deactivateAction( action );\\n\\n\\t\\t\\t\\t\\tvar cacheIndex = action._cacheIndex,\\n\\t\\t\\t\\t\\t\\tlastInactiveAction = actions[ actions.length - 1 ];\\n\\n\\t\\t\\t\\t\\taction._cacheIndex = null;\\n\\t\\t\\t\\t\\taction._byClipCacheIndex = null;\\n\\n\\t\\t\\t\\t\\tlastInactiveAction._cacheIndex = cacheIndex;\\n\\t\\t\\t\\t\\tactions[ cacheIndex ] = lastInactiveAction;\\n\\t\\t\\t\\t\\tactions.pop();\\n\\n\\t\\t\\t\\t\\tthis._removeInactiveBindingsForAction( action );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tdelete actionsByClip[ clipUuid ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t// free all resources specific to a particular root target object\\n\\t\\tuncacheRoot: function ( root ) {\\n\\n\\t\\t\\tvar rootUuid = root.uuid,\\n\\t\\t\\t\\tactionsByClip = this._actionsByClip;\\n\\n\\t\\t\\tfor ( var clipUuid in actionsByClip ) {\\n\\n\\t\\t\\t\\tvar actionByRoot = actionsByClip[ clipUuid ].actionByRoot,\\n\\t\\t\\t\\t\\taction = actionByRoot[ rootUuid ];\\n\\n\\t\\t\\t\\tif ( action !== undefined ) {\\n\\n\\t\\t\\t\\t\\tthis._deactivateAction( action );\\n\\t\\t\\t\\t\\tthis._removeInactiveAction( action );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tvar bindingsByRoot = this._bindingsByRootAndName,\\n\\t\\t\\t\\tbindingByName = bindingsByRoot[ rootUuid ];\\n\\n\\t\\t\\tif ( bindingByName !== undefined ) {\\n\\n\\t\\t\\t\\tfor ( var trackName in bindingByName ) {\\n\\n\\t\\t\\t\\t\\tvar binding = bindingByName[ trackName ];\\n\\t\\t\\t\\t\\tbinding.restoreOriginalState();\\n\\t\\t\\t\\t\\tthis._removeInactiveBinding( binding );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\t// remove a targeted clip from the cache\\n\\t\\tuncacheAction: function ( clip, optionalRoot ) {\\n\\n\\t\\t\\tvar action = this.existingAction( clip, optionalRoot );\\n\\n\\t\\t\\tif ( action !== null ) {\\n\\n\\t\\t\\t\\tthis._deactivateAction( action );\\n\\t\\t\\t\\tthis._removeInactiveAction( action );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Uniform( value ) {\\n\\n\\t\\tif ( typeof value === 'string' ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Uniform: Type parameter is no longer needed.' );\\n\\t\\t\\tvalue = arguments[ 1 ];\\n\\n\\t\\t}\\n\\n\\t\\tthis.value = value;\\n\\n\\t}\\n\\n\\tUniform.prototype.clone = function () {\\n\\n\\t\\treturn new Uniform( this.value.clone === undefined ? this.value : this.value.clone() );\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author benaadams / https://twitter.com/ben_a_adams\\n\\t */\\n\\n\\tfunction InstancedBufferGeometry() {\\n\\n\\t\\tBufferGeometry.call( this );\\n\\n\\t\\tthis.type = 'InstancedBufferGeometry';\\n\\t\\tthis.maxInstancedCount = undefined;\\n\\n\\t}\\n\\n\\tInstancedBufferGeometry.prototype = Object.assign( Object.create( BufferGeometry.prototype ), {\\n\\n\\t\\tconstructor: InstancedBufferGeometry,\\n\\n\\t\\tisInstancedBufferGeometry: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tBufferGeometry.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.maxInstancedCount = source.maxInstancedCount;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author benaadams / https://twitter.com/ben_a_adams\\n\\t */\\n\\n\\tfunction InterleavedBufferAttribute( interleavedBuffer, itemSize, offset, normalized ) {\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.data = interleavedBuffer;\\n\\t\\tthis.itemSize = itemSize;\\n\\t\\tthis.offset = offset;\\n\\n\\t\\tthis.normalized = normalized === true;\\n\\n\\t}\\n\\n\\tObject.defineProperties( InterleavedBufferAttribute.prototype, {\\n\\n\\t\\tcount: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.data.count;\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tarray: {\\n\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.data.array;\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( InterleavedBufferAttribute.prototype, {\\n\\n\\t\\tisInterleavedBufferAttribute: true,\\n\\n\\t\\tsetX: function ( index, x ) {\\n\\n\\t\\t\\tthis.data.array[ index * this.data.stride + this.offset ] = x;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetY: function ( index, y ) {\\n\\n\\t\\t\\tthis.data.array[ index * this.data.stride + this.offset + 1 ] = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetZ: function ( index, z ) {\\n\\n\\t\\t\\tthis.data.array[ index * this.data.stride + this.offset + 2 ] = z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetW: function ( index, w ) {\\n\\n\\t\\t\\tthis.data.array[ index * this.data.stride + this.offset + 3 ] = w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tgetX: function ( index ) {\\n\\n\\t\\t\\treturn this.data.array[ index * this.data.stride + this.offset ];\\n\\n\\t\\t},\\n\\n\\t\\tgetY: function ( index ) {\\n\\n\\t\\t\\treturn this.data.array[ index * this.data.stride + this.offset + 1 ];\\n\\n\\t\\t},\\n\\n\\t\\tgetZ: function ( index ) {\\n\\n\\t\\t\\treturn this.data.array[ index * this.data.stride + this.offset + 2 ];\\n\\n\\t\\t},\\n\\n\\t\\tgetW: function ( index ) {\\n\\n\\t\\t\\treturn this.data.array[ index * this.data.stride + this.offset + 3 ];\\n\\n\\t\\t},\\n\\n\\t\\tsetXY: function ( index, x, y ) {\\n\\n\\t\\t\\tindex = index * this.data.stride + this.offset;\\n\\n\\t\\t\\tthis.data.array[ index + 0 ] = x;\\n\\t\\t\\tthis.data.array[ index + 1 ] = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetXYZ: function ( index, x, y, z ) {\\n\\n\\t\\t\\tindex = index * this.data.stride + this.offset;\\n\\n\\t\\t\\tthis.data.array[ index + 0 ] = x;\\n\\t\\t\\tthis.data.array[ index + 1 ] = y;\\n\\t\\t\\tthis.data.array[ index + 2 ] = z;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetXYZW: function ( index, x, y, z, w ) {\\n\\n\\t\\t\\tindex = index * this.data.stride + this.offset;\\n\\n\\t\\t\\tthis.data.array[ index + 0 ] = x;\\n\\t\\t\\tthis.data.array[ index + 1 ] = y;\\n\\t\\t\\tthis.data.array[ index + 2 ] = z;\\n\\t\\t\\tthis.data.array[ index + 3 ] = w;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author benaadams / https://twitter.com/ben_a_adams\\n\\t */\\n\\n\\tfunction InterleavedBuffer( array, stride ) {\\n\\n\\t\\tthis.uuid = _Math.generateUUID();\\n\\n\\t\\tthis.array = array;\\n\\t\\tthis.stride = stride;\\n\\t\\tthis.count = array !== undefined ? array.length / stride : 0;\\n\\n\\t\\tthis.dynamic = false;\\n\\t\\tthis.updateRange = { offset: 0, count: - 1 };\\n\\n\\t\\tthis.onUploadCallback = function () {};\\n\\n\\t\\tthis.version = 0;\\n\\n\\t}\\n\\n\\tObject.defineProperty( InterleavedBuffer.prototype, 'needsUpdate', {\\n\\n\\t\\tset: function ( value ) {\\n\\n\\t\\t\\tif ( value === true ) this.version ++;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( InterleavedBuffer.prototype, {\\n\\n\\t\\tisInterleavedBuffer: true,\\n\\n\\t\\tsetArray: function ( array ) {\\n\\n\\t\\t\\tif ( Array.isArray( array ) ) {\\n\\n\\t\\t\\t\\tthrow new TypeError( 'THREE.BufferAttribute: array should be a Typed Array.' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.count = array !== undefined ? array.length / this.stride : 0;\\n\\t\\t\\tthis.array = array;\\n\\n\\t\\t},\\n\\n\\t\\tsetDynamic: function ( value ) {\\n\\n\\t\\t\\tthis.dynamic = value;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tthis.array = new source.array.constructor( source.array );\\n\\t\\t\\tthis.count = source.count;\\n\\t\\t\\tthis.stride = source.stride;\\n\\t\\t\\tthis.dynamic = source.dynamic;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tcopyAt: function ( index1, attribute, index2 ) {\\n\\n\\t\\t\\tindex1 *= this.stride;\\n\\t\\t\\tindex2 *= attribute.stride;\\n\\n\\t\\t\\tfor ( var i = 0, l = this.stride; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tthis.array[ index1 + i ] = attribute.array[ index2 + i ];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tset: function ( value, offset ) {\\n\\n\\t\\t\\tif ( offset === undefined ) offset = 0;\\n\\n\\t\\t\\tthis.array.set( value, offset );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tonUpload: function ( callback ) {\\n\\n\\t\\t\\tthis.onUploadCallback = callback;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author benaadams / https://twitter.com/ben_a_adams\\n\\t */\\n\\n\\tfunction InstancedInterleavedBuffer( array, stride, meshPerAttribute ) {\\n\\n\\t\\tInterleavedBuffer.call( this, array, stride );\\n\\n\\t\\tthis.meshPerAttribute = meshPerAttribute || 1;\\n\\n\\t}\\n\\n\\tInstancedInterleavedBuffer.prototype = Object.assign( Object.create( InterleavedBuffer.prototype ), {\\n\\n\\t\\tconstructor: InstancedInterleavedBuffer,\\n\\n\\t\\tisInstancedInterleavedBuffer: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tInterleavedBuffer.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.meshPerAttribute = source.meshPerAttribute;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author benaadams / https://twitter.com/ben_a_adams\\n\\t */\\n\\n\\tfunction InstancedBufferAttribute( array, itemSize, meshPerAttribute ) {\\n\\n\\t\\tBufferAttribute.call( this, array, itemSize );\\n\\n\\t\\tthis.meshPerAttribute = meshPerAttribute || 1;\\n\\n\\t}\\n\\n\\tInstancedBufferAttribute.prototype = Object.assign( Object.create( BufferAttribute.prototype ), {\\n\\n\\t\\tconstructor: InstancedBufferAttribute,\\n\\n\\t\\tisInstancedBufferAttribute: true,\\n\\n\\t\\tcopy: function ( source ) {\\n\\n\\t\\t\\tBufferAttribute.prototype.copy.call( this, source );\\n\\n\\t\\t\\tthis.meshPerAttribute = source.meshPerAttribute;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author bhouston / http://clara.io/\\n\\t * @author stephomi / http://stephaneginier.com/\\n\\t */\\n\\n\\tfunction Raycaster( origin, direction, near, far ) {\\n\\n\\t\\tthis.ray = new Ray( origin, direction );\\n\\t\\t// direction is assumed to be normalized (for accurate distance calculations)\\n\\n\\t\\tthis.near = near || 0;\\n\\t\\tthis.far = far || Infinity;\\n\\n\\t\\tthis.params = {\\n\\t\\t\\tMesh: {},\\n\\t\\t\\tLine: {},\\n\\t\\t\\tLOD: {},\\n\\t\\t\\tPoints: { threshold: 1 },\\n\\t\\t\\tSprite: {}\\n\\t\\t};\\n\\n\\t\\tObject.defineProperties( this.params, {\\n\\t\\t\\tPointCloud: {\\n\\t\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\t\\tconsole.warn( 'THREE.Raycaster: params.PointCloud has been renamed to params.Points.' );\\n\\t\\t\\t\\t\\treturn this.Points;\\n\\n\\t\\t\\t\\t}\\n\\t\\t\\t}\\n\\t\\t} );\\n\\n\\t}\\n\\n\\tfunction ascSort( a, b ) {\\n\\n\\t\\treturn a.distance - b.distance;\\n\\n\\t}\\n\\n\\tfunction intersectObject( object, raycaster, intersects, recursive ) {\\n\\n\\t\\tif ( object.visible === false ) return;\\n\\n\\t\\tobject.raycast( raycaster, intersects );\\n\\n\\t\\tif ( recursive === true ) {\\n\\n\\t\\t\\tvar children = object.children;\\n\\n\\t\\t\\tfor ( var i = 0, l = children.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tintersectObject( children[ i ], raycaster, intersects, true );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t}\\n\\n\\tObject.assign( Raycaster.prototype, {\\n\\n\\t\\tlinePrecision: 1,\\n\\n\\t\\tset: function ( origin, direction ) {\\n\\n\\t\\t\\t// direction is assumed to be normalized (for accurate distance calculations)\\n\\n\\t\\t\\tthis.ray.set( origin, direction );\\n\\n\\t\\t},\\n\\n\\t\\tsetFromCamera: function ( coords, camera ) {\\n\\n\\t\\t\\tif ( ( camera && camera.isPerspectiveCamera ) ) {\\n\\n\\t\\t\\t\\tthis.ray.origin.setFromMatrixPosition( camera.matrixWorld );\\n\\t\\t\\t\\tthis.ray.direction.set( coords.x, coords.y, 0.5 ).unproject( camera ).sub( this.ray.origin ).normalize();\\n\\n\\t\\t\\t} else if ( ( camera && camera.isOrthographicCamera ) ) {\\n\\n\\t\\t\\t\\tthis.ray.origin.set( coords.x, coords.y, ( camera.near + camera.far ) / ( camera.near - camera.far ) ).unproject( camera ); // set origin in plane of camera\\n\\t\\t\\t\\tthis.ray.direction.set( 0, 0, - 1 ).transformDirection( camera.matrixWorld );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.Raycaster: Unsupported camera type.' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t},\\n\\n\\t\\tintersectObject: function ( object, recursive ) {\\n\\n\\t\\t\\tvar intersects = [];\\n\\n\\t\\t\\tintersectObject( object, this, intersects, recursive );\\n\\n\\t\\t\\tintersects.sort( ascSort );\\n\\n\\t\\t\\treturn intersects;\\n\\n\\t\\t},\\n\\n\\t\\tintersectObjects: function ( objects, recursive ) {\\n\\n\\t\\t\\tvar intersects = [];\\n\\n\\t\\t\\tif ( Array.isArray( objects ) === false ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Raycaster.intersectObjects: objects is not an Array.' );\\n\\t\\t\\t\\treturn intersects;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tfor ( var i = 0, l = objects.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tintersectObject( objects[ i ], this, intersects, recursive );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tintersects.sort( ascSort );\\n\\n\\t\\t\\treturn intersects;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction Clock( autoStart ) {\\n\\n\\t\\tthis.autoStart = ( autoStart !== undefined ) ? autoStart : true;\\n\\n\\t\\tthis.startTime = 0;\\n\\t\\tthis.oldTime = 0;\\n\\t\\tthis.elapsedTime = 0;\\n\\n\\t\\tthis.running = false;\\n\\n\\t}\\n\\n\\tObject.assign( Clock.prototype, {\\n\\n\\t\\tstart: function () {\\n\\n\\t\\t\\tthis.startTime = ( typeof performance === 'undefined' ? Date : performance ).now(); // see #10732\\n\\n\\t\\t\\tthis.oldTime = this.startTime;\\n\\t\\t\\tthis.elapsedTime = 0;\\n\\t\\t\\tthis.running = true;\\n\\n\\t\\t},\\n\\n\\t\\tstop: function () {\\n\\n\\t\\t\\tthis.getElapsedTime();\\n\\t\\t\\tthis.running = false;\\n\\t\\t\\tthis.autoStart = false;\\n\\n\\t\\t},\\n\\n\\t\\tgetElapsedTime: function () {\\n\\n\\t\\t\\tthis.getDelta();\\n\\t\\t\\treturn this.elapsedTime;\\n\\n\\t\\t},\\n\\n\\t\\tgetDelta: function () {\\n\\n\\t\\t\\tvar diff = 0;\\n\\n\\t\\t\\tif ( this.autoStart && ! this.running ) {\\n\\n\\t\\t\\t\\tthis.start();\\n\\t\\t\\t\\treturn 0;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.running ) {\\n\\n\\t\\t\\t\\tvar newTime = ( typeof performance === 'undefined' ? Date : performance ).now();\\n\\n\\t\\t\\t\\tdiff = ( newTime - this.oldTime ) / 1000;\\n\\t\\t\\t\\tthis.oldTime = newTime;\\n\\n\\t\\t\\t\\tthis.elapsedTime += diff;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn diff;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author bhouston / http://clara.io\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t *\\n\\t * Ref: https://en.wikipedia.org/wiki/Spherical_coordinate_system\\n\\t *\\n\\t * The poles (phi) are at the positive and negative y axis.\\n\\t * The equator starts at positive z.\\n\\t */\\n\\n\\tfunction Spherical( radius, phi, theta ) {\\n\\n\\t\\tthis.radius = ( radius !== undefined ) ? radius : 1.0;\\n\\t\\tthis.phi = ( phi !== undefined ) ? phi : 0; // up / down towards top and bottom pole\\n\\t\\tthis.theta = ( theta !== undefined ) ? theta : 0; // around the equator of the sphere\\n\\n\\t\\treturn this;\\n\\n\\t}\\n\\n\\tObject.assign( Spherical.prototype, {\\n\\n\\t\\tset: function ( radius, phi, theta ) {\\n\\n\\t\\t\\tthis.radius = radius;\\n\\t\\t\\tthis.phi = phi;\\n\\t\\t\\tthis.theta = theta;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( other ) {\\n\\n\\t\\t\\tthis.radius = other.radius;\\n\\t\\t\\tthis.phi = other.phi;\\n\\t\\t\\tthis.theta = other.theta;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\t// restrict phi to be betwee EPS and PI-EPS\\n\\t\\tmakeSafe: function () {\\n\\n\\t\\t\\tvar EPS = 0.000001;\\n\\t\\t\\tthis.phi = Math.max( EPS, Math.min( Math.PI - EPS, this.phi ) );\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromVector3: function ( vec3 ) {\\n\\n\\t\\t\\tthis.radius = vec3.length();\\n\\n\\t\\t\\tif ( this.radius === 0 ) {\\n\\n\\t\\t\\t\\tthis.theta = 0;\\n\\t\\t\\t\\tthis.phi = 0;\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.theta = Math.atan2( vec3.x, vec3.z ); // equator angle around y-up axis\\n\\t\\t\\t\\tthis.phi = Math.acos( _Math.clamp( vec3.y / this.radius, - 1, 1 ) ); // polar angle\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t *\\n\\t * Ref: https://en.wikipedia.org/wiki/Cylindrical_coordinate_system\\n\\t *\\n\\t */\\n\\n\\tfunction Cylindrical( radius, theta, y ) {\\n\\n\\t\\tthis.radius = ( radius !== undefined ) ? radius : 1.0; // distance from the origin to a point in the x-z plane\\n\\t\\tthis.theta = ( theta !== undefined ) ? theta : 0; // counterclockwise angle in the x-z plane measured in radians from the positive z-axis\\n\\t\\tthis.y = ( y !== undefined ) ? y : 0; // height above the x-z plane\\n\\n\\t\\treturn this;\\n\\n\\t}\\n\\n\\tObject.assign( Cylindrical.prototype, {\\n\\n\\t\\tset: function ( radius, theta, y ) {\\n\\n\\t\\t\\tthis.radius = radius;\\n\\t\\t\\tthis.theta = theta;\\n\\t\\t\\tthis.y = y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tclone: function () {\\n\\n\\t\\t\\treturn new this.constructor().copy( this );\\n\\n\\t\\t},\\n\\n\\t\\tcopy: function ( other ) {\\n\\n\\t\\t\\tthis.radius = other.radius;\\n\\t\\t\\tthis.theta = other.theta;\\n\\t\\t\\tthis.y = other.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t},\\n\\n\\t\\tsetFromVector3: function ( vec3 ) {\\n\\n\\t\\t\\tthis.radius = Math.sqrt( vec3.x * vec3.x + vec3.z * vec3.z );\\n\\t\\t\\tthis.theta = Math.atan2( vec3.x, vec3.z );\\n\\t\\t\\tthis.y = vec3.y;\\n\\n\\t\\t\\treturn this;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tfunction ImmediateRenderObject( material ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.material = material;\\n\\t\\tthis.render = function ( /* renderCallback */ ) {};\\n\\n\\t}\\n\\n\\tImmediateRenderObject.prototype = Object.create( Object3D.prototype );\\n\\tImmediateRenderObject.prototype.constructor = ImmediateRenderObject;\\n\\n\\tImmediateRenderObject.prototype.isImmediateRenderObject = true;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction VertexNormalsHelper( object, size, hex, linewidth ) {\\n\\n\\t\\tthis.object = object;\\n\\n\\t\\tthis.size = ( size !== undefined ) ? size : 1;\\n\\n\\t\\tvar color = ( hex !== undefined ) ? hex : 0xff0000;\\n\\n\\t\\tvar width = ( linewidth !== undefined ) ? linewidth : 1;\\n\\n\\t\\t//\\n\\n\\t\\tvar nNormals = 0;\\n\\n\\t\\tvar objGeometry = this.object.geometry;\\n\\n\\t\\tif ( objGeometry && objGeometry.isGeometry ) {\\n\\n\\t\\t\\tnNormals = objGeometry.faces.length * 3;\\n\\n\\t\\t} else if ( objGeometry && objGeometry.isBufferGeometry ) {\\n\\n\\t\\t\\tnNormals = objGeometry.attributes.normal.count;\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\n\\t\\tvar positions = new Float32BufferAttribute( nNormals * 2 * 3, 3 );\\n\\n\\t\\tgeometry.addAttribute( 'position', positions );\\n\\n\\t\\tLineSegments.call( this, geometry, new LineBasicMaterial( { color: color, linewidth: width } ) );\\n\\n\\t\\t//\\n\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t\\tthis.update();\\n\\n\\t}\\n\\n\\tVertexNormalsHelper.prototype = Object.create( LineSegments.prototype );\\n\\tVertexNormalsHelper.prototype.constructor = VertexNormalsHelper;\\n\\n\\tVertexNormalsHelper.prototype.update = ( function () {\\n\\n\\t\\tvar v1 = new Vector3();\\n\\t\\tvar v2 = new Vector3();\\n\\t\\tvar normalMatrix = new Matrix3();\\n\\n\\t\\treturn function update() {\\n\\n\\t\\t\\tvar keys = [ 'a', 'b', 'c' ];\\n\\n\\t\\t\\tthis.object.updateMatrixWorld( true );\\n\\n\\t\\t\\tnormalMatrix.getNormalMatrix( this.object.matrixWorld );\\n\\n\\t\\t\\tvar matrixWorld = this.object.matrixWorld;\\n\\n\\t\\t\\tvar position = this.geometry.attributes.position;\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar objGeometry = this.object.geometry;\\n\\n\\t\\t\\tif ( objGeometry && objGeometry.isGeometry ) {\\n\\n\\t\\t\\t\\tvar vertices = objGeometry.vertices;\\n\\n\\t\\t\\t\\tvar faces = objGeometry.faces;\\n\\n\\t\\t\\t\\tvar idx = 0;\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = faces.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar face = faces[ i ];\\n\\n\\t\\t\\t\\t\\tfor ( var j = 0, jl = face.vertexNormals.length; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\t\\tvar vertex = vertices[ face[ keys[ j ] ] ];\\n\\n\\t\\t\\t\\t\\t\\tvar normal = face.vertexNormals[ j ];\\n\\n\\t\\t\\t\\t\\t\\tv1.copy( vertex ).applyMatrix4( matrixWorld );\\n\\n\\t\\t\\t\\t\\t\\tv2.copy( normal ).applyMatrix3( normalMatrix ).normalize().multiplyScalar( this.size ).add( v1 );\\n\\n\\t\\t\\t\\t\\t\\tposition.setXYZ( idx, v1.x, v1.y, v1.z );\\n\\n\\t\\t\\t\\t\\t\\tidx = idx + 1;\\n\\n\\t\\t\\t\\t\\t\\tposition.setXYZ( idx, v2.x, v2.y, v2.z );\\n\\n\\t\\t\\t\\t\\t\\tidx = idx + 1;\\n\\n\\t\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t} else if ( objGeometry && objGeometry.isBufferGeometry ) {\\n\\n\\t\\t\\t\\tvar objPos = objGeometry.attributes.position;\\n\\n\\t\\t\\t\\tvar objNorm = objGeometry.attributes.normal;\\n\\n\\t\\t\\t\\tvar idx = 0;\\n\\n\\t\\t\\t\\t// for simplicity, ignore index and drawcalls, and render every normal\\n\\n\\t\\t\\t\\tfor ( var j = 0, jl = objPos.count; j < jl; j ++ ) {\\n\\n\\t\\t\\t\\t\\tv1.set( objPos.getX( j ), objPos.getY( j ), objPos.getZ( j ) ).applyMatrix4( matrixWorld );\\n\\n\\t\\t\\t\\t\\tv2.set( objNorm.getX( j ), objNorm.getY( j ), objNorm.getZ( j ) );\\n\\n\\t\\t\\t\\t\\tv2.applyMatrix3( normalMatrix ).normalize().multiplyScalar( this.size ).add( v1 );\\n\\n\\t\\t\\t\\t\\tposition.setXYZ( idx, v1.x, v1.y, v1.z );\\n\\n\\t\\t\\t\\t\\tidx = idx + 1;\\n\\n\\t\\t\\t\\t\\tposition.setXYZ( idx, v2.x, v2.y, v2.z );\\n\\n\\t\\t\\t\\t\\tidx = idx + 1;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tposition.needsUpdate = true;\\n\\n\\t\\t};\\n\\n\\t}() );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction SpotLightHelper( light, color ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.light = light;\\n\\t\\tthis.light.updateMatrixWorld();\\n\\n\\t\\tthis.matrix = light.matrixWorld;\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t\\tthis.color = color;\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\n\\t\\tvar positions = [\\n\\t\\t\\t0, 0, 0, \\t0, 0, 1,\\n\\t\\t\\t0, 0, 0, \\t1, 0, 1,\\n\\t\\t\\t0, 0, 0,\\t- 1, 0, 1,\\n\\t\\t\\t0, 0, 0, \\t0, 1, 1,\\n\\t\\t\\t0, 0, 0, \\t0, - 1, 1\\n\\t\\t];\\n\\n\\t\\tfor ( var i = 0, j = 1, l = 32; i < l; i ++, j ++ ) {\\n\\n\\t\\t\\tvar p1 = ( i / l ) * Math.PI * 2;\\n\\t\\t\\tvar p2 = ( j / l ) * Math.PI * 2;\\n\\n\\t\\t\\tpositions.push(\\n\\t\\t\\t\\tMath.cos( p1 ), Math.sin( p1 ), 1,\\n\\t\\t\\t\\tMath.cos( p2 ), Math.sin( p2 ), 1\\n\\t\\t\\t);\\n\\n\\t\\t}\\n\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );\\n\\n\\t\\tvar material = new LineBasicMaterial( { fog: false } );\\n\\n\\t\\tthis.cone = new LineSegments( geometry, material );\\n\\t\\tthis.add( this.cone );\\n\\n\\t\\tthis.update();\\n\\n\\t}\\n\\n\\tSpotLightHelper.prototype = Object.create( Object3D.prototype );\\n\\tSpotLightHelper.prototype.constructor = SpotLightHelper;\\n\\n\\tSpotLightHelper.prototype.dispose = function () {\\n\\n\\t\\tthis.cone.geometry.dispose();\\n\\t\\tthis.cone.material.dispose();\\n\\n\\t};\\n\\n\\tSpotLightHelper.prototype.update = function () {\\n\\n\\t\\tvar vector = new Vector3();\\n\\t\\tvar vector2 = new Vector3();\\n\\n\\t\\treturn function update() {\\n\\n\\t\\t\\tthis.light.updateMatrixWorld();\\n\\n\\t\\t\\tvar coneLength = this.light.distance ? this.light.distance : 1000;\\n\\t\\t\\tvar coneWidth = coneLength * Math.tan( this.light.angle );\\n\\n\\t\\t\\tthis.cone.scale.set( coneWidth, coneWidth, coneLength );\\n\\n\\t\\t\\tvector.setFromMatrixPosition( this.light.matrixWorld );\\n\\t\\t\\tvector2.setFromMatrixPosition( this.light.target.matrixWorld );\\n\\n\\t\\t\\tthis.cone.lookAt( vector2.sub( vector ) );\\n\\n\\t\\t\\tif ( this.color !== undefined ) {\\n\\n\\t\\t\\t\\tthis.cone.material.color.set( this.color );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.cone.material.color.copy( this.light.color );\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t}();\\n\\n\\t/**\\n\\t * @author Sean Griffin / http://twitter.com/sgrif\\n\\t * @author Michael Guerrero / http://realitymeltdown.com\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author ikerr / http://verold.com\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\tfunction getBoneList( object ) {\\n\\n\\t\\tvar boneList = [];\\n\\n\\t\\tif ( object && object.isBone ) {\\n\\n\\t\\t\\tboneList.push( object );\\n\\n\\t\\t}\\n\\n\\t\\tfor ( var i = 0; i < object.children.length; i ++ ) {\\n\\n\\t\\t\\tboneList.push.apply( boneList, getBoneList( object.children[ i ] ) );\\n\\n\\t\\t}\\n\\n\\t\\treturn boneList;\\n\\n\\t}\\n\\n\\tfunction SkeletonHelper( object ) {\\n\\n\\t\\tvar bones = getBoneList( object );\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\n\\t\\tvar vertices = [];\\n\\t\\tvar colors = [];\\n\\n\\t\\tvar color1 = new Color( 0, 0, 1 );\\n\\t\\tvar color2 = new Color( 0, 1, 0 );\\n\\n\\t\\tfor ( var i = 0; i < bones.length; i ++ ) {\\n\\n\\t\\t\\tvar bone = bones[ i ];\\n\\n\\t\\t\\tif ( bone.parent && bone.parent.isBone ) {\\n\\n\\t\\t\\t\\tvertices.push( 0, 0, 0 );\\n\\t\\t\\t\\tvertices.push( 0, 0, 0 );\\n\\t\\t\\t\\tcolors.push( color1.r, color1.g, color1.b );\\n\\t\\t\\t\\tcolors.push( color2.r, color2.g, color2.b );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tgeometry.addAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );\\n\\n\\t\\tvar material = new LineBasicMaterial( { vertexColors: VertexColors, depthTest: false, depthWrite: false, transparent: true } );\\n\\n\\t\\tLineSegments.call( this, geometry, material );\\n\\n\\t\\tthis.root = object;\\n\\t\\tthis.bones = bones;\\n\\n\\t\\tthis.matrix = object.matrixWorld;\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t}\\n\\n\\tSkeletonHelper.prototype = Object.create( LineSegments.prototype );\\n\\tSkeletonHelper.prototype.constructor = SkeletonHelper;\\n\\n\\tSkeletonHelper.prototype.updateMatrixWorld = function () {\\n\\n\\t\\tvar vector = new Vector3();\\n\\n\\t\\tvar boneMatrix = new Matrix4();\\n\\t\\tvar matrixWorldInv = new Matrix4();\\n\\n\\t\\treturn function updateMatrixWorld( force ) {\\n\\n\\t\\t\\tvar bones = this.bones;\\n\\n\\t\\t\\tvar geometry = this.geometry;\\n\\t\\t\\tvar position = geometry.getAttribute( 'position' );\\n\\n\\t\\t\\tmatrixWorldInv.getInverse( this.root.matrixWorld );\\n\\n\\t\\t\\tfor ( var i = 0, j = 0; i < bones.length; i ++ ) {\\n\\n\\t\\t\\t\\tvar bone = bones[ i ];\\n\\n\\t\\t\\t\\tif ( bone.parent && bone.parent.isBone ) {\\n\\n\\t\\t\\t\\t\\tboneMatrix.multiplyMatrices( matrixWorldInv, bone.matrixWorld );\\n\\t\\t\\t\\t\\tvector.setFromMatrixPosition( boneMatrix );\\n\\t\\t\\t\\t\\tposition.setXYZ( j, vector.x, vector.y, vector.z );\\n\\n\\t\\t\\t\\t\\tboneMatrix.multiplyMatrices( matrixWorldInv, bone.parent.matrixWorld );\\n\\t\\t\\t\\t\\tvector.setFromMatrixPosition( boneMatrix );\\n\\t\\t\\t\\t\\tposition.setXYZ( j + 1, vector.x, vector.y, vector.z );\\n\\n\\t\\t\\t\\t\\tj += 2;\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tgeometry.getAttribute( 'position' ).needsUpdate = true;\\n\\n\\t\\t\\tObject3D.prototype.updateMatrixWorld.call( this, force );\\n\\n\\t\\t};\\n\\n\\t}();\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction PointLightHelper( light, sphereSize, color ) {\\n\\n\\t\\tthis.light = light;\\n\\t\\tthis.light.updateMatrixWorld();\\n\\n\\t\\tthis.color = color;\\n\\n\\t\\tvar geometry = new SphereBufferGeometry( sphereSize, 4, 2 );\\n\\t\\tvar material = new MeshBasicMaterial( { wireframe: true, fog: false } );\\n\\n\\t\\tMesh.call( this, geometry, material );\\n\\n\\t\\tthis.matrix = this.light.matrixWorld;\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t\\tthis.update();\\n\\n\\n\\t\\t/*\\n\\t\\tvar distanceGeometry = new THREE.IcosahedronGeometry( 1, 2 );\\n\\t\\tvar distanceMaterial = new THREE.MeshBasicMaterial( { color: hexColor, fog: false, wireframe: true, opacity: 0.1, transparent: true } );\\n\\n\\t\\tthis.lightSphere = new THREE.Mesh( bulbGeometry, bulbMaterial );\\n\\t\\tthis.lightDistance = new THREE.Mesh( distanceGeometry, distanceMaterial );\\n\\n\\t\\tvar d = light.distance;\\n\\n\\t\\tif ( d === 0.0 ) {\\n\\n\\t\\t\\tthis.lightDistance.visible = false;\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tthis.lightDistance.scale.set( d, d, d );\\n\\n\\t\\t}\\n\\n\\t\\tthis.add( this.lightDistance );\\n\\t\\t*/\\n\\n\\t}\\n\\n\\tPointLightHelper.prototype = Object.create( Mesh.prototype );\\n\\tPointLightHelper.prototype.constructor = PointLightHelper;\\n\\n\\tPointLightHelper.prototype.dispose = function () {\\n\\n\\t\\tthis.geometry.dispose();\\n\\t\\tthis.material.dispose();\\n\\n\\t};\\n\\n\\tPointLightHelper.prototype.update = function () {\\n\\n\\t\\tif ( this.color !== undefined ) {\\n\\n\\t\\t\\tthis.material.color.set( this.color );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tthis.material.color.copy( this.light.color );\\n\\n\\t\\t}\\n\\n\\t\\t/*\\n\\t\\tvar d = this.light.distance;\\n\\n\\t\\tif ( d === 0.0 ) {\\n\\n\\t\\t\\tthis.lightDistance.visible = false;\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tthis.lightDistance.visible = true;\\n\\t\\t\\tthis.lightDistance.scale.set( d, d, d );\\n\\n\\t\\t}\\n\\t\\t*/\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author abelnation / http://github.com/abelnation\\n\\t * @author Mugen87 / http://github.com/Mugen87\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction RectAreaLightHelper( light, color ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.light = light;\\n\\t\\tthis.light.updateMatrixWorld();\\n\\n\\t\\tthis.matrix = light.matrixWorld;\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t\\tthis.color = color;\\n\\n\\t\\tvar material = new LineBasicMaterial( { fog: false } );\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\n\\t\\tgeometry.addAttribute( 'position', new BufferAttribute( new Float32Array( 5 * 3 ), 3 ) );\\n\\n\\t\\tthis.line = new Line( geometry, material );\\n\\t\\tthis.add( this.line );\\n\\n\\n\\t\\tthis.update();\\n\\n\\t}\\n\\n\\tRectAreaLightHelper.prototype = Object.create( Object3D.prototype );\\n\\tRectAreaLightHelper.prototype.constructor = RectAreaLightHelper;\\n\\n\\tRectAreaLightHelper.prototype.dispose = function () {\\n\\n\\t\\tthis.children[ 0 ].geometry.dispose();\\n\\t\\tthis.children[ 0 ].material.dispose();\\n\\n\\t};\\n\\n\\tRectAreaLightHelper.prototype.update = function () {\\n\\n\\t\\t// calculate new dimensions of the helper\\n\\n\\t\\tvar hx = this.light.width * 0.5;\\n\\t\\tvar hy = this.light.height * 0.5;\\n\\n\\t\\tvar position = this.line.geometry.attributes.position;\\n\\t\\tvar array = position.array;\\n\\n\\t\\t// update vertices\\n\\n\\t\\tarray[ 0 ] = hx; array[ 1 ] = - hy; array[ 2 ] = 0;\\n\\t\\tarray[ 3 ] = hx; array[ 4 ] = hy; array[ 5 ] = 0;\\n\\t\\tarray[ 6 ] = - hx; array[ 7 ] = hy; array[ 8 ] = 0;\\n\\t\\tarray[ 9 ] = - hx; array[ 10 ] = - hy; array[ 11 ] = 0;\\n\\t\\tarray[ 12 ] = hx; array[ 13 ] = - hy; array[ 14 ] = 0;\\n\\n\\t\\tposition.needsUpdate = true;\\n\\n\\t\\tif ( this.color !== undefined ) {\\n\\n\\t\\t\\tthis.line.material.color.set( this.color );\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tthis.line.material.color.copy( this.light.color );\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t */\\n\\n\\tfunction HemisphereLightHelper( light, size, color ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.light = light;\\n\\t\\tthis.light.updateMatrixWorld();\\n\\n\\t\\tthis.matrix = light.matrixWorld;\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t\\tthis.color = color;\\n\\n\\t\\tvar geometry = new OctahedronBufferGeometry( size );\\n\\t\\tgeometry.rotateY( Math.PI * 0.5 );\\n\\n\\t\\tthis.material = new MeshBasicMaterial( { wireframe: true, fog: false } );\\n\\t\\tif ( this.color === undefined ) this.material.vertexColors = VertexColors;\\n\\n\\t\\tvar position = geometry.getAttribute( 'position' );\\n\\t\\tvar colors = new Float32Array( position.count * 3 );\\n\\n\\t\\tgeometry.addAttribute( 'color', new BufferAttribute( colors, 3 ) );\\n\\n\\t\\tthis.add( new Mesh( geometry, this.material ) );\\n\\n\\t\\tthis.update();\\n\\n\\t}\\n\\n\\tHemisphereLightHelper.prototype = Object.create( Object3D.prototype );\\n\\tHemisphereLightHelper.prototype.constructor = HemisphereLightHelper;\\n\\n\\tHemisphereLightHelper.prototype.dispose = function () {\\n\\n\\t\\tthis.children[ 0 ].geometry.dispose();\\n\\t\\tthis.children[ 0 ].material.dispose();\\n\\n\\t};\\n\\n\\tHemisphereLightHelper.prototype.update = function () {\\n\\n\\t\\tvar vector = new Vector3();\\n\\n\\t\\tvar color1 = new Color();\\n\\t\\tvar color2 = new Color();\\n\\n\\t\\treturn function update() {\\n\\n\\t\\t\\tvar mesh = this.children[ 0 ];\\n\\n\\t\\t\\tif ( this.color !== undefined ) {\\n\\n\\t\\t\\t\\tthis.material.color.set( this.color );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tvar colors = mesh.geometry.getAttribute( 'color' );\\n\\n\\t\\t\\t\\tcolor1.copy( this.light.color );\\n\\t\\t\\t\\tcolor2.copy( this.light.groundColor );\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = colors.count; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tvar color = ( i < ( l / 2 ) ) ? color1 : color2;\\n\\n\\t\\t\\t\\t\\tcolors.setXYZ( i, color.r, color.g, color.b );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t\\tcolors.needsUpdate = true;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tmesh.lookAt( vector.setFromMatrixPosition( this.light.matrixWorld ).negate() );\\n\\n\\t\\t};\\n\\n\\t}();\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction GridHelper( size, divisions, color1, color2 ) {\\n\\n\\t\\tsize = size || 10;\\n\\t\\tdivisions = divisions || 10;\\n\\t\\tcolor1 = new Color( color1 !== undefined ? color1 : 0x444444 );\\n\\t\\tcolor2 = new Color( color2 !== undefined ? color2 : 0x888888 );\\n\\n\\t\\tvar center = divisions / 2;\\n\\t\\tvar step = size / divisions;\\n\\t\\tvar halfSize = size / 2;\\n\\n\\t\\tvar vertices = [], colors = [];\\n\\n\\t\\tfor ( var i = 0, j = 0, k = - halfSize; i <= divisions; i ++, k += step ) {\\n\\n\\t\\t\\tvertices.push( - halfSize, 0, k, halfSize, 0, k );\\n\\t\\t\\tvertices.push( k, 0, - halfSize, k, 0, halfSize );\\n\\n\\t\\t\\tvar color = i === center ? color1 : color2;\\n\\n\\t\\t\\tcolor.toArray( colors, j ); j += 3;\\n\\t\\t\\tcolor.toArray( colors, j ); j += 3;\\n\\t\\t\\tcolor.toArray( colors, j ); j += 3;\\n\\t\\t\\tcolor.toArray( colors, j ); j += 3;\\n\\n\\t\\t}\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tgeometry.addAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );\\n\\n\\t\\tvar material = new LineBasicMaterial( { vertexColors: VertexColors } );\\n\\n\\t\\tLineSegments.call( this, geometry, material );\\n\\n\\t}\\n\\n\\tGridHelper.prototype = Object.create( LineSegments.prototype );\\n\\tGridHelper.prototype.constructor = GridHelper;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Mugen87 / http://github.com/Mugen87\\n\\t * @author Hectate / http://www.github.com/Hectate\\n\\t */\\n\\n\\tfunction PolarGridHelper( radius, radials, circles, divisions, color1, color2 ) {\\n\\n\\t\\tradius = radius || 10;\\n\\t\\tradials = radials || 16;\\n\\t\\tcircles = circles || 8;\\n\\t\\tdivisions = divisions || 64;\\n\\t\\tcolor1 = new Color( color1 !== undefined ? color1 : 0x444444 );\\n\\t\\tcolor2 = new Color( color2 !== undefined ? color2 : 0x888888 );\\n\\n\\t\\tvar vertices = [];\\n\\t\\tvar colors = [];\\n\\n\\t\\tvar x, z;\\n\\t\\tvar v, i, j, r, color;\\n\\n\\t\\t// create the radials\\n\\n\\t\\tfor ( i = 0; i <= radials; i ++ ) {\\n\\n\\t\\t\\tv = ( i / radials ) * ( Math.PI * 2 );\\n\\n\\t\\t\\tx = Math.sin( v ) * radius;\\n\\t\\t\\tz = Math.cos( v ) * radius;\\n\\n\\t\\t\\tvertices.push( 0, 0, 0 );\\n\\t\\t\\tvertices.push( x, 0, z );\\n\\n\\t\\t\\tcolor = ( i & 1 ) ? color1 : color2;\\n\\n\\t\\t\\tcolors.push( color.r, color.g, color.b );\\n\\t\\t\\tcolors.push( color.r, color.g, color.b );\\n\\n\\t\\t}\\n\\n\\t\\t// create the circles\\n\\n\\t\\tfor ( i = 0; i <= circles; i ++ ) {\\n\\n\\t\\t\\tcolor = ( i & 1 ) ? color1 : color2;\\n\\n\\t\\t\\tr = radius - ( radius / circles * i );\\n\\n\\t\\t\\tfor ( j = 0; j < divisions; j ++ ) {\\n\\n\\t\\t\\t\\t// first vertex\\n\\n\\t\\t\\t\\tv = ( j / divisions ) * ( Math.PI * 2 );\\n\\n\\t\\t\\t\\tx = Math.sin( v ) * r;\\n\\t\\t\\t\\tz = Math.cos( v ) * r;\\n\\n\\t\\t\\t\\tvertices.push( x, 0, z );\\n\\t\\t\\t\\tcolors.push( color.r, color.g, color.b );\\n\\n\\t\\t\\t\\t// second vertex\\n\\n\\t\\t\\t\\tv = ( ( j + 1 ) / divisions ) * ( Math.PI * 2 );\\n\\n\\t\\t\\t\\tx = Math.sin( v ) * r;\\n\\t\\t\\t\\tz = Math.cos( v ) * r;\\n\\n\\t\\t\\t\\tvertices.push( x, 0, z );\\n\\t\\t\\t\\tcolors.push( color.r, color.g, color.b );\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tgeometry.addAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );\\n\\n\\t\\tvar material = new LineBasicMaterial( { vertexColors: VertexColors } );\\n\\n\\t\\tLineSegments.call( this, geometry, material );\\n\\n\\t}\\n\\n\\tPolarGridHelper.prototype = Object.create( LineSegments.prototype );\\n\\tPolarGridHelper.prototype.constructor = PolarGridHelper;\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction FaceNormalsHelper( object, size, hex, linewidth ) {\\n\\n\\t\\t// FaceNormalsHelper only supports THREE.Geometry\\n\\n\\t\\tthis.object = object;\\n\\n\\t\\tthis.size = ( size !== undefined ) ? size : 1;\\n\\n\\t\\tvar color = ( hex !== undefined ) ? hex : 0xffff00;\\n\\n\\t\\tvar width = ( linewidth !== undefined ) ? linewidth : 1;\\n\\n\\t\\t//\\n\\n\\t\\tvar nNormals = 0;\\n\\n\\t\\tvar objGeometry = this.object.geometry;\\n\\n\\t\\tif ( objGeometry && objGeometry.isGeometry ) {\\n\\n\\t\\t\\tnNormals = objGeometry.faces.length;\\n\\n\\t\\t} else {\\n\\n\\t\\t\\tconsole.warn( 'THREE.FaceNormalsHelper: only THREE.Geometry is supported. Use THREE.VertexNormalsHelper, instead.' );\\n\\n\\t\\t}\\n\\n\\t\\t//\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\n\\t\\tvar positions = new Float32BufferAttribute( nNormals * 2 * 3, 3 );\\n\\n\\t\\tgeometry.addAttribute( 'position', positions );\\n\\n\\t\\tLineSegments.call( this, geometry, new LineBasicMaterial( { color: color, linewidth: width } ) );\\n\\n\\t\\t//\\n\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\t\\tthis.update();\\n\\n\\t}\\n\\n\\tFaceNormalsHelper.prototype = Object.create( LineSegments.prototype );\\n\\tFaceNormalsHelper.prototype.constructor = FaceNormalsHelper;\\n\\n\\tFaceNormalsHelper.prototype.update = ( function () {\\n\\n\\t\\tvar v1 = new Vector3();\\n\\t\\tvar v2 = new Vector3();\\n\\t\\tvar normalMatrix = new Matrix3();\\n\\n\\t\\treturn function update() {\\n\\n\\t\\t\\tthis.object.updateMatrixWorld( true );\\n\\n\\t\\t\\tnormalMatrix.getNormalMatrix( this.object.matrixWorld );\\n\\n\\t\\t\\tvar matrixWorld = this.object.matrixWorld;\\n\\n\\t\\t\\tvar position = this.geometry.attributes.position;\\n\\n\\t\\t\\t//\\n\\n\\t\\t\\tvar objGeometry = this.object.geometry;\\n\\n\\t\\t\\tvar vertices = objGeometry.vertices;\\n\\n\\t\\t\\tvar faces = objGeometry.faces;\\n\\n\\t\\t\\tvar idx = 0;\\n\\n\\t\\t\\tfor ( var i = 0, l = faces.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar face = faces[ i ];\\n\\n\\t\\t\\t\\tvar normal = face.normal;\\n\\n\\t\\t\\t\\tv1.copy( vertices[ face.a ] )\\n\\t\\t\\t\\t\\t.add( vertices[ face.b ] )\\n\\t\\t\\t\\t\\t.add( vertices[ face.c ] )\\n\\t\\t\\t\\t\\t.divideScalar( 3 )\\n\\t\\t\\t\\t\\t.applyMatrix4( matrixWorld );\\n\\n\\t\\t\\t\\tv2.copy( normal ).applyMatrix3( normalMatrix ).normalize().multiplyScalar( this.size ).add( v1 );\\n\\n\\t\\t\\t\\tposition.setXYZ( idx, v1.x, v1.y, v1.z );\\n\\n\\t\\t\\t\\tidx = idx + 1;\\n\\n\\t\\t\\t\\tposition.setXYZ( idx, v2.x, v2.y, v2.z );\\n\\n\\t\\t\\t\\tidx = idx + 1;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tposition.needsUpdate = true;\\n\\n\\t\\t};\\n\\n\\t}() );\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction DirectionalLightHelper( light, size, color ) {\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tthis.light = light;\\n\\t\\tthis.light.updateMatrixWorld();\\n\\n\\t\\tthis.matrix = light.matrixWorld;\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t\\tthis.color = color;\\n\\n\\t\\tif ( size === undefined ) size = 1;\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( [\\n\\t\\t\\t- size, size, 0,\\n\\t\\t\\tsize, size, 0,\\n\\t\\t\\tsize, - size, 0,\\n\\t\\t\\t- size, - size, 0,\\n\\t\\t\\t- size, size, 0\\n\\t\\t], 3 ) );\\n\\n\\t\\tvar material = new LineBasicMaterial( { fog: false } );\\n\\n\\t\\tthis.lightPlane = new Line( geometry, material );\\n\\t\\tthis.add( this.lightPlane );\\n\\n\\t\\tgeometry = new BufferGeometry();\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( [ 0, 0, 0, 0, 0, 1 ], 3 ) );\\n\\n\\t\\tthis.targetLine = new Line( geometry, material );\\n\\t\\tthis.add( this.targetLine );\\n\\n\\t\\tthis.update();\\n\\n\\t}\\n\\n\\tDirectionalLightHelper.prototype = Object.create( Object3D.prototype );\\n\\tDirectionalLightHelper.prototype.constructor = DirectionalLightHelper;\\n\\n\\tDirectionalLightHelper.prototype.dispose = function () {\\n\\n\\t\\tthis.lightPlane.geometry.dispose();\\n\\t\\tthis.lightPlane.material.dispose();\\n\\t\\tthis.targetLine.geometry.dispose();\\n\\t\\tthis.targetLine.material.dispose();\\n\\n\\t};\\n\\n\\tDirectionalLightHelper.prototype.update = function () {\\n\\n\\t\\tvar v1 = new Vector3();\\n\\t\\tvar v2 = new Vector3();\\n\\t\\tvar v3 = new Vector3();\\n\\n\\t\\treturn function update() {\\n\\n\\t\\t\\tv1.setFromMatrixPosition( this.light.matrixWorld );\\n\\t\\t\\tv2.setFromMatrixPosition( this.light.target.matrixWorld );\\n\\t\\t\\tv3.subVectors( v2, v1 );\\n\\n\\t\\t\\tthis.lightPlane.lookAt( v3 );\\n\\n\\t\\t\\tif ( this.color !== undefined ) {\\n\\n\\t\\t\\t\\tthis.lightPlane.material.color.set( this.color );\\n\\t\\t\\t\\tthis.targetLine.material.color.set( this.color );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\tthis.lightPlane.material.color.copy( this.light.color );\\n\\t\\t\\t\\tthis.targetLine.material.color.copy( this.light.color );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tthis.targetLine.lookAt( v3 );\\n\\t\\t\\tthis.targetLine.scale.z = v3.length();\\n\\n\\t\\t};\\n\\n\\t}();\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t * @author Mugen87 / https://github.com/Mugen87\\n\\t *\\n\\t *\\t- shows frustum, line of sight and up of the camera\\n\\t *\\t- suitable for fast updates\\n\\t * \\t- based on frustum visualization in lightgl.js shadowmap example\\n\\t *\\t\\thttp://evanw.github.com/lightgl.js/tests/shadowmap.html\\n\\t */\\n\\n\\tfunction CameraHelper( camera ) {\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\t\\tvar material = new LineBasicMaterial( { color: 0xffffff, vertexColors: FaceColors } );\\n\\n\\t\\tvar vertices = [];\\n\\t\\tvar colors = [];\\n\\n\\t\\tvar pointMap = {};\\n\\n\\t\\t// colors\\n\\n\\t\\tvar colorFrustum = new Color( 0xffaa00 );\\n\\t\\tvar colorCone = new Color( 0xff0000 );\\n\\t\\tvar colorUp = new Color( 0x00aaff );\\n\\t\\tvar colorTarget = new Color( 0xffffff );\\n\\t\\tvar colorCross = new Color( 0x333333 );\\n\\n\\t\\t// near\\n\\n\\t\\taddLine( 'n1', 'n2', colorFrustum );\\n\\t\\taddLine( 'n2', 'n4', colorFrustum );\\n\\t\\taddLine( 'n4', 'n3', colorFrustum );\\n\\t\\taddLine( 'n3', 'n1', colorFrustum );\\n\\n\\t\\t// far\\n\\n\\t\\taddLine( 'f1', 'f2', colorFrustum );\\n\\t\\taddLine( 'f2', 'f4', colorFrustum );\\n\\t\\taddLine( 'f4', 'f3', colorFrustum );\\n\\t\\taddLine( 'f3', 'f1', colorFrustum );\\n\\n\\t\\t// sides\\n\\n\\t\\taddLine( 'n1', 'f1', colorFrustum );\\n\\t\\taddLine( 'n2', 'f2', colorFrustum );\\n\\t\\taddLine( 'n3', 'f3', colorFrustum );\\n\\t\\taddLine( 'n4', 'f4', colorFrustum );\\n\\n\\t\\t// cone\\n\\n\\t\\taddLine( 'p', 'n1', colorCone );\\n\\t\\taddLine( 'p', 'n2', colorCone );\\n\\t\\taddLine( 'p', 'n3', colorCone );\\n\\t\\taddLine( 'p', 'n4', colorCone );\\n\\n\\t\\t// up\\n\\n\\t\\taddLine( 'u1', 'u2', colorUp );\\n\\t\\taddLine( 'u2', 'u3', colorUp );\\n\\t\\taddLine( 'u3', 'u1', colorUp );\\n\\n\\t\\t// target\\n\\n\\t\\taddLine( 'c', 't', colorTarget );\\n\\t\\taddLine( 'p', 'c', colorCross );\\n\\n\\t\\t// cross\\n\\n\\t\\taddLine( 'cn1', 'cn2', colorCross );\\n\\t\\taddLine( 'cn3', 'cn4', colorCross );\\n\\n\\t\\taddLine( 'cf1', 'cf2', colorCross );\\n\\t\\taddLine( 'cf3', 'cf4', colorCross );\\n\\n\\t\\tfunction addLine( a, b, color ) {\\n\\n\\t\\t\\taddPoint( a, color );\\n\\t\\t\\taddPoint( b, color );\\n\\n\\t\\t}\\n\\n\\t\\tfunction addPoint( id, color ) {\\n\\n\\t\\t\\tvertices.push( 0, 0, 0 );\\n\\t\\t\\tcolors.push( color.r, color.g, color.b );\\n\\n\\t\\t\\tif ( pointMap[ id ] === undefined ) {\\n\\n\\t\\t\\t\\tpointMap[ id ] = [];\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tpointMap[ id ].push( ( vertices.length / 3 ) - 1 );\\n\\n\\t\\t}\\n\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tgeometry.addAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );\\n\\n\\t\\tLineSegments.call( this, geometry, material );\\n\\n\\t\\tthis.camera = camera;\\n\\t\\tif ( this.camera.updateProjectionMatrix ) this.camera.updateProjectionMatrix();\\n\\n\\t\\tthis.matrix = camera.matrixWorld;\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t\\tthis.pointMap = pointMap;\\n\\n\\t\\tthis.update();\\n\\n\\t}\\n\\n\\tCameraHelper.prototype = Object.create( LineSegments.prototype );\\n\\tCameraHelper.prototype.constructor = CameraHelper;\\n\\n\\tCameraHelper.prototype.update = function () {\\n\\n\\t\\tvar geometry, pointMap;\\n\\n\\t\\tvar vector = new Vector3();\\n\\t\\tvar camera = new Camera();\\n\\n\\t\\tfunction setPoint( point, x, y, z ) {\\n\\n\\t\\t\\tvector.set( x, y, z ).unproject( camera );\\n\\n\\t\\t\\tvar points = pointMap[ point ];\\n\\n\\t\\t\\tif ( points !== undefined ) {\\n\\n\\t\\t\\t\\tvar position = geometry.getAttribute( 'position' );\\n\\n\\t\\t\\t\\tfor ( var i = 0, l = points.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\t\\tposition.setXYZ( points[ i ], vector.x, vector.y, vector.z );\\n\\n\\t\\t\\t\\t}\\n\\n\\t\\t\\t}\\n\\n\\t\\t}\\n\\n\\t\\treturn function update() {\\n\\n\\t\\t\\tgeometry = this.geometry;\\n\\t\\t\\tpointMap = this.pointMap;\\n\\n\\t\\t\\tvar w = 1, h = 1;\\n\\n\\t\\t\\t// we need just camera projection matrix\\n\\t\\t\\t// world matrix must be identity\\n\\n\\t\\t\\tcamera.projectionMatrix.copy( this.camera.projectionMatrix );\\n\\n\\t\\t\\t// center / target\\n\\n\\t\\t\\tsetPoint( 'c', 0, 0, - 1 );\\n\\t\\t\\tsetPoint( 't', 0, 0, 1 );\\n\\n\\t\\t\\t// near\\n\\n\\t\\t\\tsetPoint( 'n1', - w, - h, - 1 );\\n\\t\\t\\tsetPoint( 'n2', w, - h, - 1 );\\n\\t\\t\\tsetPoint( 'n3', - w, h, - 1 );\\n\\t\\t\\tsetPoint( 'n4', w, h, - 1 );\\n\\n\\t\\t\\t// far\\n\\n\\t\\t\\tsetPoint( 'f1', - w, - h, 1 );\\n\\t\\t\\tsetPoint( 'f2', w, - h, 1 );\\n\\t\\t\\tsetPoint( 'f3', - w, h, 1 );\\n\\t\\t\\tsetPoint( 'f4', w, h, 1 );\\n\\n\\t\\t\\t// up\\n\\n\\t\\t\\tsetPoint( 'u1', w * 0.7, h * 1.1, - 1 );\\n\\t\\t\\tsetPoint( 'u2', - w * 0.7, h * 1.1, - 1 );\\n\\t\\t\\tsetPoint( 'u3', 0, h * 2, - 1 );\\n\\n\\t\\t\\t// cross\\n\\n\\t\\t\\tsetPoint( 'cf1', - w, 0, 1 );\\n\\t\\t\\tsetPoint( 'cf2', w, 0, 1 );\\n\\t\\t\\tsetPoint( 'cf3', 0, - h, 1 );\\n\\t\\t\\tsetPoint( 'cf4', 0, h, 1 );\\n\\n\\t\\t\\tsetPoint( 'cn1', - w, 0, - 1 );\\n\\t\\t\\tsetPoint( 'cn2', w, 0, - 1 );\\n\\t\\t\\tsetPoint( 'cn3', 0, - h, - 1 );\\n\\t\\t\\tsetPoint( 'cn4', 0, h, - 1 );\\n\\n\\t\\t\\tgeometry.getAttribute( 'position' ).needsUpdate = true;\\n\\n\\t\\t};\\n\\n\\t}();\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t * @author Mugen87 / http://github.com/Mugen87\\n\\t */\\n\\n\\tfunction BoxHelper( object, color ) {\\n\\n\\t\\tthis.object = object;\\n\\n\\t\\tif ( color === undefined ) color = 0xffff00;\\n\\n\\t\\tvar indices = new Uint16Array( [ 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7 ] );\\n\\t\\tvar positions = new Float32Array( 8 * 3 );\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\t\\tgeometry.setIndex( new BufferAttribute( indices, 1 ) );\\n\\t\\tgeometry.addAttribute( 'position', new BufferAttribute( positions, 3 ) );\\n\\n\\t\\tLineSegments.call( this, geometry, new LineBasicMaterial( { color: color } ) );\\n\\n\\t\\tthis.matrixAutoUpdate = false;\\n\\n\\t\\tthis.update();\\n\\n\\t}\\n\\n\\tBoxHelper.prototype = Object.create( LineSegments.prototype );\\n\\tBoxHelper.prototype.constructor = BoxHelper;\\n\\n\\tBoxHelper.prototype.update = ( function () {\\n\\n\\t\\tvar box = new Box3();\\n\\n\\t\\treturn function update( object ) {\\n\\n\\t\\t\\tif ( object !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.BoxHelper: .update() has no longer arguments.' );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( this.object !== undefined ) {\\n\\n\\t\\t\\t\\tbox.setFromObject( this.object );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tif ( box.isEmpty() ) return;\\n\\n\\t\\t\\tvar min = box.min;\\n\\t\\t\\tvar max = box.max;\\n\\n\\t\\t\\t/*\\n\\t\\t\\t  5____4\\n\\t\\t\\t1/___0/|\\n\\t\\t\\t| 6__|_7\\n\\t\\t\\t2/___3/\\n\\n\\t\\t\\t0: max.x, max.y, max.z\\n\\t\\t\\t1: min.x, max.y, max.z\\n\\t\\t\\t2: min.x, min.y, max.z\\n\\t\\t\\t3: max.x, min.y, max.z\\n\\t\\t\\t4: max.x, max.y, min.z\\n\\t\\t\\t5: min.x, max.y, min.z\\n\\t\\t\\t6: min.x, min.y, min.z\\n\\t\\t\\t7: max.x, min.y, min.z\\n\\t\\t\\t*/\\n\\n\\t\\t\\tvar position = this.geometry.attributes.position;\\n\\t\\t\\tvar array = position.array;\\n\\n\\t\\t\\tarray[ 0 ] = max.x; array[ 1 ] = max.y; array[ 2 ] = max.z;\\n\\t\\t\\tarray[ 3 ] = min.x; array[ 4 ] = max.y; array[ 5 ] = max.z;\\n\\t\\t\\tarray[ 6 ] = min.x; array[ 7 ] = min.y; array[ 8 ] = max.z;\\n\\t\\t\\tarray[ 9 ] = max.x; array[ 10 ] = min.y; array[ 11 ] = max.z;\\n\\t\\t\\tarray[ 12 ] = max.x; array[ 13 ] = max.y; array[ 14 ] = min.z;\\n\\t\\t\\tarray[ 15 ] = min.x; array[ 16 ] = max.y; array[ 17 ] = min.z;\\n\\t\\t\\tarray[ 18 ] = min.x; array[ 19 ] = min.y; array[ 20 ] = min.z;\\n\\t\\t\\tarray[ 21 ] = max.x; array[ 22 ] = min.y; array[ 23 ] = min.z;\\n\\n\\t\\t\\tposition.needsUpdate = true;\\n\\n\\t\\t\\tthis.geometry.computeBoundingSphere();\\n\\n\\t\\t};\\n\\n\\t} )();\\n\\n\\tBoxHelper.prototype.setFromObject = function ( object ) {\\n\\n\\t\\tthis.object = object;\\n\\t\\tthis.update();\\n\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction Box3Helper( box, hex ) {\\n\\n\\t\\tthis.type = 'Box3Helper';\\n\\n\\t\\tthis.box = box;\\n\\n\\t\\tvar color = ( hex !== undefined ) ? hex : 0xffff00;\\n\\n\\t\\tvar indices = new Uint16Array( [ 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7 ] );\\n\\n\\t\\tvar positions = [ 1, 1, 1, - 1, 1, 1, - 1, - 1, 1, 1, - 1, 1, 1, 1, - 1, - 1, 1, - 1, - 1, - 1, - 1, 1, - 1, - 1 ];\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\n\\t\\tgeometry.setIndex( new BufferAttribute( indices, 1 ) );\\n\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );\\n\\n\\t\\tLineSegments.call( this, geometry, new LineBasicMaterial( { color: color } ) );\\n\\n\\t\\tthis.geometry.computeBoundingSphere();\\n\\n\\t}\\n\\n\\tBox3Helper.prototype = Object.create( LineSegments.prototype );\\n\\tBox3Helper.prototype.constructor = Box3Helper;\\n\\n\\tBox3Helper.prototype.updateMatrixWorld = function ( force ) {\\n\\n\\t\\tvar box = this.box;\\n\\n\\t\\tif ( box.isEmpty() ) return;\\n\\n\\t\\tbox.getCenter( this.position );\\n\\n\\t\\tbox.getSize( this.scale );\\n\\n\\t\\tthis.scale.multiplyScalar( 0.5 );\\n\\n\\t\\tObject3D.prototype.updateMatrixWorld.call( this, force );\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t */\\n\\n\\tfunction PlaneHelper( plane, size, hex ) {\\n\\n\\t\\tthis.type = 'PlaneHelper';\\n\\n\\t\\tthis.plane = plane;\\n\\n\\t\\tthis.size = ( size === undefined ) ? 1 : size;\\n\\n\\t\\tvar color = ( hex !== undefined ) ? hex : 0xffff00;\\n\\n\\t\\tvar positions = [ 1, - 1, 1, - 1, 1, 1, - 1, - 1, 1, 1, 1, 1, - 1, 1, 1, - 1, - 1, 1, 1, - 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0 ];\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( positions, 3 ) );\\n\\t\\tgeometry.computeBoundingSphere();\\n\\n\\t\\tLine.call( this, geometry, new LineBasicMaterial( { color: color } ) );\\n\\n\\t\\t//\\n\\n\\t\\tvar positions2 = [ 1, 1, 1, - 1, 1, 1, - 1, - 1, 1, 1, 1, 1, - 1, - 1, 1, 1, - 1, 1 ];\\n\\n\\t\\tvar geometry2 = new BufferGeometry();\\n\\t\\tgeometry2.addAttribute( 'position', new Float32BufferAttribute( positions2, 3 ) );\\n\\t\\tgeometry2.computeBoundingSphere();\\n\\n\\t\\tthis.add( new Mesh( geometry2, new MeshBasicMaterial( { color: color, opacity: 0.2, transparent: true, depthWrite: false } ) ) );\\n\\n\\t}\\n\\n\\tPlaneHelper.prototype = Object.create( Line.prototype );\\n\\tPlaneHelper.prototype.constructor = PlaneHelper;\\n\\n\\tPlaneHelper.prototype.updateMatrixWorld = function ( force ) {\\n\\n\\t\\tvar scale = - this.plane.constant;\\n\\n\\t\\tif ( Math.abs( scale ) < 1e-8 ) scale = 1e-8; // sign does not matter\\n\\n\\t\\tthis.scale.set( 0.5 * this.size, 0.5 * this.size, scale );\\n\\n\\t\\tthis.lookAt( this.plane.normal );\\n\\n\\t\\tObject3D.prototype.updateMatrixWorld.call( this, force );\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author WestLangley / http://github.com/WestLangley\\n\\t * @author zz85 / http://github.com/zz85\\n\\t * @author bhouston / http://clara.io\\n\\t *\\n\\t * Creates an arrow for visualizing directions\\n\\t *\\n\\t * Parameters:\\n\\t *  dir - Vector3\\n\\t *  origin - Vector3\\n\\t *  length - Number\\n\\t *  color - color in hex value\\n\\t *  headLength - Number\\n\\t *  headWidth - Number\\n\\t */\\n\\n\\tvar lineGeometry;\\n\\tvar coneGeometry;\\n\\n\\tfunction ArrowHelper( dir, origin, length, color, headLength, headWidth ) {\\n\\n\\t\\t// dir is assumed to be normalized\\n\\n\\t\\tObject3D.call( this );\\n\\n\\t\\tif ( color === undefined ) color = 0xffff00;\\n\\t\\tif ( length === undefined ) length = 1;\\n\\t\\tif ( headLength === undefined ) headLength = 0.2 * length;\\n\\t\\tif ( headWidth === undefined ) headWidth = 0.2 * headLength;\\n\\n\\t\\tif ( lineGeometry === undefined ) {\\n\\n\\t\\t\\tlineGeometry = new BufferGeometry();\\n\\t\\t\\tlineGeometry.addAttribute( 'position', new Float32BufferAttribute( [ 0, 0, 0, 0, 1, 0 ], 3 ) );\\n\\n\\t\\t\\tconeGeometry = new CylinderBufferGeometry( 0, 0.5, 1, 5, 1 );\\n\\t\\t\\tconeGeometry.translate( 0, - 0.5, 0 );\\n\\n\\t\\t}\\n\\n\\t\\tthis.position.copy( origin );\\n\\n\\t\\tthis.line = new Line( lineGeometry, new LineBasicMaterial( { color: color } ) );\\n\\t\\tthis.line.matrixAutoUpdate = false;\\n\\t\\tthis.add( this.line );\\n\\n\\t\\tthis.cone = new Mesh( coneGeometry, new MeshBasicMaterial( { color: color } ) );\\n\\t\\tthis.cone.matrixAutoUpdate = false;\\n\\t\\tthis.add( this.cone );\\n\\n\\t\\tthis.setDirection( dir );\\n\\t\\tthis.setLength( length, headLength, headWidth );\\n\\n\\t}\\n\\n\\tArrowHelper.prototype = Object.create( Object3D.prototype );\\n\\tArrowHelper.prototype.constructor = ArrowHelper;\\n\\n\\tArrowHelper.prototype.setDirection = ( function () {\\n\\n\\t\\tvar axis = new Vector3();\\n\\t\\tvar radians;\\n\\n\\t\\treturn function setDirection( dir ) {\\n\\n\\t\\t\\t// dir is assumed to be normalized\\n\\n\\t\\t\\tif ( dir.y > 0.99999 ) {\\n\\n\\t\\t\\t\\tthis.quaternion.set( 0, 0, 0, 1 );\\n\\n\\t\\t\\t} else if ( dir.y < - 0.99999 ) {\\n\\n\\t\\t\\t\\tthis.quaternion.set( 1, 0, 0, 0 );\\n\\n\\t\\t\\t} else {\\n\\n\\t\\t\\t\\taxis.set( dir.z, 0, - dir.x ).normalize();\\n\\n\\t\\t\\t\\tradians = Math.acos( dir.y );\\n\\n\\t\\t\\t\\tthis.quaternion.setFromAxisAngle( axis, radians );\\n\\n\\t\\t\\t}\\n\\n\\t\\t};\\n\\n\\t}() );\\n\\n\\tArrowHelper.prototype.setLength = function ( length, headLength, headWidth ) {\\n\\n\\t\\tif ( headLength === undefined ) headLength = 0.2 * length;\\n\\t\\tif ( headWidth === undefined ) headWidth = 0.2 * headLength;\\n\\n\\t\\tthis.line.scale.set( 1, Math.max( 0, length - headLength ), 1 );\\n\\t\\tthis.line.updateMatrix();\\n\\n\\t\\tthis.cone.scale.set( headWidth, headLength, headWidth );\\n\\t\\tthis.cone.position.y = length;\\n\\t\\tthis.cone.updateMatrix();\\n\\n\\t};\\n\\n\\tArrowHelper.prototype.setColor = function ( color ) {\\n\\n\\t\\tthis.line.material.color.copy( color );\\n\\t\\tthis.cone.material.color.copy( color );\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author sroucheray / http://sroucheray.org/\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction AxesHelper( size ) {\\n\\n\\t\\tsize = size || 1;\\n\\n\\t\\tvar vertices = [\\n\\t\\t\\t0, 0, 0,\\tsize, 0, 0,\\n\\t\\t\\t0, 0, 0,\\t0, size, 0,\\n\\t\\t\\t0, 0, 0,\\t0, 0, size\\n\\t\\t];\\n\\n\\t\\tvar colors = [\\n\\t\\t\\t1, 0, 0,\\t1, 0.6, 0,\\n\\t\\t\\t0, 1, 0,\\t0.6, 1, 0,\\n\\t\\t\\t0, 0, 1,\\t0, 0.6, 1\\n\\t\\t];\\n\\n\\t\\tvar geometry = new BufferGeometry();\\n\\t\\tgeometry.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );\\n\\t\\tgeometry.addAttribute( 'color', new Float32BufferAttribute( colors, 3 ) );\\n\\n\\t\\tvar material = new LineBasicMaterial( { vertexColors: VertexColors } );\\n\\n\\t\\tLineSegments.call( this, geometry, material );\\n\\n\\t}\\n\\n\\tAxesHelper.prototype = Object.create( LineSegments.prototype );\\n\\tAxesHelper.prototype.constructor = AxesHelper;\\n\\n\\t/**\\n\\t * @author alteredq / http://alteredqualia.com/\\n\\t */\\n\\n\\tvar SceneUtils = {\\n\\n\\t\\tcreateMultiMaterialObject: function ( geometry, materials ) {\\n\\n\\t\\t\\tvar group = new Group();\\n\\n\\t\\t\\tfor ( var i = 0, l = materials.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tgroup.add( new Mesh( geometry, materials[ i ] ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn group;\\n\\n\\t\\t},\\n\\n\\t\\tdetach: function ( child, parent, scene ) {\\n\\n\\t\\t\\tchild.applyMatrix( parent.matrixWorld );\\n\\t\\t\\tparent.remove( child );\\n\\t\\t\\tscene.add( child );\\n\\n\\t\\t},\\n\\n\\t\\tattach: function ( child, scene, parent ) {\\n\\n\\t\\t\\tchild.applyMatrix( new Matrix4().getInverse( parent.matrixWorld ) );\\n\\n\\t\\t\\tscene.remove( child );\\n\\t\\t\\tparent.add( child );\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t/**\\n\\t * @author mrdoob / http://mrdoob.com/\\n\\t */\\n\\n\\tfunction Face4( a, b, c, d, normal, color, materialIndex ) {\\n\\n\\t\\tconsole.warn( 'THREE.Face4 has been removed. A THREE.Face3 will be created instead.' );\\n\\t\\treturn new Face3( a, b, c, normal, color, materialIndex );\\n\\n\\t}\\n\\n\\tvar LineStrip = 0;\\n\\n\\tvar LinePieces = 1;\\n\\n\\tfunction MeshFaceMaterial( materials ) {\\n\\n\\t\\tconsole.warn( 'THREE.MeshFaceMaterial has been removed. Use an Array instead.' );\\n\\t\\treturn materials;\\n\\n\\t}\\n\\n\\tfunction MultiMaterial( materials ) {\\n\\n\\t\\tif ( materials === undefined ) materials = [];\\n\\n\\t\\tconsole.warn( 'THREE.MultiMaterial has been removed. Use an Array instead.' );\\n\\t\\tmaterials.isMultiMaterial = true;\\n\\t\\tmaterials.materials = materials;\\n\\t\\tmaterials.clone = function () {\\n\\n\\t\\t\\treturn materials.slice();\\n\\n\\t\\t};\\n\\t\\treturn materials;\\n\\n\\t}\\n\\n\\tfunction PointCloud( geometry, material ) {\\n\\n\\t\\tconsole.warn( 'THREE.PointCloud has been renamed to THREE.Points.' );\\n\\t\\treturn new Points( geometry, material );\\n\\n\\t}\\n\\n\\tfunction Particle( material ) {\\n\\n\\t\\tconsole.warn( 'THREE.Particle has been renamed to THREE.Sprite.' );\\n\\t\\treturn new Sprite( material );\\n\\n\\t}\\n\\n\\tfunction ParticleSystem( geometry, material ) {\\n\\n\\t\\tconsole.warn( 'THREE.ParticleSystem has been renamed to THREE.Points.' );\\n\\t\\treturn new Points( geometry, material );\\n\\n\\t}\\n\\n\\tfunction PointCloudMaterial( parameters ) {\\n\\n\\t\\tconsole.warn( 'THREE.PointCloudMaterial has been renamed to THREE.PointsMaterial.' );\\n\\t\\treturn new PointsMaterial( parameters );\\n\\n\\t}\\n\\n\\tfunction ParticleBasicMaterial( parameters ) {\\n\\n\\t\\tconsole.warn( 'THREE.ParticleBasicMaterial has been renamed to THREE.PointsMaterial.' );\\n\\t\\treturn new PointsMaterial( parameters );\\n\\n\\t}\\n\\n\\tfunction ParticleSystemMaterial( parameters ) {\\n\\n\\t\\tconsole.warn( 'THREE.ParticleSystemMaterial has been renamed to THREE.PointsMaterial.' );\\n\\t\\treturn new PointsMaterial( parameters );\\n\\n\\t}\\n\\n\\tfunction Vertex( x, y, z ) {\\n\\n\\t\\tconsole.warn( 'THREE.Vertex has been removed. Use THREE.Vector3 instead.' );\\n\\t\\treturn new Vector3( x, y, z );\\n\\n\\t}\\n\\n\\t//\\n\\n\\tfunction DynamicBufferAttribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.DynamicBufferAttribute has been removed. Use new THREE.BufferAttribute().setDynamic( true ) instead.' );\\n\\t\\treturn new BufferAttribute( array, itemSize ).setDynamic( true );\\n\\n\\t}\\n\\n\\tfunction Int8Attribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Int8Attribute has been removed. Use new THREE.Int8BufferAttribute() instead.' );\\n\\t\\treturn new Int8BufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\tfunction Uint8Attribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Uint8Attribute has been removed. Use new THREE.Uint8BufferAttribute() instead.' );\\n\\t\\treturn new Uint8BufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\tfunction Uint8ClampedAttribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Uint8ClampedAttribute has been removed. Use new THREE.Uint8ClampedBufferAttribute() instead.' );\\n\\t\\treturn new Uint8ClampedBufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\tfunction Int16Attribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Int16Attribute has been removed. Use new THREE.Int16BufferAttribute() instead.' );\\n\\t\\treturn new Int16BufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\tfunction Uint16Attribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Uint16Attribute has been removed. Use new THREE.Uint16BufferAttribute() instead.' );\\n\\t\\treturn new Uint16BufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\tfunction Int32Attribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Int32Attribute has been removed. Use new THREE.Int32BufferAttribute() instead.' );\\n\\t\\treturn new Int32BufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\tfunction Uint32Attribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Uint32Attribute has been removed. Use new THREE.Uint32BufferAttribute() instead.' );\\n\\t\\treturn new Uint32BufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\tfunction Float32Attribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Float32Attribute has been removed. Use new THREE.Float32BufferAttribute() instead.' );\\n\\t\\treturn new Float32BufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\tfunction Float64Attribute( array, itemSize ) {\\n\\n\\t\\tconsole.warn( 'THREE.Float64Attribute has been removed. Use new THREE.Float64BufferAttribute() instead.' );\\n\\t\\treturn new Float64BufferAttribute( array, itemSize );\\n\\n\\t}\\n\\n\\t//\\n\\n\\tCurve.create = function ( construct, getPoint ) {\\n\\n\\t\\tconsole.log( 'THREE.Curve.create() has been deprecated' );\\n\\n\\t\\tconstruct.prototype = Object.create( Curve.prototype );\\n\\t\\tconstruct.prototype.constructor = construct;\\n\\t\\tconstruct.prototype.getPoint = getPoint;\\n\\n\\t\\treturn construct;\\n\\n\\t};\\n\\n\\t//\\n\\n\\tObject.assign( CurvePath.prototype, {\\n\\n\\t\\tcreatePointsGeometry: function ( divisions ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.CurvePath: .createPointsGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.' );\\n\\n\\t\\t\\t// generate geometry from path points (for Line or Points objects)\\n\\n\\t\\t\\tvar pts = this.getPoints( divisions );\\n\\t\\t\\treturn this.createGeometry( pts );\\n\\n\\t\\t},\\n\\n\\t\\tcreateSpacedPointsGeometry: function ( divisions ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.CurvePath: .createSpacedPointsGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.' );\\n\\n\\t\\t\\t// generate geometry from equidistant sampling along the path\\n\\n\\t\\t\\tvar pts = this.getSpacedPoints( divisions );\\n\\t\\t\\treturn this.createGeometry( pts );\\n\\n\\t\\t},\\n\\n\\t\\tcreateGeometry: function ( points ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.CurvePath: .createGeometry() has been removed. Use new THREE.Geometry().setFromPoints( points ) instead.' );\\n\\n\\t\\t\\tvar geometry = new Geometry();\\n\\n\\t\\t\\tfor ( var i = 0, l = points.length; i < l; i ++ ) {\\n\\n\\t\\t\\t\\tvar point = points[ i ];\\n\\t\\t\\t\\tgeometry.vertices.push( new Vector3( point.x, point.y, point.z || 0 ) );\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\treturn geometry;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tObject.assign( Path.prototype, {\\n\\n\\t\\tfromPoints: function ( points ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Path: .fromPoints() has been renamed to .setFromPoints().' );\\n\\t\\t\\tthis.setFromPoints( points );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tfunction ClosedSplineCurve3( points ) {\\n\\n\\t\\tconsole.warn( 'THREE.ClosedSplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead.' );\\n\\n\\t\\tCatmullRomCurve3.call( this, points );\\n\\t\\tthis.type = 'catmullrom';\\n\\t\\tthis.closed = true;\\n\\n\\t}\\n\\n\\tClosedSplineCurve3.prototype = Object.create( CatmullRomCurve3.prototype );\\n\\n\\t//\\n\\n\\tfunction SplineCurve3( points ) {\\n\\n\\t\\tconsole.warn( 'THREE.SplineCurve3 has been deprecated. Use THREE.CatmullRomCurve3 instead.' );\\n\\n\\t\\tCatmullRomCurve3.call( this, points );\\n\\t\\tthis.type = 'catmullrom';\\n\\n\\t}\\n\\n\\tSplineCurve3.prototype = Object.create( CatmullRomCurve3.prototype );\\n\\n\\t//\\n\\n\\tfunction Spline( points ) {\\n\\n\\t\\tconsole.warn( 'THREE.Spline has been removed. Use THREE.CatmullRomCurve3 instead.' );\\n\\n\\t\\tCatmullRomCurve3.call( this, points );\\n\\t\\tthis.type = 'catmullrom';\\n\\n\\t}\\n\\n\\tSpline.prototype = Object.create( CatmullRomCurve3.prototype );\\n\\n\\tObject.assign( Spline.prototype, {\\n\\n\\t\\tinitFromArray: function ( /* a */ ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Spline: .initFromArray() has been removed.' );\\n\\n\\t\\t},\\n\\t\\tgetControlPointsArray: function ( /* optionalTarget */ ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Spline: .getControlPointsArray() has been removed.' );\\n\\n\\t\\t},\\n\\t\\treparametrizeByArcLength: function ( /* samplingCoef */ ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Spline: .reparametrizeByArcLength() has been removed.' );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tfunction AxisHelper( size ) {\\n\\n\\t\\tconsole.warn( 'THREE.AxisHelper has been renamed to THREE.AxesHelper.' );\\n\\t\\treturn new AxesHelper( size );\\n\\n\\t}\\n\\n\\tfunction BoundingBoxHelper( object, color ) {\\n\\n\\t\\tconsole.warn( 'THREE.BoundingBoxHelper has been deprecated. Creating a THREE.BoxHelper instead.' );\\n\\t\\treturn new BoxHelper( object, color );\\n\\n\\t}\\n\\n\\tfunction EdgesHelper( object, hex ) {\\n\\n\\t\\tconsole.warn( 'THREE.EdgesHelper has been removed. Use THREE.EdgesGeometry instead.' );\\n\\t\\treturn new LineSegments( new EdgesGeometry( object.geometry ), new LineBasicMaterial( { color: hex !== undefined ? hex : 0xffffff } ) );\\n\\n\\t}\\n\\n\\tGridHelper.prototype.setColors = function () {\\n\\n\\t\\tconsole.error( 'THREE.GridHelper: setColors() has been deprecated, pass them in the constructor instead.' );\\n\\n\\t};\\n\\n\\tSkeletonHelper.prototype.update = function () {\\n\\n\\t\\tconsole.error( 'THREE.SkeletonHelper: update() no longer needs to be called.' );\\n\\n\\t};\\n\\n\\tfunction WireframeHelper( object, hex ) {\\n\\n\\t\\tconsole.warn( 'THREE.WireframeHelper has been removed. Use THREE.WireframeGeometry instead.' );\\n\\t\\treturn new LineSegments( new WireframeGeometry( object.geometry ), new LineBasicMaterial( { color: hex !== undefined ? hex : 0xffffff } ) );\\n\\n\\t}\\n\\n\\t//\\n\\n\\tObject.assign( Loader.prototype, {\\n\\n\\t\\textractUrlBase: function ( url ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Loader: .extractUrlBase() has been deprecated. Use THREE.LoaderUtils.extractUrlBase() instead.' );\\n\\t\\t\\treturn LoaderUtils.extractUrlBase( url );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tfunction XHRLoader( manager ) {\\n\\n\\t\\tconsole.warn( 'THREE.XHRLoader has been renamed to THREE.FileLoader.' );\\n\\t\\treturn new FileLoader( manager );\\n\\n\\t}\\n\\n\\tfunction BinaryTextureLoader( manager ) {\\n\\n\\t\\tconsole.warn( 'THREE.BinaryTextureLoader has been renamed to THREE.DataTextureLoader.' );\\n\\t\\treturn new DataTextureLoader( manager );\\n\\n\\t}\\n\\n\\t//\\n\\n\\tObject.assign( Box2.prototype, {\\n\\n\\t\\tcenter: function ( optionalTarget ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box2: .center() has been renamed to .getCenter().' );\\n\\t\\t\\treturn this.getCenter( optionalTarget );\\n\\n\\t\\t},\\n\\t\\tempty: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box2: .empty() has been renamed to .isEmpty().' );\\n\\t\\t\\treturn this.isEmpty();\\n\\n\\t\\t},\\n\\t\\tisIntersectionBox: function ( box ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox().' );\\n\\t\\t\\treturn this.intersectsBox( box );\\n\\n\\t\\t},\\n\\t\\tsize: function ( optionalTarget ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box2: .size() has been renamed to .getSize().' );\\n\\t\\t\\treturn this.getSize( optionalTarget );\\n\\n\\t\\t}\\n\\t} );\\n\\n\\tObject.assign( Box3.prototype, {\\n\\n\\t\\tcenter: function ( optionalTarget ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box3: .center() has been renamed to .getCenter().' );\\n\\t\\t\\treturn this.getCenter( optionalTarget );\\n\\n\\t\\t},\\n\\t\\tempty: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box3: .empty() has been renamed to .isEmpty().' );\\n\\t\\t\\treturn this.isEmpty();\\n\\n\\t\\t},\\n\\t\\tisIntersectionBox: function ( box ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox().' );\\n\\t\\t\\treturn this.intersectsBox( box );\\n\\n\\t\\t},\\n\\t\\tisIntersectionSphere: function ( sphere ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere().' );\\n\\t\\t\\treturn this.intersectsSphere( sphere );\\n\\n\\t\\t},\\n\\t\\tsize: function ( optionalTarget ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Box3: .size() has been renamed to .getSize().' );\\n\\t\\t\\treturn this.getSize( optionalTarget );\\n\\n\\t\\t}\\n\\t} );\\n\\n\\tLine3.prototype.center = function ( optionalTarget ) {\\n\\n\\t\\tconsole.warn( 'THREE.Line3: .center() has been renamed to .getCenter().' );\\n\\t\\treturn this.getCenter( optionalTarget );\\n\\n\\t};\\n\\n\\tObject.assign( _Math, {\\n\\n\\t\\trandom16: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Math: .random16() has been deprecated. Use Math.random() instead.' );\\n\\t\\t\\treturn Math.random();\\n\\n\\t\\t},\\n\\n\\t\\tnearestPowerOfTwo: function ( value ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Math: .nearestPowerOfTwo() has been renamed to .floorPowerOfTwo().' );\\n\\t\\t\\treturn _Math.floorPowerOfTwo( value );\\n\\n\\t\\t},\\n\\n\\t\\tnextPowerOfTwo: function ( value ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Math: .nextPowerOfTwo() has been renamed to .ceilPowerOfTwo().' );\\n\\t\\t\\treturn _Math.ceilPowerOfTwo( value );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Matrix3.prototype, {\\n\\n\\t\\tflattenToArrayOffset: function ( array, offset ) {\\n\\n\\t\\t\\tconsole.warn( \\\"THREE.Matrix3: .flattenToArrayOffset() has been deprecated. Use .toArray() instead.\\\" );\\n\\t\\t\\treturn this.toArray( array, offset );\\n\\n\\t\\t},\\n\\t\\tmultiplyVector3: function ( vector ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead.' );\\n\\t\\t\\treturn vector.applyMatrix3( this );\\n\\n\\t\\t},\\n\\t\\tmultiplyVector3Array: function ( /* a */ ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix3: .multiplyVector3Array() has been removed.' );\\n\\n\\t\\t},\\n\\t\\tapplyToBuffer: function ( buffer /*, offset, length */ ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix3: .applyToBuffer() has been removed. Use matrix.applyToBufferAttribute( attribute ) instead.' );\\n\\t\\t\\treturn this.applyToBufferAttribute( buffer );\\n\\n\\t\\t},\\n\\t\\tapplyToVector3Array: function ( /* array, offset, length */ ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix3: .applyToVector3Array() has been removed.' );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Matrix4.prototype, {\\n\\n\\t\\textractPosition: function ( m ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .extractPosition() has been renamed to .copyPosition().' );\\n\\t\\t\\treturn this.copyPosition( m );\\n\\n\\t\\t},\\n\\t\\tflattenToArrayOffset: function ( array, offset ) {\\n\\n\\t\\t\\tconsole.warn( \\\"THREE.Matrix4: .flattenToArrayOffset() has been deprecated. Use .toArray() instead.\\\" );\\n\\t\\t\\treturn this.toArray( array, offset );\\n\\n\\t\\t},\\n\\t\\tgetPosition: function () {\\n\\n\\t\\t\\tvar v1;\\n\\n\\t\\t\\treturn function getPosition() {\\n\\n\\t\\t\\t\\tif ( v1 === undefined ) v1 = new Vector3();\\n\\t\\t\\t\\tconsole.warn( 'THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead.' );\\n\\t\\t\\t\\treturn v1.setFromMatrixColumn( this, 3 );\\n\\n\\t\\t\\t};\\n\\n\\t\\t}(),\\n\\t\\tsetRotationFromQuaternion: function ( q ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion().' );\\n\\t\\t\\treturn this.makeRotationFromQuaternion( q );\\n\\n\\t\\t},\\n\\t\\tmultiplyToArray: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .multiplyToArray() has been removed.' );\\n\\n\\t\\t},\\n\\t\\tmultiplyVector3: function ( vector ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) instead.' );\\n\\t\\t\\treturn vector.applyMatrix4( this );\\n\\n\\t\\t},\\n\\t\\tmultiplyVector4: function ( vector ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead.' );\\n\\t\\t\\treturn vector.applyMatrix4( this );\\n\\n\\t\\t},\\n\\t\\tmultiplyVector3Array: function ( /* a */ ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix4: .multiplyVector3Array() has been removed.' );\\n\\n\\t\\t},\\n\\t\\trotateAxis: function ( v ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead.' );\\n\\t\\t\\tv.transformDirection( this );\\n\\n\\t\\t},\\n\\t\\tcrossVector: function ( vector ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead.' );\\n\\t\\t\\treturn vector.applyMatrix4( this );\\n\\n\\t\\t},\\n\\t\\ttranslate: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix4: .translate() has been removed.' );\\n\\n\\t\\t},\\n\\t\\trotateX: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix4: .rotateX() has been removed.' );\\n\\n\\t\\t},\\n\\t\\trotateY: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix4: .rotateY() has been removed.' );\\n\\n\\t\\t},\\n\\t\\trotateZ: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix4: .rotateZ() has been removed.' );\\n\\n\\t\\t},\\n\\t\\trotateByAxis: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix4: .rotateByAxis() has been removed.' );\\n\\n\\t\\t},\\n\\t\\tapplyToBuffer: function ( buffer /*, offset, length */ ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .applyToBuffer() has been removed. Use matrix.applyToBufferAttribute( attribute ) instead.' );\\n\\t\\t\\treturn this.applyToBufferAttribute( buffer );\\n\\n\\t\\t},\\n\\t\\tapplyToVector3Array: function ( /* array, offset, length */ ) {\\n\\n\\t\\t\\tconsole.error( 'THREE.Matrix4: .applyToVector3Array() has been removed.' );\\n\\n\\t\\t},\\n\\t\\tmakeFrustum: function ( left, right, bottom, top, near, far ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Matrix4: .makeFrustum() has been removed. Use .makePerspective( left, right, top, bottom, near, far ) instead.' );\\n\\t\\t\\treturn this.makePerspective( left, right, top, bottom, near, far );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tPlane.prototype.isIntersectionLine = function ( line ) {\\n\\n\\t\\tconsole.warn( 'THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine().' );\\n\\t\\treturn this.intersectsLine( line );\\n\\n\\t};\\n\\n\\tQuaternion.prototype.multiplyVector3 = function ( vector ) {\\n\\n\\t\\tconsole.warn( 'THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead.' );\\n\\t\\treturn vector.applyQuaternion( this );\\n\\n\\t};\\n\\n\\tObject.assign( Ray.prototype, {\\n\\n\\t\\tisIntersectionBox: function ( box ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox().' );\\n\\t\\t\\treturn this.intersectsBox( box );\\n\\n\\t\\t},\\n\\t\\tisIntersectionPlane: function ( plane ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane().' );\\n\\t\\t\\treturn this.intersectsPlane( plane );\\n\\n\\t\\t},\\n\\t\\tisIntersectionSphere: function ( sphere ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere().' );\\n\\t\\t\\treturn this.intersectsSphere( sphere );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Shape.prototype, {\\n\\n\\t\\textractAllPoints: function ( divisions ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Shape: .extractAllPoints() has been removed. Use .extractPoints() instead.' );\\n\\t\\t\\treturn this.extractPoints( divisions );\\n\\n\\t\\t},\\n\\t\\textrude: function ( options ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Shape: .extrude() has been removed. Use ExtrudeGeometry() instead.' );\\n\\t\\t\\treturn new ExtrudeGeometry( this, options );\\n\\n\\t\\t},\\n\\t\\tmakeGeometry: function ( options ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Shape: .makeGeometry() has been removed. Use ShapeGeometry() instead.' );\\n\\t\\t\\treturn new ShapeGeometry( this, options );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Vector2.prototype, {\\n\\n\\t\\tfromAttribute: function ( attribute, index, offset ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector2: .fromAttribute() has been renamed to .fromBufferAttribute().' );\\n\\t\\t\\treturn this.fromBufferAttribute( attribute, index, offset );\\n\\n\\t\\t},\\n\\t\\tdistanceToManhattan: function ( v ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector2: .distanceToManhattan() has been renamed to .manhattanDistanceTo().' );\\n\\t\\t\\treturn this.manhattanDistanceTo( v );\\n\\n\\t\\t},\\n\\t\\tlengthManhattan: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector2: .lengthManhattan() has been renamed to .manhattanLength().' );\\n\\t\\t\\treturn this.manhattanLength();\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Vector3.prototype, {\\n\\n\\t\\tsetEulerFromRotationMatrix: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.' );\\n\\n\\t\\t},\\n\\t\\tsetEulerFromQuaternion: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.' );\\n\\n\\t\\t},\\n\\t\\tgetPositionFromMatrix: function ( m ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition().' );\\n\\t\\t\\treturn this.setFromMatrixPosition( m );\\n\\n\\t\\t},\\n\\t\\tgetScaleFromMatrix: function ( m ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale().' );\\n\\t\\t\\treturn this.setFromMatrixScale( m );\\n\\n\\t\\t},\\n\\t\\tgetColumnFromMatrix: function ( index, matrix ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn().' );\\n\\t\\t\\treturn this.setFromMatrixColumn( matrix, index );\\n\\n\\t\\t},\\n\\t\\tapplyProjection: function ( m ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector3: .applyProjection() has been removed. Use .applyMatrix4( m ) instead.' );\\n\\t\\t\\treturn this.applyMatrix4( m );\\n\\n\\t\\t},\\n\\t\\tfromAttribute: function ( attribute, index, offset ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector3: .fromAttribute() has been renamed to .fromBufferAttribute().' );\\n\\t\\t\\treturn this.fromBufferAttribute( attribute, index, offset );\\n\\n\\t\\t},\\n\\t\\tdistanceToManhattan: function ( v ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector3: .distanceToManhattan() has been renamed to .manhattanDistanceTo().' );\\n\\t\\t\\treturn this.manhattanDistanceTo( v );\\n\\n\\t\\t},\\n\\t\\tlengthManhattan: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector3: .lengthManhattan() has been renamed to .manhattanLength().' );\\n\\t\\t\\treturn this.manhattanLength();\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( Vector4.prototype, {\\n\\n\\t\\tfromAttribute: function ( attribute, index, offset ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector4: .fromAttribute() has been renamed to .fromBufferAttribute().' );\\n\\t\\t\\treturn this.fromBufferAttribute( attribute, index, offset );\\n\\n\\t\\t},\\n\\t\\tlengthManhattan: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Vector4: .lengthManhattan() has been renamed to .manhattanLength().' );\\n\\t\\t\\treturn this.manhattanLength();\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tGeometry.prototype.computeTangents = function () {\\n\\n\\t\\tconsole.warn( 'THREE.Geometry: .computeTangents() has been removed.' );\\n\\n\\t};\\n\\n\\tObject.assign( Object3D.prototype, {\\n\\n\\t\\tgetChildByName: function ( name ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Object3D: .getChildByName() has been renamed to .getObjectByName().' );\\n\\t\\t\\treturn this.getObjectByName( name );\\n\\n\\t\\t},\\n\\t\\trenderDepth: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.' );\\n\\n\\t\\t},\\n\\t\\ttranslate: function ( distance, axis ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead.' );\\n\\t\\t\\treturn this.translateOnAxis( axis, distance );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperties( Object3D.prototype, {\\n\\n\\t\\teulerOrder: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Object3D: .eulerOrder is now .rotation.order.' );\\n\\t\\t\\t\\treturn this.rotation.order;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Object3D: .eulerOrder is now .rotation.order.' );\\n\\t\\t\\t\\tthis.rotation.order = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tuseQuaternion: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.' );\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.' );\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperties( LOD.prototype, {\\n\\n\\t\\tobjects: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.LOD: .objects has been renamed to .levels.' );\\n\\t\\t\\t\\treturn this.levels;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperty( Skeleton.prototype, 'useVertexTexture', {\\n\\n\\t\\tget: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Skeleton: useVertexTexture has been removed.' );\\n\\n\\t\\t},\\n\\t\\tset: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Skeleton: useVertexTexture has been removed.' );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperty( Curve.prototype, '__arcLengthDivisions', {\\n\\n\\t\\tget: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.' );\\n\\t\\t\\treturn this.arcLengthDivisions;\\n\\n\\t\\t},\\n\\t\\tset: function ( value ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Curve: .__arcLengthDivisions is now .arcLengthDivisions.' );\\n\\t\\t\\tthis.arcLengthDivisions = value;\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tPerspectiveCamera.prototype.setLens = function ( focalLength, filmGauge ) {\\n\\n\\t\\tconsole.warn( \\\"THREE.PerspectiveCamera.setLens is deprecated. \\\" +\\n\\t\\t\\t\\t\\\"Use .setFocalLength and .filmGauge for a photographic setup.\\\" );\\n\\n\\t\\tif ( filmGauge !== undefined ) this.filmGauge = filmGauge;\\n\\t\\tthis.setFocalLength( focalLength );\\n\\n\\t};\\n\\n\\t//\\n\\n\\tObject.defineProperties( Light.prototype, {\\n\\t\\tonlyShadow: {\\n\\t\\t\\tset: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .onlyShadow has been removed.' );\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowCameraFov: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowCameraFov is now .shadow.camera.fov.' );\\n\\t\\t\\t\\tthis.shadow.camera.fov = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowCameraLeft: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowCameraLeft is now .shadow.camera.left.' );\\n\\t\\t\\t\\tthis.shadow.camera.left = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowCameraRight: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowCameraRight is now .shadow.camera.right.' );\\n\\t\\t\\t\\tthis.shadow.camera.right = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowCameraTop: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowCameraTop is now .shadow.camera.top.' );\\n\\t\\t\\t\\tthis.shadow.camera.top = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowCameraBottom: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom.' );\\n\\t\\t\\t\\tthis.shadow.camera.bottom = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowCameraNear: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowCameraNear is now .shadow.camera.near.' );\\n\\t\\t\\t\\tthis.shadow.camera.near = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowCameraFar: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowCameraFar is now .shadow.camera.far.' );\\n\\t\\t\\t\\tthis.shadow.camera.far = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowCameraVisible: {\\n\\t\\t\\tset: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.' );\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowBias: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowBias is now .shadow.bias.' );\\n\\t\\t\\t\\tthis.shadow.bias = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowDarkness: {\\n\\t\\t\\tset: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowDarkness has been removed.' );\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowMapWidth: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowMapWidth is now .shadow.mapSize.width.' );\\n\\t\\t\\t\\tthis.shadow.mapSize.width = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowMapHeight: {\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Light: .shadowMapHeight is now .shadow.mapSize.height.' );\\n\\t\\t\\t\\tthis.shadow.mapSize.height = value;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\t} );\\n\\n\\t//\\n\\n\\tObject.defineProperties( BufferAttribute.prototype, {\\n\\n\\t\\tlength: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.BufferAttribute: .length has been deprecated. Use .count instead.' );\\n\\t\\t\\t\\treturn this.array.length;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.assign( BufferGeometry.prototype, {\\n\\n\\t\\taddIndex: function ( index ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.BufferGeometry: .addIndex() has been renamed to .setIndex().' );\\n\\t\\t\\tthis.setIndex( index );\\n\\n\\t\\t},\\n\\t\\taddDrawCall: function ( start, count, indexOffset ) {\\n\\n\\t\\t\\tif ( indexOffset !== undefined ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset.' );\\n\\n\\t\\t\\t}\\n\\t\\t\\tconsole.warn( 'THREE.BufferGeometry: .addDrawCall() is now .addGroup().' );\\n\\t\\t\\tthis.addGroup( start, count );\\n\\n\\t\\t},\\n\\t\\tclearDrawCalls: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups().' );\\n\\t\\t\\tthis.clearGroups();\\n\\n\\t\\t},\\n\\t\\tcomputeTangents: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.BufferGeometry: .computeTangents() has been removed.' );\\n\\n\\t\\t},\\n\\t\\tcomputeOffsets: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.BufferGeometry: .computeOffsets() has been removed.' );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperties( BufferGeometry.prototype, {\\n\\n\\t\\tdrawcalls: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.BufferGeometry: .drawcalls has been renamed to .groups.' );\\n\\t\\t\\t\\treturn this.groups;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\toffsets: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.BufferGeometry: .offsets has been renamed to .groups.' );\\n\\t\\t\\t\\treturn this.groups;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tObject.defineProperties( Uniform.prototype, {\\n\\n\\t\\tdynamic: {\\n\\t\\t\\tset: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Uniform: .dynamic has been removed. Use object.onBeforeRender() instead.' );\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tonUpdate: {\\n\\t\\t\\tvalue: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Uniform: .onUpdate() has been removed. Use object.onBeforeRender() instead.' );\\n\\t\\t\\t\\treturn this;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tObject.defineProperties( Material.prototype, {\\n\\n\\t\\twrapAround: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Material: .wrapAround has been removed.' );\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Material: .wrapAround has been removed.' );\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\twrapRGB: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.Material: .wrapRGB has been removed.' );\\n\\t\\t\\t\\treturn new Color();\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\n\\t\\tshading: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.error( 'THREE.' + this.type + ': .shading has been removed. Use the boolean .flatShading instead.' );\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.' + this.type + ': .shading has been removed. Use the boolean .flatShading instead.' );\\n\\t\\t\\t\\tthis.flatShading = ( value === FlatShading );\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperties( MeshPhongMaterial.prototype, {\\n\\n\\t\\tmetal: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead.' );\\n\\t\\t\\t\\treturn false;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead' );\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperties( ShaderMaterial.prototype, {\\n\\n\\t\\tderivatives: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives.' );\\n\\t\\t\\t\\treturn this.extensions.derivatives;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives.' );\\n\\t\\t\\t\\tthis.extensions.derivatives = value;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tObject.assign( WebGLRenderer.prototype, {\\n\\n\\t\\tgetCurrentRenderTarget: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget().' );\\n\\t\\t\\treturn this.getRenderTarget();\\n\\n\\t\\t},\\n\\n\\t\\tgetMaxAnisotropy: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .getMaxAnisotropy() is now .capabilities.getMaxAnisotropy().' );\\n\\t\\t\\treturn this.capabilities.getMaxAnisotropy();\\n\\n\\t\\t},\\n\\n\\t\\tgetPrecision: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .getPrecision() is now .capabilities.precision.' );\\n\\t\\t\\treturn this.capabilities.precision;\\n\\n\\t\\t},\\n\\n\\t\\tresetGLState: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .resetGLState() is now .state.reset().' );\\n\\t\\t\\treturn this.state.reset();\\n\\n\\t\\t},\\n\\n\\t\\tsupportsFloatTextures: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( \\\\'OES_texture_float\\\\' ).' );\\n\\t\\t\\treturn this.extensions.get( 'OES_texture_float' );\\n\\n\\t\\t},\\n\\t\\tsupportsHalfFloatTextures: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( \\\\'OES_texture_half_float\\\\' ).' );\\n\\t\\t\\treturn this.extensions.get( 'OES_texture_half_float' );\\n\\n\\t\\t},\\n\\t\\tsupportsStandardDerivatives: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( \\\\'OES_standard_derivatives\\\\' ).' );\\n\\t\\t\\treturn this.extensions.get( 'OES_standard_derivatives' );\\n\\n\\t\\t},\\n\\t\\tsupportsCompressedTextureS3TC: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( \\\\'WEBGL_compressed_texture_s3tc\\\\' ).' );\\n\\t\\t\\treturn this.extensions.get( 'WEBGL_compressed_texture_s3tc' );\\n\\n\\t\\t},\\n\\t\\tsupportsCompressedTexturePVRTC: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( \\\\'WEBGL_compressed_texture_pvrtc\\\\' ).' );\\n\\t\\t\\treturn this.extensions.get( 'WEBGL_compressed_texture_pvrtc' );\\n\\n\\t\\t},\\n\\t\\tsupportsBlendMinMax: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( \\\\'EXT_blend_minmax\\\\' ).' );\\n\\t\\t\\treturn this.extensions.get( 'EXT_blend_minmax' );\\n\\n\\t\\t},\\n\\t\\tsupportsVertexTextures: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .supportsVertexTextures() is now .capabilities.vertexTextures.' );\\n\\t\\t\\treturn this.capabilities.vertexTextures;\\n\\n\\t\\t},\\n\\t\\tsupportsInstancedArrays: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( \\\\'ANGLE_instanced_arrays\\\\' ).' );\\n\\t\\t\\treturn this.extensions.get( 'ANGLE_instanced_arrays' );\\n\\n\\t\\t},\\n\\t\\tenableScissorTest: function ( boolean ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest().' );\\n\\t\\t\\tthis.setScissorTest( boolean );\\n\\n\\t\\t},\\n\\t\\tinitMaterial: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .initMaterial() has been removed.' );\\n\\n\\t\\t},\\n\\t\\taddPrePlugin: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .addPrePlugin() has been removed.' );\\n\\n\\t\\t},\\n\\t\\taddPostPlugin: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .addPostPlugin() has been removed.' );\\n\\n\\t\\t},\\n\\t\\tupdateShadowMap: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .updateShadowMap() has been removed.' );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperties( WebGLRenderer.prototype, {\\n\\n\\t\\tshadowMapEnabled: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.shadowMap.enabled;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled.' );\\n\\t\\t\\t\\tthis.shadowMap.enabled = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowMapType: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.shadowMap.type;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type.' );\\n\\t\\t\\t\\tthis.shadowMap.type = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tshadowMapCullFace: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.shadowMap.cullFace;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderer: .shadowMapCullFace is now .shadowMap.cullFace.' );\\n\\t\\t\\t\\tthis.shadowMap.cullFace = value;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\t} );\\n\\n\\tObject.defineProperties( WebGLShadowMap.prototype, {\\n\\n\\t\\tcullFace: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\treturn this.renderReverseSided ? CullFaceFront : CullFaceBack;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( cullFace ) {\\n\\n\\t\\t\\t\\tvar value = ( cullFace !== CullFaceBack );\\n\\t\\t\\t\\tconsole.warn( \\\"WebGLRenderer: .shadowMap.cullFace is deprecated. Set .shadowMap.renderReverseSided to \\\" + value + \\\".\\\" );\\n\\t\\t\\t\\tthis.renderReverseSided = value;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tObject.defineProperties( WebGLRenderTarget.prototype, {\\n\\n\\t\\twrapS: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.' );\\n\\t\\t\\t\\treturn this.texture.wrapS;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.' );\\n\\t\\t\\t\\tthis.texture.wrapS = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\twrapT: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.' );\\n\\t\\t\\t\\treturn this.texture.wrapT;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.' );\\n\\t\\t\\t\\tthis.texture.wrapT = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tmagFilter: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.' );\\n\\t\\t\\t\\treturn this.texture.magFilter;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.' );\\n\\t\\t\\t\\tthis.texture.magFilter = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tminFilter: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.' );\\n\\t\\t\\t\\treturn this.texture.minFilter;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.' );\\n\\t\\t\\t\\tthis.texture.minFilter = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tanisotropy: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.' );\\n\\t\\t\\t\\treturn this.texture.anisotropy;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.' );\\n\\t\\t\\t\\tthis.texture.anisotropy = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\toffset: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .offset is now .texture.offset.' );\\n\\t\\t\\t\\treturn this.texture.offset;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .offset is now .texture.offset.' );\\n\\t\\t\\t\\tthis.texture.offset = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\trepeat: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .repeat is now .texture.repeat.' );\\n\\t\\t\\t\\treturn this.texture.repeat;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .repeat is now .texture.repeat.' );\\n\\t\\t\\t\\tthis.texture.repeat = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tformat: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .format is now .texture.format.' );\\n\\t\\t\\t\\treturn this.texture.format;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .format is now .texture.format.' );\\n\\t\\t\\t\\tthis.texture.format = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\ttype: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .type is now .texture.type.' );\\n\\t\\t\\t\\treturn this.texture.type;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .type is now .texture.type.' );\\n\\t\\t\\t\\tthis.texture.type = value;\\n\\n\\t\\t\\t}\\n\\t\\t},\\n\\t\\tgenerateMipmaps: {\\n\\t\\t\\tget: function () {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.' );\\n\\t\\t\\t\\treturn this.texture.generateMipmaps;\\n\\n\\t\\t\\t},\\n\\t\\t\\tset: function ( value ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.' );\\n\\t\\t\\t\\tthis.texture.generateMipmaps = value;\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tObject.assign( WebVRManager.prototype, {\\n\\n\\t\\tgetStandingMatrix: function () {\\n\\n\\t\\t\\tconsole.warn( 'THREE.WebVRManager: .getStandingMatrix() has been removed.' );\\n\\n\\t\\t}\\n\\n\\t} );\\n\\n\\tObject.defineProperties( WebVRManager.prototype, {\\n\\n\\t\\tstanding: {\\n\\t\\t\\tset: function ( /* value */ ) {\\n\\n\\t\\t\\t\\tconsole.warn( 'THREE.WebVRManager: .standing has been removed.' );\\n\\n\\t\\t\\t}\\n\\t\\t}\\n\\n\\t} );\\n\\n\\t//\\n\\n\\tAudio.prototype.load = function ( file ) {\\n\\n\\t\\tconsole.warn( 'THREE.Audio: .load has been deprecated. Use THREE.AudioLoader instead.' );\\n\\t\\tvar scope = this;\\n\\t\\tvar audioLoader = new AudioLoader();\\n\\t\\taudioLoader.load( file, function ( buffer ) {\\n\\n\\t\\t\\tscope.setBuffer( buffer );\\n\\n\\t\\t} );\\n\\t\\treturn this;\\n\\n\\t};\\n\\n\\tAudioAnalyser.prototype.getData = function () {\\n\\n\\t\\tconsole.warn( 'THREE.AudioAnalyser: .getData() is now .getFrequencyData().' );\\n\\t\\treturn this.getFrequencyData();\\n\\n\\t};\\n\\n\\t//\\n\\n\\tCubeCamera.prototype.updateCubeMap = function ( renderer, scene ) {\\n\\n\\t\\tconsole.warn( 'THREE.CubeCamera: .updateCubeMap() is now .update().' );\\n\\t\\treturn this.update( renderer, scene );\\n\\n\\t};\\n\\n\\t//\\n\\n\\tvar GeometryUtils = {\\n\\n\\t\\tmerge: function ( geometry1, geometry2, materialIndexOffset ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.GeometryUtils: .merge() has been moved to Geometry. Use geometry.merge( geometry2, matrix, materialIndexOffset ) instead.' );\\n\\t\\t\\tvar matrix;\\n\\n\\t\\t\\tif ( geometry2.isMesh ) {\\n\\n\\t\\t\\t\\tgeometry2.matrixAutoUpdate && geometry2.updateMatrix();\\n\\n\\t\\t\\t\\tmatrix = geometry2.matrix;\\n\\t\\t\\t\\tgeometry2 = geometry2.geometry;\\n\\n\\t\\t\\t}\\n\\n\\t\\t\\tgeometry1.merge( geometry2, matrix, materialIndexOffset );\\n\\n\\t\\t},\\n\\n\\t\\tcenter: function ( geometry ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.GeometryUtils: .center() has been moved to Geometry. Use geometry.center() instead.' );\\n\\t\\t\\treturn geometry.center();\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\tvar ImageUtils = {\\n\\n\\t\\tcrossOrigin: undefined,\\n\\n\\t\\tloadTexture: function ( url, mapping, onLoad, onError ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.' );\\n\\n\\t\\t\\tvar loader = new TextureLoader();\\n\\t\\t\\tloader.setCrossOrigin( this.crossOrigin );\\n\\n\\t\\t\\tvar texture = loader.load( url, onLoad, undefined, onError );\\n\\n\\t\\t\\tif ( mapping ) texture.mapping = mapping;\\n\\n\\t\\t\\treturn texture;\\n\\n\\t\\t},\\n\\n\\t\\tloadTextureCube: function ( urls, mapping, onLoad, onError ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.' );\\n\\n\\t\\t\\tvar loader = new CubeTextureLoader();\\n\\t\\t\\tloader.setCrossOrigin( this.crossOrigin );\\n\\n\\t\\t\\tvar texture = loader.load( urls, onLoad, undefined, onError );\\n\\n\\t\\t\\tif ( mapping ) texture.mapping = mapping;\\n\\n\\t\\t\\treturn texture;\\n\\n\\t\\t},\\n\\n\\t\\tloadCompressedTexture: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.' );\\n\\n\\t\\t},\\n\\n\\t\\tloadCompressedTextureCube: function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.' );\\n\\n\\t\\t}\\n\\n\\t};\\n\\n\\t//\\n\\n\\tfunction Projector() {\\n\\n\\t\\tconsole.error( 'THREE.Projector has been moved to /examples/js/renderers/Projector.js.' );\\n\\n\\t\\tthis.projectVector = function ( vector, camera ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Projector: .projectVector() is now vector.project().' );\\n\\t\\t\\tvector.project( camera );\\n\\n\\t\\t};\\n\\n\\t\\tthis.unprojectVector = function ( vector, camera ) {\\n\\n\\t\\t\\tconsole.warn( 'THREE.Projector: .unprojectVector() is now vector.unproject().' );\\n\\t\\t\\tvector.unproject( camera );\\n\\n\\t\\t};\\n\\n\\t\\tthis.pickingRay = function () {\\n\\n\\t\\t\\tconsole.error( 'THREE.Projector: .pickingRay() is now raycaster.setFromCamera().' );\\n\\n\\t\\t};\\n\\n\\t}\\n\\n\\t//\\n\\n\\tfunction CanvasRenderer() {\\n\\n\\t\\tconsole.error( 'THREE.CanvasRenderer has been moved to /examples/js/renderers/CanvasRenderer.js' );\\n\\n\\t\\tthis.domElement = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' );\\n\\t\\tthis.clear = function () {};\\n\\t\\tthis.render = function () {};\\n\\t\\tthis.setClearColor = function () {};\\n\\t\\tthis.setSize = function () {};\\n\\n\\t}\\n\\n\\texports.WebGLRenderTargetCube = WebGLRenderTargetCube;\\n\\texports.WebGLRenderTarget = WebGLRenderTarget;\\n\\texports.WebGLRenderer = WebGLRenderer;\\n\\texports.ShaderLib = ShaderLib;\\n\\texports.UniformsLib = UniformsLib;\\n\\texports.UniformsUtils = UniformsUtils;\\n\\texports.ShaderChunk = ShaderChunk;\\n\\texports.FogExp2 = FogExp2;\\n\\texports.Fog = Fog;\\n\\texports.Scene = Scene;\\n\\texports.LensFlare = LensFlare;\\n\\texports.Sprite = Sprite;\\n\\texports.LOD = LOD;\\n\\texports.SkinnedMesh = SkinnedMesh;\\n\\texports.Skeleton = Skeleton;\\n\\texports.Bone = Bone;\\n\\texports.Mesh = Mesh;\\n\\texports.LineSegments = LineSegments;\\n\\texports.LineLoop = LineLoop;\\n\\texports.Line = Line;\\n\\texports.Points = Points;\\n\\texports.Group = Group;\\n\\texports.VideoTexture = VideoTexture;\\n\\texports.DataTexture = DataTexture;\\n\\texports.CompressedTexture = CompressedTexture;\\n\\texports.CubeTexture = CubeTexture;\\n\\texports.CanvasTexture = CanvasTexture;\\n\\texports.DepthTexture = DepthTexture;\\n\\texports.Texture = Texture;\\n\\texports.CompressedTextureLoader = CompressedTextureLoader;\\n\\texports.DataTextureLoader = DataTextureLoader;\\n\\texports.CubeTextureLoader = CubeTextureLoader;\\n\\texports.TextureLoader = TextureLoader;\\n\\texports.ObjectLoader = ObjectLoader;\\n\\texports.MaterialLoader = MaterialLoader;\\n\\texports.BufferGeometryLoader = BufferGeometryLoader;\\n\\texports.DefaultLoadingManager = DefaultLoadingManager;\\n\\texports.LoadingManager = LoadingManager;\\n\\texports.JSONLoader = JSONLoader;\\n\\texports.ImageLoader = ImageLoader;\\n\\texports.ImageBitmapLoader = ImageBitmapLoader;\\n\\texports.FontLoader = FontLoader;\\n\\texports.FileLoader = FileLoader;\\n\\texports.Loader = Loader;\\n\\texports.LoaderUtils = LoaderUtils;\\n\\texports.Cache = Cache;\\n\\texports.AudioLoader = AudioLoader;\\n\\texports.SpotLightShadow = SpotLightShadow;\\n\\texports.SpotLight = SpotLight;\\n\\texports.PointLight = PointLight;\\n\\texports.RectAreaLight = RectAreaLight;\\n\\texports.HemisphereLight = HemisphereLight;\\n\\texports.DirectionalLightShadow = DirectionalLightShadow;\\n\\texports.DirectionalLight = DirectionalLight;\\n\\texports.AmbientLight = AmbientLight;\\n\\texports.LightShadow = LightShadow;\\n\\texports.Light = Light;\\n\\texports.StereoCamera = StereoCamera;\\n\\texports.PerspectiveCamera = PerspectiveCamera;\\n\\texports.OrthographicCamera = OrthographicCamera;\\n\\texports.CubeCamera = CubeCamera;\\n\\texports.ArrayCamera = ArrayCamera;\\n\\texports.Camera = Camera;\\n\\texports.AudioListener = AudioListener;\\n\\texports.PositionalAudio = PositionalAudio;\\n\\texports.AudioContext = AudioContext;\\n\\texports.AudioAnalyser = AudioAnalyser;\\n\\texports.Audio = Audio;\\n\\texports.VectorKeyframeTrack = VectorKeyframeTrack;\\n\\texports.StringKeyframeTrack = StringKeyframeTrack;\\n\\texports.QuaternionKeyframeTrack = QuaternionKeyframeTrack;\\n\\texports.NumberKeyframeTrack = NumberKeyframeTrack;\\n\\texports.ColorKeyframeTrack = ColorKeyframeTrack;\\n\\texports.BooleanKeyframeTrack = BooleanKeyframeTrack;\\n\\texports.PropertyMixer = PropertyMixer;\\n\\texports.PropertyBinding = PropertyBinding;\\n\\texports.KeyframeTrack = KeyframeTrack;\\n\\texports.AnimationUtils = AnimationUtils;\\n\\texports.AnimationObjectGroup = AnimationObjectGroup;\\n\\texports.AnimationMixer = AnimationMixer;\\n\\texports.AnimationClip = AnimationClip;\\n\\texports.Uniform = Uniform;\\n\\texports.InstancedBufferGeometry = InstancedBufferGeometry;\\n\\texports.BufferGeometry = BufferGeometry;\\n\\texports.Geometry = Geometry;\\n\\texports.InterleavedBufferAttribute = InterleavedBufferAttribute;\\n\\texports.InstancedInterleavedBuffer = InstancedInterleavedBuffer;\\n\\texports.InterleavedBuffer = InterleavedBuffer;\\n\\texports.InstancedBufferAttribute = InstancedBufferAttribute;\\n\\texports.Face3 = Face3;\\n\\texports.Object3D = Object3D;\\n\\texports.Raycaster = Raycaster;\\n\\texports.Layers = Layers;\\n\\texports.EventDispatcher = EventDispatcher;\\n\\texports.Clock = Clock;\\n\\texports.QuaternionLinearInterpolant = QuaternionLinearInterpolant;\\n\\texports.LinearInterpolant = LinearInterpolant;\\n\\texports.DiscreteInterpolant = DiscreteInterpolant;\\n\\texports.CubicInterpolant = CubicInterpolant;\\n\\texports.Interpolant = Interpolant;\\n\\texports.Triangle = Triangle;\\n\\texports.Math = _Math;\\n\\texports.Spherical = Spherical;\\n\\texports.Cylindrical = Cylindrical;\\n\\texports.Plane = Plane;\\n\\texports.Frustum = Frustum;\\n\\texports.Sphere = Sphere;\\n\\texports.Ray = Ray;\\n\\texports.Matrix4 = Matrix4;\\n\\texports.Matrix3 = Matrix3;\\n\\texports.Box3 = Box3;\\n\\texports.Box2 = Box2;\\n\\texports.Line3 = Line3;\\n\\texports.Euler = Euler;\\n\\texports.Vector4 = Vector4;\\n\\texports.Vector3 = Vector3;\\n\\texports.Vector2 = Vector2;\\n\\texports.Quaternion = Quaternion;\\n\\texports.Color = Color;\\n\\texports.ImmediateRenderObject = ImmediateRenderObject;\\n\\texports.VertexNormalsHelper = VertexNormalsHelper;\\n\\texports.SpotLightHelper = SpotLightHelper;\\n\\texports.SkeletonHelper = SkeletonHelper;\\n\\texports.PointLightHelper = PointLightHelper;\\n\\texports.RectAreaLightHelper = RectAreaLightHelper;\\n\\texports.HemisphereLightHelper = HemisphereLightHelper;\\n\\texports.GridHelper = GridHelper;\\n\\texports.PolarGridHelper = PolarGridHelper;\\n\\texports.FaceNormalsHelper = FaceNormalsHelper;\\n\\texports.DirectionalLightHelper = DirectionalLightHelper;\\n\\texports.CameraHelper = CameraHelper;\\n\\texports.BoxHelper = BoxHelper;\\n\\texports.Box3Helper = Box3Helper;\\n\\texports.PlaneHelper = PlaneHelper;\\n\\texports.ArrowHelper = ArrowHelper;\\n\\texports.AxesHelper = AxesHelper;\\n\\texports.Shape = Shape;\\n\\texports.Path = Path;\\n\\texports.ShapePath = ShapePath;\\n\\texports.Font = Font;\\n\\texports.CurvePath = CurvePath;\\n\\texports.Curve = Curve;\\n\\texports.ShapeUtils = ShapeUtils;\\n\\texports.SceneUtils = SceneUtils;\\n\\texports.WebGLUtils = WebGLUtils;\\n\\texports.WireframeGeometry = WireframeGeometry;\\n\\texports.ParametricGeometry = ParametricGeometry;\\n\\texports.ParametricBufferGeometry = ParametricBufferGeometry;\\n\\texports.TetrahedronGeometry = TetrahedronGeometry;\\n\\texports.TetrahedronBufferGeometry = TetrahedronBufferGeometry;\\n\\texports.OctahedronGeometry = OctahedronGeometry;\\n\\texports.OctahedronBufferGeometry = OctahedronBufferGeometry;\\n\\texports.IcosahedronGeometry = IcosahedronGeometry;\\n\\texports.IcosahedronBufferGeometry = IcosahedronBufferGeometry;\\n\\texports.DodecahedronGeometry = DodecahedronGeometry;\\n\\texports.DodecahedronBufferGeometry = DodecahedronBufferGeometry;\\n\\texports.PolyhedronGeometry = PolyhedronGeometry;\\n\\texports.PolyhedronBufferGeometry = PolyhedronBufferGeometry;\\n\\texports.TubeGeometry = TubeGeometry;\\n\\texports.TubeBufferGeometry = TubeBufferGeometry;\\n\\texports.TorusKnotGeometry = TorusKnotGeometry;\\n\\texports.TorusKnotBufferGeometry = TorusKnotBufferGeometry;\\n\\texports.TorusGeometry = TorusGeometry;\\n\\texports.TorusBufferGeometry = TorusBufferGeometry;\\n\\texports.TextGeometry = TextGeometry;\\n\\texports.TextBufferGeometry = TextBufferGeometry;\\n\\texports.SphereGeometry = SphereGeometry;\\n\\texports.SphereBufferGeometry = SphereBufferGeometry;\\n\\texports.RingGeometry = RingGeometry;\\n\\texports.RingBufferGeometry = RingBufferGeometry;\\n\\texports.PlaneGeometry = PlaneGeometry;\\n\\texports.PlaneBufferGeometry = PlaneBufferGeometry;\\n\\texports.LatheGeometry = LatheGeometry;\\n\\texports.LatheBufferGeometry = LatheBufferGeometry;\\n\\texports.ShapeGeometry = ShapeGeometry;\\n\\texports.ShapeBufferGeometry = ShapeBufferGeometry;\\n\\texports.ExtrudeGeometry = ExtrudeGeometry;\\n\\texports.ExtrudeBufferGeometry = ExtrudeBufferGeometry;\\n\\texports.EdgesGeometry = EdgesGeometry;\\n\\texports.ConeGeometry = ConeGeometry;\\n\\texports.ConeBufferGeometry = ConeBufferGeometry;\\n\\texports.CylinderGeometry = CylinderGeometry;\\n\\texports.CylinderBufferGeometry = CylinderBufferGeometry;\\n\\texports.CircleGeometry = CircleGeometry;\\n\\texports.CircleBufferGeometry = CircleBufferGeometry;\\n\\texports.BoxGeometry = BoxGeometry;\\n\\texports.BoxBufferGeometry = BoxBufferGeometry;\\n\\texports.ShadowMaterial = ShadowMaterial;\\n\\texports.SpriteMaterial = SpriteMaterial;\\n\\texports.RawShaderMaterial = RawShaderMaterial;\\n\\texports.ShaderMaterial = ShaderMaterial;\\n\\texports.PointsMaterial = PointsMaterial;\\n\\texports.MeshPhysicalMaterial = MeshPhysicalMaterial;\\n\\texports.MeshStandardMaterial = MeshStandardMaterial;\\n\\texports.MeshPhongMaterial = MeshPhongMaterial;\\n\\texports.MeshToonMaterial = MeshToonMaterial;\\n\\texports.MeshNormalMaterial = MeshNormalMaterial;\\n\\texports.MeshLambertMaterial = MeshLambertMaterial;\\n\\texports.MeshDepthMaterial = MeshDepthMaterial;\\n\\texports.MeshDistanceMaterial = MeshDistanceMaterial;\\n\\texports.MeshBasicMaterial = MeshBasicMaterial;\\n\\texports.LineDashedMaterial = LineDashedMaterial;\\n\\texports.LineBasicMaterial = LineBasicMaterial;\\n\\texports.Material = Material;\\n\\texports.Float64BufferAttribute = Float64BufferAttribute;\\n\\texports.Float32BufferAttribute = Float32BufferAttribute;\\n\\texports.Uint32BufferAttribute = Uint32BufferAttribute;\\n\\texports.Int32BufferAttribute = Int32BufferAttribute;\\n\\texports.Uint16BufferAttribute = Uint16BufferAttribute;\\n\\texports.Int16BufferAttribute = Int16BufferAttribute;\\n\\texports.Uint8ClampedBufferAttribute = Uint8ClampedBufferAttribute;\\n\\texports.Uint8BufferAttribute = Uint8BufferAttribute;\\n\\texports.Int8BufferAttribute = Int8BufferAttribute;\\n\\texports.BufferAttribute = BufferAttribute;\\n\\texports.ArcCurve = ArcCurve;\\n\\texports.CatmullRomCurve3 = CatmullRomCurve3;\\n\\texports.CubicBezierCurve = CubicBezierCurve;\\n\\texports.CubicBezierCurve3 = CubicBezierCurve3;\\n\\texports.EllipseCurve = EllipseCurve;\\n\\texports.LineCurve = LineCurve;\\n\\texports.LineCurve3 = LineCurve3;\\n\\texports.QuadraticBezierCurve = QuadraticBezierCurve;\\n\\texports.QuadraticBezierCurve3 = QuadraticBezierCurve3;\\n\\texports.SplineCurve = SplineCurve;\\n\\texports.REVISION = REVISION;\\n\\texports.MOUSE = MOUSE;\\n\\texports.CullFaceNone = CullFaceNone;\\n\\texports.CullFaceBack = CullFaceBack;\\n\\texports.CullFaceFront = CullFaceFront;\\n\\texports.CullFaceFrontBack = CullFaceFrontBack;\\n\\texports.FrontFaceDirectionCW = FrontFaceDirectionCW;\\n\\texports.FrontFaceDirectionCCW = FrontFaceDirectionCCW;\\n\\texports.BasicShadowMap = BasicShadowMap;\\n\\texports.PCFShadowMap = PCFShadowMap;\\n\\texports.PCFSoftShadowMap = PCFSoftShadowMap;\\n\\texports.FrontSide = FrontSide;\\n\\texports.BackSide = BackSide;\\n\\texports.DoubleSide = DoubleSide;\\n\\texports.FlatShading = FlatShading;\\n\\texports.SmoothShading = SmoothShading;\\n\\texports.NoColors = NoColors;\\n\\texports.FaceColors = FaceColors;\\n\\texports.VertexColors = VertexColors;\\n\\texports.NoBlending = NoBlending;\\n\\texports.NormalBlending = NormalBlending;\\n\\texports.AdditiveBlending = AdditiveBlending;\\n\\texports.SubtractiveBlending = SubtractiveBlending;\\n\\texports.MultiplyBlending = MultiplyBlending;\\n\\texports.CustomBlending = CustomBlending;\\n\\texports.AddEquation = AddEquation;\\n\\texports.SubtractEquation = SubtractEquation;\\n\\texports.ReverseSubtractEquation = ReverseSubtractEquation;\\n\\texports.MinEquation = MinEquation;\\n\\texports.MaxEquation = MaxEquation;\\n\\texports.ZeroFactor = ZeroFactor;\\n\\texports.OneFactor = OneFactor;\\n\\texports.SrcColorFactor = SrcColorFactor;\\n\\texports.OneMinusSrcColorFactor = OneMinusSrcColorFactor;\\n\\texports.SrcAlphaFactor = SrcAlphaFactor;\\n\\texports.OneMinusSrcAlphaFactor = OneMinusSrcAlphaFactor;\\n\\texports.DstAlphaFactor = DstAlphaFactor;\\n\\texports.OneMinusDstAlphaFactor = OneMinusDstAlphaFactor;\\n\\texports.DstColorFactor = DstColorFactor;\\n\\texports.OneMinusDstColorFactor = OneMinusDstColorFactor;\\n\\texports.SrcAlphaSaturateFactor = SrcAlphaSaturateFactor;\\n\\texports.NeverDepth = NeverDepth;\\n\\texports.AlwaysDepth = AlwaysDepth;\\n\\texports.LessDepth = LessDepth;\\n\\texports.LessEqualDepth = LessEqualDepth;\\n\\texports.EqualDepth = EqualDepth;\\n\\texports.GreaterEqualDepth = GreaterEqualDepth;\\n\\texports.GreaterDepth = GreaterDepth;\\n\\texports.NotEqualDepth = NotEqualDepth;\\n\\texports.MultiplyOperation = MultiplyOperation;\\n\\texports.MixOperation = MixOperation;\\n\\texports.AddOperation = AddOperation;\\n\\texports.NoToneMapping = NoToneMapping;\\n\\texports.LinearToneMapping = LinearToneMapping;\\n\\texports.ReinhardToneMapping = ReinhardToneMapping;\\n\\texports.Uncharted2ToneMapping = Uncharted2ToneMapping;\\n\\texports.CineonToneMapping = CineonToneMapping;\\n\\texports.UVMapping = UVMapping;\\n\\texports.CubeReflectionMapping = CubeReflectionMapping;\\n\\texports.CubeRefractionMapping = CubeRefractionMapping;\\n\\texports.EquirectangularReflectionMapping = EquirectangularReflectionMapping;\\n\\texports.EquirectangularRefractionMapping = EquirectangularRefractionMapping;\\n\\texports.SphericalReflectionMapping = SphericalReflectionMapping;\\n\\texports.CubeUVReflectionMapping = CubeUVReflectionMapping;\\n\\texports.CubeUVRefractionMapping = CubeUVRefractionMapping;\\n\\texports.RepeatWrapping = RepeatWrapping;\\n\\texports.ClampToEdgeWrapping = ClampToEdgeWrapping;\\n\\texports.MirroredRepeatWrapping = MirroredRepeatWrapping;\\n\\texports.NearestFilter = NearestFilter;\\n\\texports.NearestMipMapNearestFilter = NearestMipMapNearestFilter;\\n\\texports.NearestMipMapLinearFilter = NearestMipMapLinearFilter;\\n\\texports.LinearFilter = LinearFilter;\\n\\texports.LinearMipMapNearestFilter = LinearMipMapNearestFilter;\\n\\texports.LinearMipMapLinearFilter = LinearMipMapLinearFilter;\\n\\texports.UnsignedByteType = UnsignedByteType;\\n\\texports.ByteType = ByteType;\\n\\texports.ShortType = ShortType;\\n\\texports.UnsignedShortType = UnsignedShortType;\\n\\texports.IntType = IntType;\\n\\texports.UnsignedIntType = UnsignedIntType;\\n\\texports.FloatType = FloatType;\\n\\texports.HalfFloatType = HalfFloatType;\\n\\texports.UnsignedShort4444Type = UnsignedShort4444Type;\\n\\texports.UnsignedShort5551Type = UnsignedShort5551Type;\\n\\texports.UnsignedShort565Type = UnsignedShort565Type;\\n\\texports.UnsignedInt248Type = UnsignedInt248Type;\\n\\texports.AlphaFormat = AlphaFormat;\\n\\texports.RGBFormat = RGBFormat;\\n\\texports.RGBAFormat = RGBAFormat;\\n\\texports.LuminanceFormat = LuminanceFormat;\\n\\texports.LuminanceAlphaFormat = LuminanceAlphaFormat;\\n\\texports.RGBEFormat = RGBEFormat;\\n\\texports.DepthFormat = DepthFormat;\\n\\texports.DepthStencilFormat = DepthStencilFormat;\\n\\texports.RGB_S3TC_DXT1_Format = RGB_S3TC_DXT1_Format;\\n\\texports.RGBA_S3TC_DXT1_Format = RGBA_S3TC_DXT1_Format;\\n\\texports.RGBA_S3TC_DXT3_Format = RGBA_S3TC_DXT3_Format;\\n\\texports.RGBA_S3TC_DXT5_Format = RGBA_S3TC_DXT5_Format;\\n\\texports.RGB_PVRTC_4BPPV1_Format = RGB_PVRTC_4BPPV1_Format;\\n\\texports.RGB_PVRTC_2BPPV1_Format = RGB_PVRTC_2BPPV1_Format;\\n\\texports.RGBA_PVRTC_4BPPV1_Format = RGBA_PVRTC_4BPPV1_Format;\\n\\texports.RGBA_PVRTC_2BPPV1_Format = RGBA_PVRTC_2BPPV1_Format;\\n\\texports.RGB_ETC1_Format = RGB_ETC1_Format;\\n\\texports.LoopOnce = LoopOnce;\\n\\texports.LoopRepeat = LoopRepeat;\\n\\texports.LoopPingPong = LoopPingPong;\\n\\texports.InterpolateDiscrete = InterpolateDiscrete;\\n\\texports.InterpolateLinear = InterpolateLinear;\\n\\texports.InterpolateSmooth = InterpolateSmooth;\\n\\texports.ZeroCurvatureEnding = ZeroCurvatureEnding;\\n\\texports.ZeroSlopeEnding = ZeroSlopeEnding;\\n\\texports.WrapAroundEnding = WrapAroundEnding;\\n\\texports.TrianglesDrawMode = TrianglesDrawMode;\\n\\texports.TriangleStripDrawMode = TriangleStripDrawMode;\\n\\texports.TriangleFanDrawMode = TriangleFanDrawMode;\\n\\texports.LinearEncoding = LinearEncoding;\\n\\texports.sRGBEncoding = sRGBEncoding;\\n\\texports.GammaEncoding = GammaEncoding;\\n\\texports.RGBEEncoding = RGBEEncoding;\\n\\texports.LogLuvEncoding = LogLuvEncoding;\\n\\texports.RGBM7Encoding = RGBM7Encoding;\\n\\texports.RGBM16Encoding = RGBM16Encoding;\\n\\texports.RGBDEncoding = RGBDEncoding;\\n\\texports.BasicDepthPacking = BasicDepthPacking;\\n\\texports.RGBADepthPacking = RGBADepthPacking;\\n\\texports.CubeGeometry = BoxGeometry;\\n\\texports.Face4 = Face4;\\n\\texports.LineStrip = LineStrip;\\n\\texports.LinePieces = LinePieces;\\n\\texports.MeshFaceMaterial = MeshFaceMaterial;\\n\\texports.MultiMaterial = MultiMaterial;\\n\\texports.PointCloud = PointCloud;\\n\\texports.Particle = Particle;\\n\\texports.ParticleSystem = ParticleSystem;\\n\\texports.PointCloudMaterial = PointCloudMaterial;\\n\\texports.ParticleBasicMaterial = ParticleBasicMaterial;\\n\\texports.ParticleSystemMaterial = ParticleSystemMaterial;\\n\\texports.Vertex = Vertex;\\n\\texports.DynamicBufferAttribute = DynamicBufferAttribute;\\n\\texports.Int8Attribute = Int8Attribute;\\n\\texports.Uint8Attribute = Uint8Attribute;\\n\\texports.Uint8ClampedAttribute = Uint8ClampedAttribute;\\n\\texports.Int16Attribute = Int16Attribute;\\n\\texports.Uint16Attribute = Uint16Attribute;\\n\\texports.Int32Attribute = Int32Attribute;\\n\\texports.Uint32Attribute = Uint32Attribute;\\n\\texports.Float32Attribute = Float32Attribute;\\n\\texports.Float64Attribute = Float64Attribute;\\n\\texports.ClosedSplineCurve3 = ClosedSplineCurve3;\\n\\texports.SplineCurve3 = SplineCurve3;\\n\\texports.Spline = Spline;\\n\\texports.AxisHelper = AxisHelper;\\n\\texports.BoundingBoxHelper = BoundingBoxHelper;\\n\\texports.EdgesHelper = EdgesHelper;\\n\\texports.WireframeHelper = WireframeHelper;\\n\\texports.XHRLoader = XHRLoader;\\n\\texports.BinaryTextureLoader = BinaryTextureLoader;\\n\\texports.GeometryUtils = GeometryUtils;\\n\\texports.ImageUtils = ImageUtils;\\n\\texports.Projector = Projector;\\n\\texports.CanvasRenderer = CanvasRenderer;\\n\\n\\tObject.defineProperty(exports, '__esModule', { value: true });\\n\\n})));\\n\""],"names":[],"sourceRoot":""}\n//# sourceURL=webpack-internal:///621\n")},642:module=>{eval('/*\n\tMIT License http://www.opensource.org/licenses/mit-license.php\n\tAuthor Tobias Koppers @sokra\n*/\nmodule.exports = function(src) {\n\tfunction log(error) {\n\t\t(typeof console !== "undefined")\n\t\t&& (console.error || console.log)("[Script Loader]", error);\n\t}\n\n\t// Check for IE =< 8\n\tfunction isIE() {\n\t\treturn typeof attachEvent !== "undefined" && typeof addEventListener === "undefined";\n\t}\n\n\ttry {\n\t\tif (typeof execScript !== "undefined" && isIE()) {\n\t\t\texecScript(src);\n\t\t} else if (typeof eval !== "undefined") {\n\t\t\teval.call(null, src);\n\t\t} else {\n\t\t\tlog("EvalError: No eval function available");\n\t\t}\n\t} catch (error) {\n\t\tlog(error);\n\t}\n}\n//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiNjQyLmpzIiwibWFwcGluZ3MiOiJBQUFBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTtBQUNBO0FBQ0E7QUFDQTs7QUFFQTtBQUNBO0FBQ0E7QUFDQTs7QUFFQTtBQUNBO0FBQ0E7QUFDQSxJQUFJO0FBQ0o7QUFDQSxJQUFJO0FBQ0o7QUFDQTtBQUNBLEdBQUc7QUFDSDtBQUNBO0FBQ0EiLCJzb3VyY2VzIjpbIndlYnBhY2s6Ly9kYXNoLy4vbm9kZV9tb2R1bGVzL3NjcmlwdC1sb2FkZXIvYWRkU2NyaXB0LmpzP2YyYjUiXSwic291cmNlc0NvbnRlbnQiOlsiLypcblx0TUlUIExpY2Vuc2UgaHR0cDovL3d3dy5vcGVuc291cmNlLm9yZy9saWNlbnNlcy9taXQtbGljZW5zZS5waHBcblx0QXV0aG9yIFRvYmlhcyBLb3BwZXJzIEBzb2tyYVxuKi9cbm1vZHVsZS5leHBvcnRzID0gZnVuY3Rpb24oc3JjKSB7XG5cdGZ1bmN0aW9uIGxvZyhlcnJvcikge1xuXHRcdCh0eXBlb2YgY29uc29sZSAhPT0gXCJ1bmRlZmluZWRcIilcblx0XHQmJiAoY29uc29sZS5lcnJvciB8fCBjb25zb2xlLmxvZykoXCJbU2NyaXB0IExvYWRlcl1cIiwgZXJyb3IpO1xuXHR9XG5cblx0Ly8gQ2hlY2sgZm9yIElFID08IDhcblx0ZnVuY3Rpb24gaXNJRSgpIHtcblx0XHRyZXR1cm4gdHlwZW9mIGF0dGFjaEV2ZW50ICE9PSBcInVuZGVmaW5lZFwiICYmIHR5cGVvZiBhZGRFdmVudExpc3RlbmVyID09PSBcInVuZGVmaW5lZFwiO1xuXHR9XG5cblx0dHJ5IHtcblx0XHRpZiAodHlwZW9mIGV4ZWNTY3JpcHQgIT09IFwidW5kZWZpbmVkXCIgJiYgaXNJRSgpKSB7XG5cdFx0XHRleGVjU2NyaXB0KHNyYyk7XG5cdFx0fSBlbHNlIGlmICh0eXBlb2YgZXZhbCAhPT0gXCJ1bmRlZmluZWRcIikge1xuXHRcdFx0ZXZhbC5jYWxsKG51bGwsIHNyYyk7XG5cdFx0fSBlbHNlIHtcblx0XHRcdGxvZyhcIkV2YWxFcnJvcjogTm8gZXZhbCBmdW5jdGlvbiBhdmFpbGFibGVcIik7XG5cdFx0fVxuXHR9IGNhdGNoIChlcnJvcikge1xuXHRcdGxvZyhlcnJvcik7XG5cdH1cbn1cbiJdLCJuYW1lcyI6W10sInNvdXJjZVJvb3QiOiIifQ==\n//# sourceURL=webpack-internal:///642\n')},172:(__unused_webpack_module,__unused_webpack_exports,__webpack_require__)=>{eval("__webpack_require__(642)(__webpack_require__(585))//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMTcyLmpzIiwibWFwcGluZ3MiOiJBQUFBLG1CQUFPLENBQUMsR0FBNkUsRUFBRSxtQkFBTyxDQUFDLEdBQW9IIiwic291cmNlcyI6WyJ3ZWJwYWNrOi8vZGFzaC8uL2pzL1V0aWxzLmpzPzdiNWYiXSwic291cmNlc0NvbnRlbnQiOlsicmVxdWlyZShcIiEhL1VzZXJzL2xuZHN0b2wvRGV2L2Rhc2gvc2ltdWxhdG9yL25vZGVfbW9kdWxlcy9zY3JpcHQtbG9hZGVyL2FkZFNjcmlwdC5qc1wiKShyZXF1aXJlKFwiISEvVXNlcnMvbG5kc3RvbC9EZXYvZGFzaC9zaW11bGF0b3Ivbm9kZV9tb2R1bGVzL3Jhdy1sb2FkZXIvaW5kZXguanMhL1VzZXJzL2xuZHN0b2wvRGV2L2Rhc2gvc2ltdWxhdG9yL2pzL1V0aWxzLmpzXCIpKSJdLCJuYW1lcyI6W10sInNvdXJjZVJvb3QiOiIifQ==\n//# sourceURL=webpack-internal:///172\n")},680:(__unused_webpack_module,__unused_webpack_exports,__webpack_require__)=>{eval("__webpack_require__(642)(__webpack_require__(621))//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiNjgwLmpzIiwibWFwcGluZ3MiOiJBQUFBLG1CQUFPLENBQUMsR0FBNkUsRUFBRSxtQkFBTyxDQUFDLEdBQXdIIiwic291cmNlcyI6WyJ3ZWJwYWNrOi8vZGFzaC8uL3ZlbmRvci90aHJlZS5qcz9jOTJhIl0sInNvdXJjZXNDb250ZW50IjpbInJlcXVpcmUoXCIhIS9Vc2Vycy9sbmRzdG9sL0Rldi9kYXNoL3NpbXVsYXRvci9ub2RlX21vZHVsZXMvc2NyaXB0LWxvYWRlci9hZGRTY3JpcHQuanNcIikocmVxdWlyZShcIiEhL1VzZXJzL2xuZHN0b2wvRGV2L2Rhc2gvc2ltdWxhdG9yL25vZGVfbW9kdWxlcy9yYXctbG9hZGVyL2luZGV4LmpzIS9Vc2Vycy9sbmRzdG9sL0Rldi9kYXNoL3NpbXVsYXRvci92ZW5kb3IvdGhyZWUuanNcIikpIl0sIm5hbWVzIjpbXSwic291cmNlUm9vdCI6IiJ9\n//# sourceURL=webpack-internal:///680\n")},691:(__unused_webpack_module,__unused_webpack___webpack_exports__,__webpack_require__)=>{"use strict";eval("\n// EXTERNAL MODULE: ./node_modules/script-loader/index.js!./vendor/three.js\nvar three = __webpack_require__(680);\n// EXTERNAL MODULE: ./node_modules/script-loader/index.js!./js/Utils.js\nvar Utils = __webpack_require__(172);\n;// CONCATENATED MODULE: ./js/physics/Car.js\nclass Car {\n constructor(x = 0, y = 0, rotation = 0) {\n this.setPose(x, y, rotation);\n }\n\n static getFrontAxlePosition(pos, rot) {\n return THREE.Vector2.fromAngle(rot).multiplyScalar(Car.WHEEL_BASE).add(pos);\n }\n\n static getFakeAxlePosition(pos, rot) {\n return Car.frontToRearAxlePosition(pos, rot);\n }\n\n static centerToRearAxlePosition(pos, rot) {\n return THREE.Vector2.fromAngle(rot).multiplyScalar(Car.REAR_AXLE_POS).add(pos);\n }\n\n static frontToRearAxlePosition(pos, rot) {\n return THREE.Vector2.fromAngle(rot).multiplyScalar(-Car.WHEEL_BASE).add(pos);\n }\n\n get pose() {\n return { pos: this.rearAxlePosition.clone(), rot: this.rotation, velocity: this.velocity, curv: this.curvature, dCurv: this.dCurv, ddCurv: this.ddCurv };\n }\n\n get curvature() {\n return Math.tan(this.wheelAngle) / Car.WHEEL_BASE;\n }\n\n get rearAxlePosition() {\n const { x, y } = this.position;\n const rot = this.rotation;\n return new THREE.Vector2(x + Math.cos(rot) * Car.REAR_AXLE_POS, y + Math.sin(rot) * Car.REAR_AXLE_POS);\n }\n\n get frontAxlePosition() {\n const { x, y } = this.position;\n const rot = this.rotation;\n return new THREE.Vector2(x + Math.cos(rot) * Car.FRONT_AXLE_POS, y + Math.sin(rot) * Car.FRONT_AXLE_POS);\n }\n\n setPose(x, y, rotation) {\n // Translate so that x and y become the center of the vehicle (instead of the center of the rear axle)\n x -= Car.REAR_AXLE_POS * Math.cos(rotation);\n y -= Car.REAR_AXLE_POS * Math.sin(rotation);\n\n this.position = new THREE.Vector2(x, y);\n this.rotation = Math.wrapAngle(rotation);\n this.velocity = 0;\n this.acceleration = 0;\n this.wheelAngle = 0;\n this.wheelAngularVelocity = 0;\n this.dCurv = 0; // derivative with respect to arc length\n this.ddCurv = 0; // derivative with respect to arc length\n }\n\n step(dt) {\n const curvPrev = this.curvature;\n const dCurvPrev = this.dCurv;\n\n const drag = (0.5 * Car.DRAG_COEFF * Car.FRONTAL_AREA * Car.DENSITY_OF_AIR * Math.abs(this.velocity) + Car.ROLL_RESIST) * -this.velocity;\n this.velocity += (this.acceleration + drag / Car.MASS) * dt;\n\n const velocitySq = this.velocity * this.velocity;\n const maxWheelAngle = Math.clamp(Math.atan(Car.MAX_LATERAL_ACCEL * Car.WHEEL_BASE / velocitySq), 0.07, Car.MAX_WHEEL_ANGLE);\n this.wheelAngle = Math.clamp(Math.wrapAngle(this.wheelAngle + this.wheelAngularVelocity * dt), -maxWheelAngle, maxWheelAngle);\n\n const angularVelocity = this.velocity * this.curvature;\n this.rotation = Math.wrapAngle(this.rotation + angularVelocity * dt);\n\n const dist = this.velocity * dt;\n this.position = THREE.Vector2.fromAngle(this.rotation).multiplyScalar(dist).add(this.position);\n\n this.dCurv = dist > 0.1 ? (this.curvature - curvPrev) / dist : 0;\n this.ddCurv = dist > 0.1 ? (this.dCurv - dCurvPrev) / dist : 0;\n }\n\n update(controls, dt) {\n const gas = Math.clamp(controls.gas, -1, +1);\n const brake = Math.clamp(controls.brake, 0, 1);\n const steer = Math.clamp(controls.steer, -1, +1);\n\n if (brake > 0) {\n this.acceleration = -Math.sign(this.velocity) * Car.MAX_BRAKE_DECEL * brake;\n const newVelocity = this.velocity + this.acceleration * dt;\n\n // If applying the braking deceleration at the next step would cause the velocity\n // to change directions, then just set the car as stopped.\n if (Math.sign(newVelocity) != Math.sign(this.velocity)) {\n this.velocity = 0;\n this.acceleration = 0;\n }\n } else {\n this.acceleration = Car.MAX_GAS_ACCEL * gas;\n }\n\n if (steer != 0) {\n this.wheelAngularVelocity = steer * Car.MAX_STEER_SPEED;\n } else {\n this.wheelAngularVelocity = Math.clamp(-this.wheelAngle / Car.MAX_WHEEL_ANGLE * this.velocity * this.velocity * dt, -Car.MAX_STEER_SPEED, Car.MAX_STEER_SPEED);\n }\n }\n}\n\nCar.HALF_CAR_LENGTH = 2.5; // meters\nCar.HALF_CAR_WIDTH = 1; // meters\nCar.HALF_WHEEL_LENGTH = 0.38; // meters\nCar.HALF_WHEEL_WIDTH = 0.12; // meters\nCar.MAX_WHEEL_ANGLE = 32 / 180 * Math.PI; // radians\nCar.MASS = 1600; // kg\nCar.DRAG_COEFF = 0.7;\nCar.DENSITY_OF_AIR = 1.8580608; // (kg/m^3)\nCar.FRONTAL_AREA = 1.85; // m^2\nCar.ROLL_RESIST = 0;\nCar.MAX_STEER_SPEED = 0.8;//1.2; // Radians per second\nCar.MAX_GAS_ACCEL = 3.0; // m / s^2\nCar.MAX_BRAKE_DECEL = 3.0; // m / s^2\nCar.WHEEL_LATERAL_POS = 0.843; // meters\nCar.FRONT_AXLE_POS = 1.6; // meters\nCar.REAR_AXLE_POS = -1.43; // meters\nCar.WHEEL_BASE = Car.FRONT_AXLE_POS - Car.REAR_AXLE_POS; // meters\nCar.MAX_LATERAL_ACCEL = 5.81; // m / s^2\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/CubicPath.js\nconst SIMPSONS_INTERVALS = 8;\nconst NEWTON_ITERATIONS = 16;\nconst RELAXATION_ITERATIONS = 32;\nconst CONVERGENCE_ERROR = 0.01;\n\nconst jacobian = new THREE.Matrix3();\nconst invJacobian = new THREE.Matrix3();\n\n// Alternate reference implementation: https://github.com/ApolloAuto/apollo/blob/master/modules/planning/math/spiral_curve/cubic_spiral_curve.cc\nclass CubicPath_CubicPath {\n constructor(start, end, params = null) {\n this.start = Object.assign({}, start);\n this.end = Object.assign({}, end);\n\n if (start.pos) {\n this.start.x = start.pos.x;\n this.start.y = start.pos.y\n }\n\n if (end.pos) {\n this.end.x = end.pos.x;\n this.end.y = end.pos.y\n }\n\n const diffX = this.end.x - this.start.x;\n const diffY = this.end.y - this.start.y;\n const sinRot = Math.sin(this.start.rot);\n const cosRot = Math.cos(this.start.rot);\n\n this.goal = {\n x: cosRot * diffX + sinRot * diffY,\n y: -sinRot * diffX + cosRot * diffY,\n rot: Math.wrapAngle(this.end.rot - this.start.rot),\n curv: this.end.curv\n };\n\n if (params)\n this.params = Object.assign({}, params, { p0: this.start.curv, p3: this.end.curv });\n else\n this.guessInitialParams();\n\n this.converged = false;\n }\n\n guessInitialParams() {\n const originalGoal = this.goal;\n const dStartCurv = this.start.curv / RELAXATION_ITERATIONS;\n const dGoalY = originalGoal.y / RELAXATION_ITERATIONS;\n const dGoalRot = originalGoal.rot / RELAXATION_ITERATIONS;\n const dGoalCurv = originalGoal.curv / RELAXATION_ITERATIONS;\n\n this.goal = {\n x: originalGoal.x,\n y: 0,\n rot: 0,\n curv: 0\n };\n\n this.params = {\n p0: 0,\n p1: 0,\n p2: 0,\n p3: 0,\n sG: originalGoal.x\n };\n\n for (let i = 0; i < RELAXATION_ITERATIONS; i++) {\n this.params.p0 += dStartCurv;\n this.params.p3 += dGoalCurv;\n this.goal.y += dGoalY;\n this.goal.rot += dGoalRot;\n this.goal.curv += dGoalCurv;\n\n this.iterate();\n }\n\n this.goal = originalGoal;\n }\n\n optimize() {\n for (let i = 0; i < NEWTON_ITERATIONS; i++) {\n if (this.iterate()) {\n this.converged = true;\n return true;\n }\n }\n\n this.converged = false;\n return false;\n }\n\n iterate() {\n const { p0, p1, p2, p3, sG } = this.params;\n\n const ds = sG / SIMPSONS_INTERVALS;\n const sG_2 = sG * sG;\n const sG_3 = sG_2 * sG;\n\n let dX_p1 = 0;\n let dX_p2 = 0;\n let dX_sG = 0;\n let dY_p1 = 0;\n let dY_p2 = 0;\n let dY_sG = 0;\n let guessX = 0;\n let guessY = 0;\n\n let theta, cosTheta, sinTheta, dT_p1, dT_p2, dT_sG;\n\n for (let i = 0, s = 0; i <= SIMPSONS_INTERVALS; i++, s += ds) {\n const coeff = i == 0 || i == SIMPSONS_INTERVALS ? 1 : i % 2 == 0 ? 2 : 4;\n\n const a = p0;\n const b = (-5.5 * p0 + 9 * p1 - 4.5 * p2 + p3) / sG;\n const c = (9 * p0 - 22.5 * p1 + 18 * p2 - 4.5 * p3) / sG_2;\n const d = (-4.5 * (p0 - 3 * p1 + 3 * p2 - p3)) / sG_3;\n\n theta = (((d * s / 4 + c / 3) * s + b / 2) * s + a) * s;\n cosTheta = Math.cos(theta);\n sinTheta = Math.sin(theta);\n\n const s_sG = s / sG;\n dT_p1 = ((3.375 * s_sG - 7.5) * s_sG + 4.5) * s_sG * s;\n dT_p2 = ((-3.375 * s_sG + 6) * s_sG - 2.25) * s_sG * s;\n dT_sG = ((3.375 * (p0 - 3 * p1 + 3 * p2 - p3) * s_sG - 3 * (2 * p0 - 5 * p1 + 4 * p2 - p3)) * s_sG + 0.25 * (11 * p0 - 18 * p1 + 9 * p2 - 2 * p3)) * s_sG * s_sG;\n\n dX_p1 -= coeff * sinTheta * dT_p1;\n dX_p2 -= coeff * sinTheta * dT_p2;\n dX_sG -= coeff * sinTheta * dT_sG;\n\n dY_p1 += coeff * cosTheta * dT_p1;\n dY_p2 += coeff * cosTheta * dT_p2;\n dY_sG += coeff * cosTheta * dT_sG;\n\n guessX += coeff * cosTheta;\n guessY += coeff * sinTheta;\n }\n\n // After the Simpson's integration loop, `theta`, `cosTheta`, `sinTheta`,\n // `dT_p1`, `dT_p2`, and `dT_sG` hold the appropriate values for `sG`.\n\n const hOver3 = sG / SIMPSONS_INTERVALS / 3;\n\n const deltaX = this.goal.x - guessX * hOver3;\n const deltaY = this.goal.y - guessY * hOver3;\n const deltaRot = Math.wrapAngle(this.goal.rot - theta);\n\n if (Math.abs(deltaX) + Math.abs(deltaY) + Math.abs(deltaRot) < CONVERGENCE_ERROR)\n return true;\n\n jacobian.set(\n dX_p1 * hOver3, dX_p2 * hOver3, cosTheta + dX_sG * hOver3,\n dY_p1 * hOver3, dY_p2 * hOver3, sinTheta + dY_sG * hOver3,\n dT_p1, dT_p2, dT_sG\n );\n\n const [m11, m21, m31, m12, m22, m32, m13, m23, m33] = invJacobian.getInverse(jacobian).elements;\n\n this.params.p1 += m11 * deltaX + m12 * deltaY + m13 * deltaRot;\n this.params.p2 += m21 * deltaX + m22 * deltaY + m23 * deltaRot;\n this.params.sG += m31 * deltaX + m32 * deltaY + m33 * deltaRot;\n\n return false;\n }\n\n buildPath(num) {\n const { p0, p1, p2, p3, sG } = this.params;\n\n const sG_2 = sG * sG;\n const sG_3 = sG_2 * sG;\n\n const a = p0;\n const b = (-5.5 * p0 + 9 * p1 - 4.5 * p2 + p3) / sG;\n const c = (9 * p0 - 22.5 * p1 + 18 * p2 - 4.5 * p3) / sG_2;\n const d = (-4.5 * (p0 - 3 * p1 + 3 * p2 - p3)) / sG_3;\n\n const path = [{ pos: new THREE.Vector2(this.start.x, this.start.y), rot: this.start.rot, curv: this.start.curv }];\n const ds = sG / (num - 1);\n let s = ds;\n let dx = 0;\n let dy = 0;\n let prevCosRot = Math.cos(path[0].rot);\n let prevSinRot = Math.sin(path[0].rot);\n\n for (let i = 1; i < num - 1; i++) {\n const rot = (((d * s / 4 + c / 3) * s + b / 2) * s + a) * s + this.start.rot;\n const curv = ((d * s + c) * s + b) * s + a;\n const cosRot = Math.cos(rot);\n const sinRot = Math.sin(rot);\n\n dx = dx * (i - 1) / i + (cosRot + prevCosRot) / (2 * i);\n dy = dy * (i - 1) / i + (sinRot + prevSinRot) / (2 * i);\n\n path.push({ pos: new THREE.Vector2(s * dx + this.start.x, s * dy + this.start.y), rot: rot, curv: curv });\n\n s += ds;\n prevCosRot = cosRot;\n prevSinRot = sinRot;\n }\n\n path.push({ pos: new THREE.Vector2(this.end.x, this.end.y), rot: this.end.rot, curv: this.end.curv });\n\n return path;\n }\n}\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/xyObstacleGrid.js\nconst OBSTACLE_VERTEX_SHADER = `#version 300 es\nuniform mat3 xform;\nin vec2 position;\n\nvoid main(void) {\n gl_Position = vec4((xform * vec3(position, 1)).xy, 0, 1);\n}\n`;\n\nconst OBSTACLE_KERNEL = `\n vec4 kernel() {\n return vec4(1, 0, 0, 1);\n }\n`;\n\nlet obstacleVertices;\nlet obstacleXform;\n\n// Draw obstacle triangles to XY-space obstacle grid\n/* harmony default export */ const gpgpu_programs_xyObstacleGrid = ({\n setUp() {\n return {\n kernel: OBSTACLE_KERNEL,\n vertexShader: OBSTACLE_VERTEX_SHADER,\n output: { name: 'xyObstacleGrid' },\n draw: (gpgpu, program) => {\n const gl = gpgpu.gl;\n\n gl.clearColor(0, 0, 0, 0);\n gl.clear(gl.COLOR_BUFFER_BIT);\n\n if (obstacleVertices.length > 0) {\n const buf = gl.createBuffer();\n\n gl.bindBuffer(gl.ARRAY_BUFFER, buf);\n gl.bufferData(gl.ARRAY_BUFFER, obstacleVertices, gl.STATIC_DRAW);\n gl.enableVertexAttribArray(program.positionLocation);\n gl.vertexAttribPointer(program.positionLocation, 2, gl.FLOAT, false, 0, 0);\n\n const xformLocation = gl.getUniformLocation(program.glProgram, 'xform');\n gl.uniformMatrix3fv(xformLocation, false, obstacleXform.elements);\n\n gl.drawArrays(gl.TRIANGLES, 0, obstacleVertices.length / 2);\n\n gl.deleteBuffer(buf);\n }\n }\n };\n },\n\n update(config, xyWidth, xyHeight, xyCenterPoint, vehicleXform, obstacles) {\n obstacleVertices = new Float32Array(Array.prototype.concat.apply([], obstacles.map(o => o.vertices)));\n\n const translate = new THREE.Matrix3();\n translate.set(\n 1, 0, -xyCenterPoint.x,\n 0, 1, -xyCenterPoint.y,\n 0, 0, 1\n );\n\n const scale = new THREE.Matrix3();\n scale.set(\n 2 / (xyWidth * config.xyGridCellSize), 0, 0,\n 0, 2 / (xyHeight * config.xyGridCellSize), 0,\n 0, 0, 1\n );\n\n obstacleXform = scale.multiply(translate).multiply(vehicleXform);\n\n return {\n width: xyWidth,\n height: xyHeight\n }\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/slObstacleGrid.js\nconst SL_OBSTACLE_KERNEL = `\n\nvec4 kernel() {\n float centerlineWidth = float(textureSize(centerline, 0).x);\n\n vec2 sl = (kernelPosition - 0.5) * vec2(kernelSize) * vec2(slGridCellSize) + slCenterPoint;\n float centerlineCoord = sl.x / centerlineStationInterval / centerlineWidth * (centerlineWidth - 1.0) / centerlineWidth + (0.5 / centerlineWidth);\n if (centerlineCoord < 0.0 || centerlineCoord > 1.0) return vec4(0);\n\n vec3 centerlineSample = texture(centerline, vec2(centerlineCoord, 0)).xyz;\n float perpindicular = centerlineSample.z + radians(90.0);\n vec2 xy = centerlineSample.xy + sl.yy * vec2(cos(perpindicular), sin(perpindicular));\n\n vec2 xyTexCoords = (xy - xyCenterPoint) / vec2(textureSize(xyObstacleGrid, 0)) / vec2(xyGridCellSize) + 0.5;\n return texture(xyObstacleGrid, xyTexCoords);\n}\n\n`;\n\n// Convert XY-space obstacle grid to SL-space obstacle grid\n/* harmony default export */ const gpgpu_programs_slObstacleGrid = ({\n setUp() {\n return {\n kernel: SL_OBSTACLE_KERNEL,\n output: { name: 'slObstacleGrid' },\n uniforms: {\n xyObstacleGrid: { type: 'outputTexture' },\n slGridCellSize: { type: 'float' },\n xyGridCellSize: { type: 'float' },\n slCenterPoint: { type: 'vec2' },\n xyCenterPoint: { type: 'vec2' },\n centerlineStationInterval: { type: 'float' },\n centerline: { type: 'sharedTexture' }\n }\n }\n },\n\n update(config, slWidth, slHeight, slCenterPoint, xyCenterPoint) {\n return {\n width: slWidth,\n height: slHeight,\n uniforms: {\n slGridCellSize: config.slGridCellSize,\n xyGridCellSize: config.xyGridCellSize,\n slCenterPoint: [slCenterPoint.x, slCenterPoint.y],\n xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y],\n centerlineStationInterval: config.centerlineStationInterval\n }\n }\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/slObstacleGridDilation.js\nconst SL_OBSTACLE_DILATION_KERNEL = `\n\n// TODO: test performance of returning early if non-zero pixel found\nvec4 kernel() {\n float val = 0.0;\n\n for (int d = 0; d <= collisionDilation; d++) {\n val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(d)).r);\n val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(-d)).r);\n }\n\n for (int d = collisionDilation + 1; d <= collisionDilation + hazardDilation; d++) {\n val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(d)).r * 0.5);\n val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(-d)).r * 0.5);\n }\n\n val = max(val, step(0.1, val) * 0.5);\n\n return vec4(val, 0, 0, 1);\n}\n\n`;\n\n/* harmony default export */ const gpgpu_programs_slObstacleGridDilation = ({\n setUp() {\n return [\n { // SL-space obstacle grid S dilation\n kernel: SL_OBSTACLE_DILATION_KERNEL,\n output: { name: 'slObstacleGridStationDilated' },\n uniforms: {\n slObstacleGrid: { type: 'outputTexture' },\n delta: { type: 'vec2' },\n collisionDilation: { type: 'int' },\n hazardDilation: { type: 'int' }\n }\n },\n { // SL-space obstacle grid L dilation\n kernel: SL_OBSTACLE_DILATION_KERNEL,\n output: { name: 'slObstacleGridDilated' },\n uniforms: {\n slObstacleGrid: { type: 'outputTexture', name: 'slObstacleGridStationDilated' },\n delta: { type: 'vec2' },\n collisionDilation: { type: 'int' },\n hazardDilation: { type: 'int' }\n }\n }\n ];\n },\n\n update(config, slWidth, slHeight) {\n return [\n { // SL-space obstacle grid S dilation\n width: slWidth,\n height: slHeight,\n uniforms: {\n delta: [1 / slWidth, 0],\n collisionDilation: Math.ceil(config.collisionDilationS / config.slGridCellSize),\n hazardDilation: Math.ceil(config.hazardDilationS / config.slGridCellSize)\n }\n },\n { // SL-space obstacle grid L dilation\n width: slWidth,\n height: slHeight,\n uniforms: {\n delta: [0, 1 / slHeight],\n collisionDilation: Math.ceil(config.collisionDilationL / config.slGridCellSize),\n hazardDilation: Math.ceil(config.hazardDilationL / config.slGridCellSize)\n }\n }\n ];\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/slDynamicObstacleGrid.js\nconst DYNAMIC_OBSTACLE_VERTEX_SHADER = `#version 300 es\nuniform mat3 xform;\nin vec3 position;\nout float color;\n\nvoid main(void) {\n gl_Position = vec4((xform * vec3(position.xy, 1)).xy, position.z, 1);\n\n // The z coordinate is 0.25 for collision zone and 0.75 for hazard zone,\n // so that the collision zone is drawn on top.\n // Convert this to 1.0 for collision zone, 0.5 for hazard zone\n color = (1.0 - step(0.5, position.z)) * 0.5 + 0.5;\n}\n`;\n\nconst DYNAMIC_OBSTACLE_KERNEL = `\n in float color;\n\n vec4 kernel() {\n return vec4(color, 0, 0, 1);\n }\n`;\n\nlet slDynamicObstacleGrid_obstacleVertices;\nlet slDynamicObstacleGrid_obstacleXform;\nconst numDynamicFrames = 20;\n\n// Draw dynamic obstacle triangles to SL-space obstacle grid\n/* harmony default export */ const gpgpu_programs_slDynamicObstacleGrid = ({\n setUp() {\n return {\n kernel: DYNAMIC_OBSTACLE_KERNEL,\n vertexShader: DYNAMIC_OBSTACLE_VERTEX_SHADER,\n output: { name: 'slDynamicObstacleGrid', textureType: '2DArray', depth: numDynamicFrames },\n draw: (gpgpu, program) => {\n const gl = gpgpu.gl;\n\n gl.enable(gl.DEPTH_TEST);\n\n const renderbuffer = gl.createRenderbuffer();\n gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer);\n gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, program.inputWidth, program.inputHeight);\n gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, renderbuffer);\n\n for (let frame = 0; frame < numDynamicFrames; frame++) {\n gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, program.outputTexture, 0, frame);\n const frameBufferStatus = (gl.checkFramebufferStatus(gl.FRAMEBUFFER) == gl.FRAMEBUFFER_COMPLETE);\n if (!frameBufferStatus)\n throw new Error('Error attaching float texture to framebuffer. Your device is probably incompatible.');\n\n gl.clearColor(0, 0, 0, 0);\n gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);\n\n if (slDynamicObstacleGrid_obstacleVertices[frame].length > 0) {\n const buf = gl.createBuffer();\n\n gl.bindBuffer(gl.ARRAY_BUFFER, buf);\n gl.bufferData(gl.ARRAY_BUFFER, slDynamicObstacleGrid_obstacleVertices[frame], gl.STATIC_DRAW);\n gl.enableVertexAttribArray(program.positionLocation);\n gl.vertexAttribPointer(program.positionLocation, 3, gl.FLOAT, false, 0, 0);\n\n const xformLocation = gl.getUniformLocation(program.glProgram, 'xform');\n gl.uniformMatrix3fv(xformLocation, false, slDynamicObstacleGrid_obstacleXform.elements);\n\n gl.drawArrays(gl.TRIANGLES, 0, slDynamicObstacleGrid_obstacleVertices[frame].length / 3);\n\n if (frame == 0) {\n const obstacleGrid = new Float32Array(program.inputWidth * program.inputHeight * 4);\n gl.readPixels(0, 0, program.inputWidth, program.inputHeight, gl.RGBA, gl.FLOAT, obstacleGrid);\n gpgpu._dynamicObstacleGrid = obstacleGrid;\n }\n\n gl.deleteBuffer(buf);\n }\n }\n\n gl.bindRenderbuffer(gl.RENDERBUFFER, null);\n gl.deleteRenderbuffer(renderbuffer);\n gl.disable(gl.DEPTH_TEST);\n }\n };\n },\n\n update(config, slWidth, slHeight, slCenterPoint, vehicleStation, startTime, dynamicFrameTime, dynamicObstacles) {\n slDynamicObstacleGrid_obstacleVertices = [];\n\n let time = startTime;\n for (let frame = 0; frame < numDynamicFrames; frame++) {\n const vertices = Array.prototype.concat.apply([], dynamicObstacles.map(o => o.verticesInTimeRange(time, time + dynamicFrameTime, config)));\n slDynamicObstacleGrid_obstacleVertices.push(new Float32Array(vertices));\n time += dynamicFrameTime;\n }\n\n const translate = new THREE.Matrix3();\n translate.set(\n 1, 0, -slCenterPoint.x - vehicleStation,\n 0, 1, -slCenterPoint.y,\n 0, 0, 1\n );\n\n const scale = new THREE.Matrix3();\n scale.set(\n 2 / (slWidth * config.slGridCellSize), 0, 0,\n 0, 2 / (slHeight * config.slGridCellSize), 0,\n 0, 0, 1\n );\n\n slDynamicObstacleGrid_obstacleXform = scale.multiply(translate);\n\n return {\n width: slWidth,\n height: slHeight\n }\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/xyslMap.js\nconst XYSL_MAP_KERNEL = `\n\nvec4 kernel() {\n vec2 xy = (kernelPosition - 0.5) * vec2(kernelSize) * vec2(xyGridCellSize) + xyCenterPoint;\n\n int numSamples = textureSize(centerline, 0).x;\n int closest = 0;\n float closestDist = distance(xy, texelFetch(centerline, ivec2(0, 0), 0).xy);\n for (int i = 1; i < numSamples; i++) {\n float dist = distance(xy, texelFetch(centerline, ivec2(i, 0), 0).xy);\n if (dist < closestDist) {\n closestDist = dist;\n closest = i;\n }\n }\n\n vec2 closestPos = texelFetch(centerline, ivec2(closest, 0), 0).xy;\n vec2 prev, next;\n int prevIndex, nextIndex;\n\n if (closest == 0) {\n prevIndex = 0;\n nextIndex = 1;\n prev = closestPos;\n next = texelFetch(centerline, ivec2(1, 0), 0).xy;\n } else if (closest == numSamples - 1) {\n prevIndex = closest - 1;\n nextIndex = closest;\n prev = texelFetch(centerline, ivec2(prevIndex, 0), 0).xy;\n next = closestPos;\n } else {\n vec2 before = texelFetch(centerline, ivec2(closest - 1, 0), 0).xy;\n vec2 after = texelFetch(centerline, ivec2(closest + 1, 0), 0).xy;\n\n if (distance(before, xy) < distance(after, xy)) {\n prevIndex = closest - 1;\n nextIndex = closest;\n prev = before;\n next = closestPos;\n } else {\n prevIndex = closest;\n nextIndex = closest + 1;\n prev = closestPos;\n next = after;\n }\n }\n\n float dist = distance(prev, next);\n float progress = clamp(dot(xy - prev, next - prev) / dist / dist, 0.0, 1.0);\n vec2 projectedPos = (next - prev) * vec2(progress) + prev;\n\n return vec4(\n (float(prevIndex) + progress) * centerlineStationInterval,\n sign(determinant(mat2(next - prev, xy - prev))) * distance(xy, projectedPos),\n 0,\n 0\n );\n}\n\n`;\n\n// Build XY-SL map\n/* harmony default export */ const gpgpu_programs_xyslMap = ({\n setUp() {\n return {\n kernel: XYSL_MAP_KERNEL,\n output: { name: 'xyslMap', filter: 'linear' },\n uniforms: {\n centerline: { type: 'sharedTexture' },\n xyCenterPoint: { type: 'vec2' },\n xyGridCellSize: { type: 'float'},\n centerlineStationInterval: { type: 'float'}\n }\n };\n },\n\n update(config, xyWidth, xyHeight, xyCenterPoint) {\n return {\n width: xyWidth,\n height: xyHeight,\n uniforms: {\n xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y],\n xyGridCellSize: config.xyGridCellSize,\n centerlineStationInterval: config.centerlineStationInterval\n }\n };\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/optimizeCubicPaths.js\n// Config:\n// num stations\n// num latitudes\n// station connectivity\n// latitude connectivity\n//\n// Shared:\n// lattice\n\nconst OPTIMIZE_CUBIC_SHARED = `\n\nconst int NEWTON_ITERATIONS = 16;\nconst int RELAXATION_ITERATIONS = 16;\nconst float CONVERGENCE_ERROR = 0.01;\n\n// These two consts must stay in sync.\nconst int SIMPSONS_INTERVALS = 8;\n//const float SIMPSONS_COEFFS[SIMPSONS_INTERVALS + 1] = float[](1.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 1.0);\nconst float SIMPSONS_COEFFS[SIMPSONS_INTERVALS + 1] = float[](1.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 1.0);\n\nconst float PI = 3.1415926535897932384626433832795;\nconst float TWO_PI = PI + PI;\n\nconst float RELAXATION_ITERATIONS_F = float(RELAXATION_ITERATIONS);\nconst float SIMPSONS_INTERVALS_F = float(SIMPSONS_INTERVALS);\n\nfloat wrapAngle(float angle) {\n angle = mod(angle, TWO_PI);\n if (angle <= -PI) return angle + TWO_PI;\n else if (angle > PI) return angle - TWO_PI;\n return angle;\n}\n\nvec4 iterate(vec4 goal, float p0, float p1, float p2, float p3, float sG) {\n float ds = sG / SIMPSONS_INTERVALS_F;\n float sG_2 = sG * sG;\n float sG_3 = sG_2 * sG;\n\n vec3 dX_p = vec3(0.0);\n vec3 dY_p = vec3(0.0);\n vec2 guess = vec2(0.0);\n float s = 0.0;\n\n float theta, cosTheta, sinTheta;\n vec3 dT_p;\n\n for (int i = 0; i <= SIMPSONS_INTERVALS; i++) {\n float coeff = SIMPSONS_COEFFS[i];\n\n float a = p0;\n float b = (-5.5 * p0 + 9.0 * p1 - 4.5 * p2 + p3) / sG;\n float c = (9.0 * p0 - 22.5 * p1 + 18.0 * p2 - 4.5 * p3) / sG_2;\n float d = (-4.5 * (p0 - 3.0 * p1 + 3.0 * p2 - p3)) / sG_3;\n\n theta = (((d * s / 4.0 + c / 3.0) * s + b / 2.0) * s + a) * s;\n cosTheta = cos(theta);\n sinTheta = sin(theta);\n\n float s_sG = s / sG;\n\n dT_p = vec3(\n // p1\n ((3.375 * s_sG - 7.5) * s_sG + 4.5) * s_sG * s,\n\n // p2\n ((-3.375 * s_sG + 6.0) * s_sG - 2.25) * s_sG * s,\n\n // sG\n ((3.375 * (p0 - 3.0 * p1 + 3.0 * p2 - p3) * s_sG - 3.0 * (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3)) * s_sG + 0.25 * (11.0 * p0 - 18.0 * p1 + 9.0 * p2 - 2.0 * p3)) * s_sG * s_sG\n );\n\n dX_p -= coeff * sinTheta * dT_p;\n dY_p += coeff * cosTheta * dT_p;\n\n guess += coeff * vec2(cosTheta, sinTheta);\n\n s += ds;\n }\n\n float hOver3 = sG / SIMPSONS_INTERVALS_F / 3.0;\n\n vec3 delta;\n delta.xy = goal.xy - guess * hOver3;\n delta.z = wrapAngle(goal.z - theta);\n\n if (abs(delta.x) + abs(delta.y) + abs(delta.z) < CONVERGENCE_ERROR)\n return vec4(p1, p2, sG, 1.0);\n\n dX_p.xyz *= hOver3;\n dY_p.xyz *= hOver3;\n dX_p.z += cosTheta;\n dY_p.z += sinTheta;\n\n mat3 invJacobian = inverse(transpose(mat3(dX_p, dY_p, dT_p)));\n\n vec3 deltaP = invJacobian * delta;\n vec4 params = vec4(p1, p2, sG, 0.0);\n params.xyz += deltaP;\n\n return params;\n}\n\n/* Input:\n * start: (vec4)\n * x: x position,\n * y: y position,\n * z: theta rotation,\n * w: k curvature\n * end: (vec4)\n * x: x position,\n * y: y position,\n * z: theta rotation,\n * w: k curvature\n *\n * Output: (vec4)\n * x: p1,\n * y: p2,\n * z: sG,\n * w: 1 if converged, 0 if not\n */\n\nvec4 optimize(vec4 start, vec4 end) {\n // Translate and rotate start and end so that start is at the origin\n float sinRot = sin(start.z);\n float cosRot = cos(start.z);\n\n vec4 diff = end - start;\n vec4 goal;\n goal.xy = mat2(cosRot, -sinRot, sinRot, cosRot) * diff.xy;\n goal.z = wrapAngle(diff.z);\n goal.w = end.w;\n\n vec4 originalGoal = goal;\n vec4 dGoal;\n dGoal.x = 0.0;\n dGoal.yzw = goal.yzw / RELAXATION_ITERATIONS_F;\n float dK0 = start.w / RELAXATION_ITERATIONS_F;\n\n // Relax the goal to (x, 0, 0, 0)\n goal.yzw = vec3(0, 0, 0);\n\n // Relax the params to (0, 0, 0, 0, goal.x)\n float p0 = 0.0;\n float p1 = 0.0;\n float p2 = 0.0;\n float p3 = 0.0;\n float sG = goal.x;\n\n if (sG < 0.1) return vec4(0.0);\n\n for (int i = 0; i < RELAXATION_ITERATIONS; i++) {\n p0 += dK0;\n p3 += dGoal.w;\n goal += dGoal;\n \n vec4 result = iterate(goal, p0, p1, p2, p3, sG);\n p1 = result.x;\n p2 = result.y;\n sG = result.z;\n }\n\n goal = originalGoal;\n\n for (int i = 0; i < NEWTON_ITERATIONS; i++) {\n vec4 result = iterate(goal, p0, p1, p2, p3, sG);\n if (result.w == 1.0) {\n result.w = step(0.0, result.z);\n return result;\n }\n\n p1 = result.x;\n p2 = result.y;\n sG = result.z;\n }\n\n return vec4(p1, p2, sG, 0.0);\n}\n\n`;\n\nconst OPTIMIZE_CUBIC_KERNEL = OPTIMIZE_CUBIC_SHARED + `\n\n// width: station * latitude index\n// height: station_conn * lattice_conn\n//\n// lattice:\n// width: latitudes\n// height: stations\n\nvec4 kernel() {\n ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize));\n\n int endStation = indexes.x / numLatitudes;\n int endLatitude = int(mod(float(indexes.x), float(numLatitudes)));\n\n int startStation = endStation - stationConnectivity + indexes.y / latitudeConnectivity;\n int startLatitude = endLatitude - latitudeConnectivity / 2 + int(mod(float(indexes.y), float(latitudeConnectivity)));\n\n if (startStation < 0 || startStation >= numStations || startLatitude < 0 || startLatitude >= numLatitudes)\n return vec4(0.0);\n\n vec4 start = texelFetch(lattice, ivec2(startLatitude, startStation), 0);\n vec4 end = texelFetch(lattice, ivec2(endLatitude, endStation), 0);\n\n return optimize(start, end);\n}\n\n`;\n\nconst OPTIMIZE_CUBIC_FROM_VEHICLE_KERNEL = OPTIMIZE_CUBIC_SHARED + `\n\nvec4 kernel() {\n ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize));\n\n vec4 start = vec4(0, 0, 0, curvVehicle);\n vec4 end = texelFetch(lattice, indexes, 0);\n\n return optimize(start, end);\n}\n\n`;\n\n/* harmony default export */ const gpgpu_programs_optimizeCubicPaths = ({\n setUp() {\n return [\n { // Cubic paths between lattice nodes\n kernel: OPTIMIZE_CUBIC_KERNEL,\n output: { name: 'cubicPaths', read: true },\n uniforms: {\n lattice: { type: 'sharedTexture' },\n numStations: { type: 'int' },\n numLatitudes: { type: 'int' },\n stationConnectivity: { type: 'int' },\n latitudeConnectivity: { type: 'int' }\n }\n },\n { // Cubic paths from vehicle to lattice nodes\n kernel: OPTIMIZE_CUBIC_FROM_VEHICLE_KERNEL,\n output: { name: 'cubicPathsFromVehicle', read: true },\n uniforms: {\n lattice: { type: 'sharedTexture' },\n curvVehicle: { type: 'float' }\n }\n }\n ]\n },\n\n update(config, pose) {\n return [\n { // Cubic paths between lattice nodes\n width: config.lattice.numStations * config.lattice.numLatitudes,\n height: config.lattice.stationConnectivity * config.lattice.latitudeConnectivity,\n uniforms: {\n numStations: config.lattice.numStations,\n numLatitudes: config.lattice.numLatitudes,\n stationConnectivity: config.lattice.stationConnectivity,\n latitudeConnectivity: config.lattice.latitudeConnectivity,\n }\n },\n { // Cubic paths from vehicle to lattice nodes\n width: config.lattice.numLatitudes,\n height: config.lattice.stationConnectivity,\n uniforms: {\n curvVehicle: pose.curv\n }\n }\n ];\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/optimizeQuinticPaths.js\nconst OPTIMIZE_KERNEL = `\n\nconst int NEWTON_ITERATIONS = 32;\nconst int RELAXATION_ITERATIONS = 32;\nconst float CONVERGENCE_ERROR = 0.01;\n\n// These two consts must stay in sync.\nconst int SIMPSONS_INTERVALS = 8;\nconst float SIMPSONS_COEFFS[SIMPSONS_INTERVALS + 1] = float[](1.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 1.0);\n\nconst float PI = 3.1415926535897932384626433832795;\nconst float TWO_PI = PI + PI;\n\nconst float RELAXATION_ITERATIONS_F = float(RELAXATION_ITERATIONS);\nconst float SIMPSONS_INTERVALS_F = float(SIMPSONS_INTERVALS);\n\nfloat wrapAngle(float angle) {\n angle = mod(angle, TWO_PI);\n if (angle <= -PI) return angle + TWO_PI;\n else if (angle > PI) return angle - TWO_PI;\n return angle;\n}\n\nvec4 iterate(vec4 goal, float p0, float p1, float p2, float p3, float p4, float p5, float sG) {\n float ds = sG / SIMPSONS_INTERVALS_F;\n float sG_2 = sG * sG;\n float sG_3 = sG_2 * sG;\n\n vec3 dX_p = vec3(0.0);\n vec3 dY_p = vec3(0.0);\n vec2 guess = vec2(0.0);\n float s = 0.0;\n\n float theta, cosTheta, sinTheta;\n vec3 dT_p;\n\n for (int i = 0; i <= SIMPSONS_INTERVALS; i++) {\n float coeff = SIMPSONS_COEFFS[i];\n\n float a = p0;\n float b = p1;\n float c = p2 / 2.0;\n float d = (-71.875 * p0 + 81.0 * p3 - 10.125 * p4 + p5 - 21.25 * p1 * sG - 2.75 * p2 * sG_2) / sG_3;\n float e = (166.5 * p0 - 202.5 * p3 + 40.5 * p4 - 4.5 * p5 + 45.0 * p1 * sG + 4.5 * p2 * sG_2) / (sG_2 * sG_2);\n float f = (-95.625 * p0 + 121.5 * p3 - 30.375 * p4 + 4.5 * p5 - 24.75 * p1 * sG - 2.25 * p2 * sG_2) / (sG_2 * sG_3);\n\n theta = (((((f * s / 6.0 + e / 5.0) * s + d / 4.0) * s + c / 3.0) * s + b / 2.0) * s + a) * s;\n cosTheta = cos(theta);\n sinTheta = sin(theta);\n\n float s_2 = s * s;\n float s_sG = s / sG;\n float s_sG_2 = s_sG * s_sG;\n float s_sG_3 = s_sG_2 * s_sG;\n float s_sG_4 = s_sG_3 * s_sG;\n float s_sG_5 = s_sG_4 * s_sG;\n\n dT_p = vec3(\n // p3\n ((20.25 * s_sG - 40.5) * s_sG + 20.25) * s_sG_3 * s,\n\n // p4\n ((-5.0625 * s_sG + 8.1) * s_sG - 2.53125) * s_sG_3 * s,\n\n // sG\n (53.90625 * p0 - 60.75 * p3 + 7.59375 * p4 - 0.75 * p5) * s_sG_4 + 10.625 * p1 * s * s_sG_3 + 0.6875 * p2 * s_2 * s_sG_2 + (-133.2 * p0 + 162.0 * p3 - 32.4 * p4 + 3.6 * p5) * s_sG_5 + (-27.0) * p1 * s * s_sG_4 - 1.8 * p2 * s_2 * s_sG_3 + (79.6875 * p0 - 101.25 * p3 + 25.3125 * p4 - 3.75 * p5) * s_sG_5 * s_sG + 16.5 * p1 * s * s_sG_5 + 1.125 * p2 * s_2 * s_sG_4\n );\n\n dX_p -= coeff * sinTheta * dT_p;\n dY_p += coeff * cosTheta * dT_p;\n\n guess += coeff * vec2(cosTheta, sinTheta);\n\n s += ds;\n }\n\n float hOver3 = sG / SIMPSONS_INTERVALS_F / 3.0;\n\n vec3 delta;\n delta.xy = goal.xy - guess * hOver3;\n delta.z = wrapAngle(goal.z - theta);\n\n if (abs(delta.x) + abs(delta.y) + abs(delta.z) < CONVERGENCE_ERROR)\n return vec4(p3, p4, sG, 1.0);\n\n dX_p.xyz *= hOver3;\n dY_p.xyz *= hOver3;\n dX_p.z += cosTheta;\n dY_p.z += sinTheta;\n\n mat3 invJacobian = inverse(transpose(mat3(dX_p, dY_p, dT_p)));\n\n vec3 deltaP = invJacobian * delta;\n vec4 params = vec4(p3, p4, sG, 0.0);\n params.xyz += deltaP;\n\n return params;\n}\n\nvec4 optimize(vec4 start, vec4 end) {\n // Translate and rotate start and end so that start is at the origin\n float sinRot = sin(start.z);\n float cosRot = cos(start.z);\n\n vec4 diff = end - start;\n vec4 goal;\n goal.xy = mat2(cosRot, -sinRot, sinRot, cosRot) * diff.xy;\n goal.z = wrapAngle(diff.z);\n goal.w = end.w;\n\n vec4 originalGoal = goal;\n vec4 dGoal;\n dGoal.x = 0.0;\n dGoal.yzw = goal.yzw / RELAXATION_ITERATIONS_F;\n float d_K0 = start.w / RELAXATION_ITERATIONS_F;\n float d_dK0 = dCurvVehicle / RELAXATION_ITERATIONS_F;\n float d_ddK0 = ddCurvVehicle / RELAXATION_ITERATIONS_F;\n\n // Relax the goal to (x, 0, 0, 0)\n goal.yzw = vec3(0, 0, 0);\n\n // Relax the params to (0, 0, 0, 0, goal.x)\n float p0 = 0.0;\n float p1 = 0.0;\n float p2 = 0.0;\n float p3 = 0.0;\n float p4 = 0.0;\n float p5 = 0.0;\n float sG = goal.x;\n\n if (sG < 0.1) return vec4(0.0);\n\n for (int i = 0; i < RELAXATION_ITERATIONS; i++) {\n p0 += d_K0;\n p1 += d_dK0;\n p2 += d_ddK0;\n p5 += dGoal.w;\n goal += dGoal;\n \n vec4 result = iterate(goal, p0, p1, p2, p3, p4, p5, sG);\n p3 = result.x;\n p4 = result.y;\n sG = result.z;\n }\n\n goal = originalGoal;\n\n for (int i = 0; i < NEWTON_ITERATIONS; i++) {\n vec4 result = iterate(goal, p0, p1, p2, p3, p4, p5, sG);\n if (result.w == 1.0) {\n result.w = step(0.0, result.z);\n return result;\n }\n\n p3 = result.x;\n p4 = result.y;\n sG = result.z;\n }\n\n return vec4(p3, p4, sG, 0.0);\n}\n\nvec4 kernel() {\n ivec2 latticeIndexes = ivec2(kernelPosition * vec2(kernelSize));\n\n vec4 start = vec4(0, 0, 0, curvVehicle);\n vec4 end = texelFetch(lattice, latticeIndexes, 0);\n\n return optimize(start, end);\n}\n\n`;\n\n// Quintic spiral path optimizer\n// * Start of paths is the vehicle pose\n// * x-pos, y-pos, and rotation aren't needed, since the lattice origin is the vehicle pose\n// * So assume position and rotation are 0\n// * Ends of paths are all latitudes within the first (stationConnectivity) stations\n/* harmony default export */ const gpgpu_programs_optimizeQuinticPaths = ({\n setUp() {\n return {\n kernel: OPTIMIZE_KERNEL,\n output: { name: 'quinticPathsFromVehicle', read: true },\n uniforms: {\n lattice: { type: 'sharedTexture' },\n curvVehicle: { type: 'float' },\n dCurvVehicle: { type: 'float' },\n ddCurvVehicle: { type: 'float' }\n }\n };\n },\n\n update(config, pose) {\n return {\n width: config.lattice.numLatitudes,\n height: config.lattice.stationConnectivity,\n uniforms: {\n curvVehicle: pose.curv,\n dCurvVehicle: pose.dCurv,\n ddCurvVehicle: pose.ddCurv\n }\n };\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/graphSearchShared.js\nconst SHARED_SHADER = `\n\nconst float smallV = 0.01;\nvec4 pathSamples[128];\nfloat pathSampleCurvRates[128];\n\nfloat calculateAcceleration(int index, float initialVelocitySq, float distance) {\n if (index <= 4) {\n // [aMaxHard, aMinHard, aMaxSoft, aMinSoft, 0]\n return accelerationProfiles[index];\n } else {\n float finalVelocity = finalVelocityProfiles[index - 5];\n if (distance < 0.001) return 0.0;\n return clamp((finalVelocity * finalVelocity - initialVelocitySq) / (2.0 * distance), accelerationProfiles[1], accelerationProfiles[0]);\n }\n}\n\nvec2 xy2sl(vec4 xytk) {\n vec2 xy = xytk.xy + rearAxleToCenter * vec2(cos(xytk.z), sin(xytk.z));\n vec2 xyTexCoords = (xy - xyCenterPoint) / vec2(textureSize(xyslMap, 0)) / vec2(xyGridCellSize) + 0.5;\n return texture(xyslMap, xyTexCoords).xy;\n}\n\nfloat sampleStaticCost(vec4 xytk) {\n vec2 sl = xy2sl(xytk);\n vec2 slTexCoords = (sl - slCenterPoint) / vec2(textureSize(slObstacleGrid, 0)) / vec2(slGridCellSize) + 0.5;\n float obstacleCost = texture(slObstacleGrid, slTexCoords).r;\n\n if (obstacleCost >= 0.75) return -1.0; // Infinite cost\n\n obstacleCost = step(0.25, obstacleCost) * obstacleHazardCost;\n\n float absLatitude = abs(sl.y);\n if (absLatitude >= laneShoulderLatitude) return -1.0;\n\n float laneCost = abs(absLatitude - laneCenterLatitude) * laneCostSlope + step(0.0, -sl.y * sign(lanePreference)) * lanePreferenceDiscount;\n\n return obstacleCost + laneCost;\n}\n\nfloat sampleDynamicCost(vec4 xytk, float time, float velocity, float acceleration) {\n vec2 sl = xy2sl(xytk);\n vec2 slTexCoords = (sl - slCenterPoint) / vec2(textureSize(slDynamicObstacleGrid, 0).xy) / vec2(slGridCellSize) + 0.5;\n float dynamicFrame = floor(time / dynamicFrameTime);\n\n float obstacleCost = texture(slDynamicObstacleGrid, vec3(slTexCoords, dynamicFrame)).r;\n\n if (obstacleCost > 0.75) return -1.0; // Infinite cost\n\n return step(0.25, obstacleCost) * obstacleHazardCost;\n}\n\nfloat calculateAverageStaticCost(int numSamples) {\n float averageStaticCost = 0.0;\n\n for (int i = 0; i < numSamples; i++) {\n float cost = sampleStaticCost(pathSamples[i]);\n\n if (cost < 0.0) return cost;\n\n averageStaticCost += cost;\n }\n\n averageStaticCost /= float(numSamples);\n\n return averageStaticCost;\n}\n\nfloat calculateAverageDynamicCost(int numSamples, float pathLength, float initialTime, float initialVelocity, float acceleration, float abandonThreshold) {\n float s = 0.0;\n float ds = pathLength / float(numSamples - 1);\n float averageDynamicCost = 0.0;\n float maxVelocity = 0.0;\n float maxLateralAcceleration = 0.0;\n float numSamples_f = float(numSamples);\n\n for (int i = 0; i < numSamples; i++) {\n vec4 pathSample = pathSamples[i]; // vec4(x-pos, y-pos, theta (rotation), kappa (curvature))\n\n float velocitySq = 2.0 * acceleration * s + initialVelocity * initialVelocity;\n float velocity = max(smallV, sqrt(max(0.0, velocitySq)));\n maxVelocity = max(maxVelocity, velocity);\n maxLateralAcceleration = max(maxLateralAcceleration, abs(pathSample.w * velocity * velocity));\n\n float time = 2.0 * s / (initialVelocity + velocity) + initialTime;\n\n float dCurv = pathSampleCurvRates[i] * velocity;\n if (dCurv > dCurvatureMax) return -1.0;\n\n float cost = sampleDynamicCost(pathSample, time, velocity, acceleration);\n if (cost < 0.0) return cost;\n\n averageDynamicCost += cost;\n if (averageDynamicCost / numSamples_f >= abandonThreshold) return -1.0;\n\n s += ds;\n }\n\n averageDynamicCost /= numSamples_f;\n\n // Apply speeding penality if any velocity along the trajectory is over the speed limit\n averageDynamicCost += step(speedLimit, maxVelocity) * speedLimitPenalty;\n\n // Apply hard acceleration/deceleration penalties if the acceleration/deceleration exceeds the soft limits\n averageDynamicCost += step(accelerationProfiles[2] + 0.0001, acceleration) * hardAccelerationPenalty;\n averageDynamicCost += (1.0 - step(accelerationProfiles[3], acceleration)) * hardDecelerationPenalty;\n\n // Penalize lateral acceleration\n averageDynamicCost += step(softLateralAccelerationLimit, maxLateralAcceleration) * softLateralAccelerationPenalty;\n averageDynamicCost += linearLateralAccelerationPenalty * maxLateralAcceleration;\n\n return averageDynamicCost;\n}\n\nvec3 calculateAVT(int accelerationIndex, float initialVelocity, float initialTime, float pathLength) {\n float initialVelocitySq = initialVelocity * initialVelocity;\n float acceleration = calculateAcceleration(accelerationIndex, initialVelocitySq, pathLength);\n\n float finalVelocitySq = 2.0 * acceleration * pathLength + initialVelocitySq;\n float finalVelocity = max(smallV, sqrt(max(0.0, finalVelocitySq)));\n\n float finalTime = initialTime;\n\n if (acceleration == 0.0) {\n finalTime += pathLength / finalVelocity;\n } else if (finalVelocitySq <= 0.0) { // Calculate final time if the vehicle stops before the end of the trajectory\n float distanceLeft = pathLength - (smallV * smallV - initialVelocitySq) / (2.0 * acceleration);\n finalTime += (finalVelocity - initialVelocity) / acceleration + distanceLeft / smallV;\n } else {\n finalTime += 2.0 * pathLength / (finalVelocity + initialVelocity);\n }\n\n return vec3(acceleration, finalVelocity, finalTime);\n}\n\n`;\n\nconst SAMPLE_CUBIC_PATH_FN = `\n\nint sampleCubicPath(vec4 start, vec4 end, vec4 cubicPathParams) {\n float p0 = start.w;\n float p1 = cubicPathParams.x;\n float p2 = cubicPathParams.y;\n float p3 = end.w;\n float sG = cubicPathParams.z;\n\n if (sG <= 0.0) return 0;\n\n int numSamples = int(ceil(sG / pathSamplingStep)) + 1;\n\n float sG_2 = sG * sG;\n float sG_3 = sG_2 * sG;\n\n float a = p0;\n float b = (-5.5 * p0 + 9.0 * p1 - 4.5 * p2 + p3) / sG;\n float c = (9.0 * p0 - 22.5 * p1 + 18.0 * p2 - 4.5 * p3) / sG_2;\n float d = (-4.5 * (p0 - 3.0 * p1 + 3.0 * p2 - p3)) / sG_3;\n\n pathSamples[0] = start;\n\n float ds = sG / float(numSamples - 1);\n float s = ds;\n vec2 dxy = vec2(0);\n vec2 prevCosSin = vec2(cos(start.z), sin(start.z));\n\n for (int i = 1; i < numSamples; i++) {\n float rot = (((d * s / 4.0 + c / 3.0) * s + b / 2.0) * s + a) * s + start.z;\n float curv = ((d * s + c) * s + b) * s + a;\n\n vec2 cosSin = vec2(cos(rot), sin(rot));\n dxy = dxy * vec2(float(i - 1) / float(i)) + (cosSin + prevCosSin) / vec2(2 * i);\n\n pathSamples[i] = vec4(dxy * vec2(s) + start.xy, rot, curv);\n pathSampleCurvRates[i] = b + s * (2.0 * c + 3.0 * d * s);\n\n s += ds;\n prevCosSin = cosSin;\n }\n\n return numSamples;\n}\n\n`;\n\nconst SAMPLE_QUINTIC_PATH_FN = `\n\nint sampleQuinticPath(vec4 start, vec4 end, vec4 quinticPathParams) {\n float p0 = start.w;\n float p1 = dCurvVehicle;\n float p2 = ddCurvVehicle;\n float p3 = quinticPathParams.x;\n float p4 = quinticPathParams.y;\n float p5 = end.w;\n float sG = quinticPathParams.z;\n\n if (sG <= 0.0) return 0;\n\n int numSamples = int(ceil(sG / pathSamplingStep)) + 1;\n\n float sG_2 = sG * sG;\n float sG_3 = sG_2 * sG;\n\n float a = p0;\n float b = p1;\n float c = p2 / 2.0;\n float d = (-71.875 * p0 + 81.0 * p3 - 10.125 * p4 + p5 - 21.25 * p1 * sG - 2.75 * p2 * sG_2) / sG_3;\n float e = (166.5 * p0 - 202.5 * p3 + 40.5 * p4 - 4.5 * p5 + 45.0 * p1 * sG + 4.5 * p2 * sG_2) / (sG_2 * sG_2);\n float f = (-95.625 * p0 + 121.5 * p3 - 30.375 * p4 + 4.5 * p5 - 24.75 * p1 * sG - 2.25 * p2 * sG_2) / (sG_2 * sG_3);\n\n pathSamples[0] = start;\n\n float ds = sG / float(numSamples - 1);\n float s = ds;\n vec2 dxy = vec2(0);\n vec2 prevCosSin = vec2(cos(start.z), sin(start.z));\n\n for (int i = 1; i < numSamples; i++) {\n float rot = (((((f * s / 6.0 + e / 5.0) * s + d / 4.0) * s + c / 3.0) * s + b / 2.0) * s + a) * s + start.z;\n float curv = ((((f * s + e) * s + d) * s + c) * s + b) * s + a;\n\n vec2 cosSin = vec2(cos(rot), sin(rot));\n dxy = dxy * vec2(float(i - 1) / float(i)) + (cosSin + prevCosSin) / vec2(2 * i);\n\n pathSamples[i] = vec4(dxy * vec2(s) + start.xy, rot, curv);\n pathSampleCurvRates[i] = b + s * (2.0 * c + s * (3.0 * d + s * (4.0 * e + 5.0 * f * s)));\n\n s += ds;\n prevCosSin = cosSin;\n }\n\n return numSamples;\n}\n\n`;\n\nconst NUM_ACCELERATION_PROFILES = 8;\nconst NUM_VELOCITY_RANGES = 4;\nconst NUM_TIME_RANGES = 2;\n\nconst SHARED_UNIFORMS = {\n xyslMap: { type: 'outputTexture' },\n slObstacleGrid: { type: 'outputTexture', name: 'slObstacleGridDilated' },\n slDynamicObstacleGrid: { type: 'outputTexture', name: 'slDynamicObstacleGrid', textureType: '2DArray' },\n accelerationProfiles: { type: 'float', length: 5 },\n finalVelocityProfiles: { type: 'float', length: 3 },\n xyCenterPoint: { type: 'vec2' },\n xyGridCellSize: { type: 'float' },\n slCenterPoint: { type: 'vec2' },\n slGridCellSize: { type: 'float'},\n laneCenterLatitude: { type: 'float'},\n laneShoulderLatitude: { type: 'float'},\n laneCostSlope: { type: 'float'},\n lanePreference: { type: 'float' },\n lanePreferenceDiscount: { type: 'float' },\n obstacleHazardCost: { type: 'float' },\n speedLimit: { type: 'float' },\n speedLimitPenalty: { type: 'float' },\n hardAccelerationPenalty: { type: 'float' },\n hardDecelerationPenalty: { type: 'float' },\n softLateralAccelerationLimit: { type: 'float' },\n softLateralAccelerationPenalty: { type: 'float' },\n linearLateralAccelerationPenalty: { type: 'float' },\n dCurvatureMax: { type: 'float' },\n pathSamplingStep: { type: 'float' },\n rearAxleToCenter: { type: 'float' },\n dynamicFrameTime: { type: 'float' }\n};\n\nfunction buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime) {\n return {\n accelerationProfiles: [3.5, -6.5, 2.0, -3.0, 0],\n finalVelocityProfiles: [0.999 * config.speedLimit, 1.0, 0.01],\n xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y],\n xyGridCellSize: config.xyGridCellSize,\n slCenterPoint: [slCenterPoint.x, slCenterPoint.y],\n slGridCellSize: config.slGridCellSize,\n laneCenterLatitude: config.laneCenterLatitude,\n laneShoulderLatitude: config.laneShoulderLatitude,\n laneCostSlope: config.laneCostSlope,\n lanePreference: config.lanePreference,\n lanePreferenceDiscount: config.lanePreferenceDiscount,\n obstacleHazardCost: config.obstacleHazardCost,\n speedLimit: config.speedLimit,\n speedLimitPenalty: config.speedLimitPenalty,\n hardAccelerationPenalty: config.hardAccelerationPenalty,\n hardDecelerationPenalty: config.hardDecelerationPenalty,\n softLateralAccelerationLimit: config.softLateralAccelerationLimit,\n softLateralAccelerationPenalty: config.softLateralAccelerationPenalty,\n linearLateralAccelerationPenalty: config.linearLateralAccelerationPenalty,\n dCurvatureMax: config.dCurvatureMax,\n pathSamplingStep: config.pathSamplingStep,\n rearAxleToCenter: config.rearAxleToCenter,\n dynamicFrameTime: dynamicFrameTime\n };\n}\n\n\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/pathFromVehicleCosts.js\n\n\nfunction fromVehiclePathCostsKernel(pathType) {\n return SHARED_SHADER + (pathType == 'cubic' ? SAMPLE_CUBIC_PATH_FN : SAMPLE_QUINTIC_PATH_FN) +\n\n`\n\n/* Calculate cost of a {cubic|quintic} path from vehicle to (stationConnectivity * numLatitudes * numAccelerations) nodes\n * width: numLatitudes\n * height: station * numAccelerations\n */\nvec4 kernel() {\n ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize));\n\n int latitude = indexes.x;\n int station = indexes.y / numAccelerations;\n int accelerationIndex = int(mod(float(indexes.y), float(numAccelerations)));\n\n vec4 pathStart = vec4(0, 0, 0, curvVehicle);\n vec4 pathEnd = texelFetch(lattice, ivec2(latitude, station), 0);\n\n vec4 pathParams = texelFetch(pathsFromVehicle, ivec2(latitude, station), 0);\n\n // If the path didn't converge\n if (pathParams.w == 0.0) return vec4(-1);\n\n int numSamples = ${pathType == 'cubic' ? 'sampleCubicPath' : 'sampleQuinticPath'}(pathStart, pathEnd, pathParams);\n float pathLength = pathParams.z;\n\n if (numSamples < 2) return vec4(-1);\n\n float averageStaticCost = calculateAverageStaticCost(numSamples);\n if (averageStaticCost < 0.0) return vec4(-1);\n\n int slIndex = station * kernelSize.x + latitude;\n float hysteresisAdjustment = (slIndex == firstLatticePoint || slIndex == secondLatticePoint) ? 0.0 : hysteresisDiscount;\n averageStaticCost += hysteresisAdjustment;\n\n vec3 avt = calculateAVT(accelerationIndex, velocityVehicle, 0.0, pathLength);\n float acceleration = avt.x;\n float finalVelocity = avt.y;\n float finalTime = avt.z;\n\n float averageDynamicCost = calculateAverageDynamicCost(numSamples, pathLength, 0.0, velocityVehicle, acceleration, 1.0 / 0.0);\n if (averageDynamicCost < 0.0) return vec4(-1);\n\n averageDynamicCost += accelerationChangePenalty;\n\n // The cost of a trajectory is the average sample cost scaled by the path length\n float totalCost = (averageStaticCost + averageDynamicCost + ${pathType == 'cubic' ? '(cubicPathPenalty * velocityVehicle * velocityVehicle)' : '0.0'}) * pathLength;\n ${pathType != 'cubic' ? 'totalCost = -1.0;' : ''}\n\n return vec4(totalCost, finalVelocity, finalTime, ${pathType == 'cubic' ? '-2' : '-1'});\n}\n\n`;\n}\n\n/* harmony default export */ const gpgpu_programs_pathFromVehicleCosts = ({\n setUp() {\n return [\n {\n kernel: fromVehiclePathCostsKernel('cubic'),\n output: { name: 'cubicPathFromVehicleCosts' },\n uniforms: Object.assign({}, SHARED_UNIFORMS, {\n lattice: { type: 'sharedTexture' },\n pathsFromVehicle: { type: 'outputTexture', name: 'cubicPathsFromVehicle' },\n firstLatticePoint: { type: 'int' },\n secondLatticePoint: { type: 'int' },\n velocityVehicle: { type: 'float' },\n curvVehicle: { type: 'float' },\n numAccelerations: { type: 'int' },\n cubicPathPenalty: { type: 'float' },\n hysteresisDiscount: { type: 'float' },\n accelerationChangePenalty: { type: 'float' }\n })\n },\n {\n kernel: fromVehiclePathCostsKernel('quintic'),\n output: { name: 'quinticPathFromVehicleCosts' },\n uniforms: Object.assign({}, SHARED_UNIFORMS, {\n lattice: { type: 'sharedTexture' },\n pathsFromVehicle: { type: 'outputTexture', name: 'quinticPathsFromVehicle' },\n firstLatticePoint: { type: 'int' },\n secondLatticePoint: { type: 'int' },\n velocityVehicle: { type: 'float' },\n curvVehicle: { type: 'float' },\n dCurvVehicle: { type: 'float' },\n ddCurvVehicle: { type: 'float' },\n numAccelerations: { type: 'int' },\n hysteresisDiscount: { type: 'float' },\n accelerationChangePenalty: { type: 'float' }\n })\n }\n ];\n },\n\n update(config, pose, xyCenterPoint, slCenterPoint, firstLatticePoint, secondLatticePoint, dynamicFrameTime) {\n return [\n {\n width: config.lattice.numLatitudes,\n height: config.lattice.stationConnectivity * NUM_ACCELERATION_PROFILES,\n uniforms: Object.assign({}, buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime), {\n firstLatticePoint: firstLatticePoint,\n secondLatticePoint: secondLatticePoint,\n velocityVehicle: pose.velocity,\n curvVehicle: pose.curv,\n numAccelerations: NUM_ACCELERATION_PROFILES,\n cubicPathPenalty: config.cubicPathPenalty,\n hysteresisDiscount: config.hysteresisDiscount,\n accelerationChangePenalty: config.accelerationChangePenalty\n })\n },\n {\n width: config.lattice.numLatitudes,\n height: config.lattice.stationConnectivity * NUM_ACCELERATION_PROFILES,\n uniforms: Object.assign({}, buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime), {\n firstLatticePoint: firstLatticePoint,\n secondLatticePoint: secondLatticePoint,\n velocityVehicle: pose.velocity,\n curvVehicle: pose.curv,\n dCurvVehicle: pose.dCurv,\n ddCurvVehicle: pose.ddCurv,\n numAccelerations: NUM_ACCELERATION_PROFILES,\n hysteresisDiscount: config.hysteresisDiscount,\n accelerationChangePenalty: config.accelerationChangePenalty\n })\n }\n ];\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/graphSearch.js\n/* State Lattice Cost Map\n * \n * 5-dimensional node: station, latitude, acceleration profile, velocity, time\n *\n * A draw call per station s\n * * Input to kernel: latitude l, acceleration profile a, velocity range v, time range t\n * * Find all SL vertices that can connect to this node\n * * For each of those vertices, check if any terminate in this specific velocity and time range\n * * Based on initial velocity, initial time, and acceleration\n * * Each connected SL vertex should have a * v * t nodes that could possibly terminate at this node\n * * For all valid edges, find the one with the lowest cost\n *\n * Input:\n * * 2D texture array cost map\n * * Height: num of latitudes (~20)\n * * Width: num of acceleration profiles * num of time ranges * num of velocity ranges (8 * 2 * 4 = ~64)\n * * A flattened 3D array:\n * d1: acceleration\n * d2: velocity\n * d3: time\n * * Layer: num of stations (~10)\n * \n * Output:\n * * 2D texture slice of the next station in the input 2D texture array cost map\n *\n * Cost Map Elements:\n * * Traversal cost so far\n * * Ending velocity\n * * Ending time\n * * Index of parent node\n *\n * Since one cubic path can be shared between multiple trajectories, they need to be pre-optimized.\n *\n * Quintic Paths:\n * Stations 0 through (numStations - 1) correspond to the stations on the lattice; however,\n * a new station (station -1) will be used to signifiy the single vehicle pose node. Either\n * a cubic path or quintic path can be used to connect this single node to the lattice\n * (depending on vehicle velocity). At station -1, latitude 0 will correspond to a cubic path,\n * and latitude 1 will correspond to a quintic path. All other latitudes will be skipped.\n */\n\n\n\nconst SOLVE_STATION_KERNEL =\n SHARED_SHADER +\n SAMPLE_CUBIC_PATH_FN +\n SAMPLE_QUINTIC_PATH_FN +\n\n`\n\nvec4 kernel() {\n ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize));\n\n int latitude = indexes.y;\n\n int numPerTime = numAccelerations * numVelocities;\n int timeIndex = indexes.x / numPerTime;\n indexes.x -= timeIndex * numPerTime;\n int velocityIndex = indexes.x / numAccelerations;\n int accelerationIndex = int(mod(float(indexes.x), float(numAccelerations)));\n\n int minLatitude = max(latitude - latitudeConnectivity / 2, 0);\n int maxLatitude = min(latitude + latitudeConnectivity / 2, numLatitudes - 1);\n\n int slIndex = station * numLatitudes + latitude;\n\n vec4 pathEnd = texelFetch(lattice, ivec2(latitude, station), 0);\n\n float minVelocity = velocityRanges[velocityIndex];\n float maxVelocity = velocityRanges[velocityIndex + 1];\n\n float minTime = timeRanges[timeIndex];\n float maxTime = timeRanges[timeIndex + 1];\n\n vec4 bestTrajectory = vec4(-1); // -1 means infinite cost\n float bestTerminalCost = 1.0 / 0.0;\n\n float hysteresisAdjustment = (slIndex == firstLatticePoint || slIndex == secondLatticePoint) ? 0.0 : hysteresisDiscount;\n\n for (int prevStation = max(station - stationConnectivity, 0); prevStation < station; prevStation++) {\n int stationConnectivityIndex = prevStation - station + stationConnectivity;\n\n for (int prevLatitude = minLatitude; prevLatitude <= maxLatitude; prevLatitude++) {\n int latitudeConnectivityIndex = prevLatitude - latitude + latitudeConnectivity / 2;\n int connectivityIndex = stationConnectivityIndex * latitudeConnectivity + latitudeConnectivityIndex;\n\n vec4 pathStart = texelFetch(lattice, ivec2(prevLatitude, prevStation), 0);\n vec4 cubicPathParams = texelFetch(cubicPaths, ivec2(slIndex, connectivityIndex), 0);\n\n // If the path didn't converge\n if (cubicPathParams.w == 0.0) continue;\n\n int numSamples = sampleCubicPath(pathStart, pathEnd, cubicPathParams);\n float pathLength = cubicPathParams.z;\n\n if (numSamples < 2) continue;\n\n float averageStaticCost = calculateAverageStaticCost(numSamples);\n if (averageStaticCost < 0.0) continue;\n\n averageStaticCost += hysteresisAdjustment;\n\n if (averageStaticCost * pathLength >= bestTerminalCost) continue;\n\n for (int prevVelocity = 0; prevVelocity < numVelocities; prevVelocity++) {\n for (int prevTime = 0; prevTime < numTimes; prevTime++) {\n for (int prevAccel = 0; prevAccel < numAccelerations; prevAccel++) {\n int avtIndex = prevTime * numPerTime + prevVelocity * numAccelerations + prevAccel;\n\n // Cost table entry:\n // x: cost so far\n // y: end velocity\n // z: end time\n // w: parent index\n vec4 costTableEntry = texelFetch(costTable, ivec3(avtIndex, prevLatitude, prevStation), 0);\n\n // If cost entry is infinity\n if (costTableEntry.x < 0.0 || averageStaticCost * pathLength + costTableEntry.x >= bestTerminalCost) continue;\n\n vec3 avt = calculateAVT(accelerationIndex, costTableEntry.y, costTableEntry.z, pathLength);\n float acceleration = avt.x;\n float finalVelocity = avt.y;\n float finalTime = avt.z;\n\n if (averageStaticCost * pathLength + costTableEntry.x + extraTimePenalty * finalTime >= bestTerminalCost) continue;\n\n // If the calculated final velocity does not match this fragment's velocity range, then skip this trajectory\n if (finalVelocity < minVelocity || finalVelocity >= maxVelocity) continue;\n\n // If the calculated final time does not match this fragment's time range, then skip this trajectory\n if (finalTime < minTime || finalTime >= maxTime) continue;\n\n float abandonThreshold = (bestTerminalCost - extraTimePenalty * finalTime - costTableEntry.x) / pathLength - averageStaticCost;\n float averageDynamicCost = calculateAverageDynamicCost(numSamples, pathLength, costTableEntry.z, costTableEntry.y, acceleration, abandonThreshold);\n if (averageDynamicCost < 0.0) continue;\n\n if (accelerationIndex != prevAccel)\n averageDynamicCost += accelerationChangePenalty;\n\n // The cost of a trajectory is the average sample cost scaled by the path length\n float totalCost = (averageStaticCost + averageDynamicCost) * pathLength + costTableEntry.x;\n\n float terminalCost = totalCost + extraTimePenalty * finalTime;\n if (terminalCost >= bestTerminalCost) continue;\n bestTerminalCost = terminalCost;\n\n int incomingIndex = avtIndex + numPerTime * numTimes * (prevLatitude + numLatitudes * prevStation);\n bestTrajectory = vec4(totalCost, finalVelocity, finalTime, incomingIndex);\n }\n }\n }\n }\n }\n\n if (station < stationConnectivity) {\n ivec2 slaIndex = ivec2(latitude, station * numAccelerations + accelerationIndex);\n\n vec4 costTableEntry = texelFetch(cubicPathFromVehicleCosts, slaIndex, 0);\n float terminalCost;\n\n if (costTableEntry.x >= 0.0) {\n terminalCost = costTableEntry.x + extraTimePenalty * costTableEntry.z;\n\n if (terminalCost < bestTerminalCost) {\n bestTerminalCost = terminalCost;\n bestTrajectory = costTableEntry;\n }\n }\n\n costTableEntry = texelFetch(quinticPathFromVehicleCosts, slaIndex, 0);\n\n if (costTableEntry.x >= 0.0) {\n terminalCost = costTableEntry.x + extraTimePenalty * costTableEntry.z;\n\n if (terminalCost < bestTerminalCost) {\n bestTerminalCost = terminalCost;\n bestTrajectory = costTableEntry;\n }\n }\n }\n\n return bestTrajectory;\n}\n\n`;\n\n/* harmony default export */ const gpgpu_programs_graphSearch = ({\n setUp() {\n return {\n kernel: SOLVE_STATION_KERNEL,\n output: { name: 'graphSearch' },\n uniforms: Object.assign({}, SHARED_UNIFORMS, {\n lattice: { type: 'sharedTexture' },\n costTable: { type: 'sharedTexture', textureType: '2DArray' },\n cubicPaths: { type: 'outputTexture' },\n cubicPathFromVehicleCosts: { type: 'outputTexture' },\n quinticPathFromVehicleCosts: { type: 'outputTexture' },\n firstLatticePoint: { type: 'int' },\n secondLatticePoint: { type: 'int' },\n velocityVehicle: { type: 'float' },\n curvVehicle: { type: 'float' },\n dCurvVehicle: { type: 'float' },\n ddCurvVehicle: { type: 'float' },\n extraTimePenalty: { type: 'float' },\n hysteresisDiscount: { type: 'float' },\n accelerationChangePenalty: { type: 'float' },\n numStations: { type: 'int' },\n numLatitudes: { type: 'int' },\n numAccelerations: { type: 'int' },\n numVelocities: { type: 'int' },\n numTimes: { type: 'int' },\n stationConnectivity: { type: 'int' },\n latitudeConnectivity: { type: 'int' },\n velocityRanges: { type: 'float', length: NUM_VELOCITY_RANGES + 1 },\n timeRanges: { type: 'float', length: NUM_TIME_RANGES + 1 },\n station: { type: 'int' } // Updated in `drawProxy`\n }),\n drawProxy: (gpgpu, program, draw) => {\n const width = NUM_ACCELERATION_PROFILES * NUM_VELOCITY_RANGES * NUM_TIME_RANGES;\n const height = program.meta.lattice.numLatitudes;\n const costTable = new Float32Array(width * height * program.meta.lattice.numStations * 4);\n\n for (let s = 0; s < program.meta.lattice.numStations; s++) {\n gpgpu.updateProgramUniforms(program, { station: s });\n draw();\n\n gpgpu.gl.readPixels(0, 0, width, height, gpgpu.gl.RGBA, gpgpu.gl.FLOAT, costTable, s * width * height * 4);\n\n gpgpu.gl.bindTexture(gpgpu.gl.TEXTURE_2D_ARRAY, gpgpu.sharedTextures.costTable);\n gpgpu.gl.copyTexSubImage3D(gpgpu.gl.TEXTURE_2D_ARRAY, 0, 0, 0, s, 0, 0, width, height);\n }\n\n gpgpu._graphSearchCostTable = costTable;\n }\n };\n },\n\n update(config, pose, xyCenterPoint, slCenterPoint, firstLatticePoint, secondLatticePoint, dynamicFrameTime) {\n return {\n width: NUM_ACCELERATION_PROFILES * NUM_VELOCITY_RANGES * NUM_TIME_RANGES,\n height: config.lattice.numLatitudes,\n meta: {\n lattice: config.lattice\n },\n uniforms: Object.assign({}, buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime), {\n firstLatticePoint: firstLatticePoint,\n secondLatticePoint: secondLatticePoint,\n velocityVehicle: pose.velocity,\n curvVehicle: pose.curv,\n dCurvVehicle: pose.dCurv,\n ddCurvVehicle: pose.ddCurv,\n extraTimePenalty: config.extraTimePenalty,\n hysteresisDiscount: config.hysteresisDiscount,\n accelerationChangePenalty: config.accelerationChangePenalty,\n numStations: config.lattice.numStations,\n numLatitudes: config.lattice.numLatitudes,\n numAccelerations: NUM_ACCELERATION_PROFILES,\n numVelocities: NUM_VELOCITY_RANGES,\n numTimes: NUM_TIME_RANGES,\n stationConnectivity: config.lattice.stationConnectivity,\n latitudeConnectivity: config.lattice.latitudeConnectivity,\n velocityRanges: [0, config.speedLimit / 3, config.speedLimit * 2 / 3, config.speedLimit, 1000000],\n timeRanges: [0, 10, 1000000]\n })\n };\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/gpgpu-programs/xyObstacleCostGrid.js\nconst XY_OBSTACLE_COST_KERNEL = `\n\nvec4 kernel() {\n vec2 xy = (kernelPosition - 0.5) * vec2(kernelSize) * vec2(xyGridCellSize) + xyCenterPoint;\n\n vec2 xyTexCoords = (xy - xyCenterPoint) / vec2(textureSize(xyslMap, 0)) / vec2(xyGridCellSize) + 0.5;\n vec2 sl = texture(xyslMap, xyTexCoords).xy;\n\n vec2 slTexCoords = (sl - slCenterPoint) / vec2(textureSize(slObstacleGrid, 0)) / vec2(slGridCellSize) + 0.5;\n return texture(slObstacleGrid, slTexCoords);\n}\n\n`;\n\n// Build XY obstacle costs using XYSL map\n/* harmony default export */ const xyObstacleCostGrid = ({\n setUp() {\n return {\n kernel: XY_OBSTACLE_COST_KERNEL,\n output: { name: 'xyObstacleCostGrid', read: true },\n uniforms: {\n xyslMap: { type: 'outputTexture' },\n slObstacleGrid: { type: 'outputTexture', name: 'slObstacleGridDilated' },\n xyCenterPoint: { type: 'vec2' },\n xyGridCellSize: { type: 'float'},\n slCenterPoint: { type: 'vec2' },\n slGridCellSize: { type: 'float'}\n }\n };\n },\n\n update(config, xyWidth, xyHeight, xyCenterPoint, slCenterPoint) {\n return {\n width: xyWidth,\n height: xyHeight,\n uniforms: {\n xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y],\n xyGridCellSize: config.xyGridCellSize,\n slCenterPoint: [slCenterPoint.x, slCenterPoint.y],\n slGridCellSize: config.slGridCellSize\n }\n };\n }\n});\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/PathPlanner.js\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nconst PathPlanner_NUM_ACCELERATION_PROFILES = 8;\nconst PathPlanner_NUM_VELOCITY_RANGES = 4;\nconst PathPlanner_NUM_TIME_RANGES = 2;\n\n/* Obstacle cost map:\n *\n * 1. Rasterize triangles from polygonal obstacles into XY-space occupancy grid\n * 2. Convert occupancy grid to SL-space\n * * Width is spatial horizon of the state lattice\n * * Height is lane width\n * * Resolution should be higher than XY-grid\n * * Get XY position from centerline texture\n * * Lookup XY in XY occupancy grid (nearest)\n * 3. Dilate SL-space grid using two passes (along station, then along latitude)\n * * collision area: half car size + 0.3m\n * * high cost area: 1 meter\n * 4. Convert back to XY-space using XYSL map\n */\n\nclass PathPlanner {\n constructor() {\n this.previousStartStation = null;\n this.previousFirstLatticePoint = -1;\n this.previousSecondLatticePoint = -1;\n this.previousFirstAcceleration = -1;\n this.previousSecondLatticePoint = -1;\n\n let start = performance.now();\n const programs = [\n xyObstacleGrid.setUp(),\n slObstacleGrid.setUp(),\n ...slObstacleGridDilation.setUp(),\n slDynamicObstacleGrid.setUp(),\n xyslMap.setUp(),\n ...optimizeCubicPaths.setUp(),\n optimizeQuinticPaths.setUp(),\n ...pathFromVehicleCosts.setUp(),\n graphSearch.setUp(),\n ].map(p => Object.assign({}, p, { width: 1, height: 1 }));\n\n this.gpgpu = new GPGPU(programs);\n }\n\n reset() {\n this.previousStartStation = null;\n this.previousFirstLatticePoint = -1;\n this.previousSecondLatticePoint = -1;\n this.previousFirstAcceleration = -1;\n this.previousSecondLatticePoint = -1;\n }\n\n plan(vehiclePose, vehicleStation, lanePath, startTime, staticObstacles, dynamicObstacles) {\n const latticeStationInterval = this._latticeStationInterval();\n\n const centerlineRaw = lanePath.sampleStations(vehicleStation, Math.ceil((this.config.spatialHorizon + latticeStationInterval) / this.config.centerlineStationInterval) + 1, this.config.centerlineStationInterval);\n\n // Transform all centerline points into vehicle frame\n const vehicleXform = vehicleTransform(vehiclePose);\n const centerline = centerlineRaw.map(c => { return { pos: c.pos.clone().applyMatrix3(vehicleXform), rot: c.rot - vehiclePose.rot, curv: c.curv } });\n\n const centerlineData = new Float32Array(centerline.length * 3);\n const maxPoint = new THREE.Vector2(0, 0);\n const minPoint = new THREE.Vector2(0, 0);\n\n for (let i = 0; i < centerline.length; i++) {\n const sample = centerline[i];\n const pos = sample.pos;\n centerlineData[i * 3 + 0] = pos.x;\n centerlineData[i * 3 + 1] = pos.y;\n centerlineData[i * 3 + 2] = sample.rot;\n\n maxPoint.max(pos);\n minPoint.min(pos);\n }\n\n const diff = maxPoint.clone().sub(minPoint);\n const xyCenterPoint = minPoint.clone().add(maxPoint).divideScalar(2);\n\n // Sizes of the xy grids (in pixels, not meters)\n const xyWidth = Math.ceil((diff.x + this.config.gridMargin * 2) / this.config.xyGridCellSize);\n const xyHeight = Math.ceil((diff.y + this.config.gridMargin * 2) / this.config.xyGridCellSize);\n\n const stationWidth = this.config.spatialHorizon + latticeStationInterval * 2;\n const slCenterPoint = new THREE.Vector2(this.config.spatialHorizon / 2, 0);\n\n // Sizes of the sl grids (in pixels, not meters)\n const slWidth = Math.ceil(stationWidth / this.config.slGridCellSize);\n const slHeight = Math.ceil((this.config.roadWidth + this.config.gridMargin * 2) / this.config.slGridCellSize);\n\n let startStation;\n\n if (this.previousStartStation === null || vehicleStation + latticeStationInterval / 2 > this.previousStartStation) {\n startStation = (this.previousStartStation === null ? vehicleStation : this.previousStartStation) + latticeStationInterval;\n this.previousStartStation = startStation;\n this.previousFirstLatticePoint -= this.config.lattice.numLatitudes;\n this.previousSecondLatticePoint -= this.config.lattice.numLatitudes;\n } else {\n startStation = this.previousStartStation;\n }\n\n const lattice = this._buildLattice(lanePath, startStation, vehiclePose.rot, vehicleXform);\n\n const temporalHorizon = this.config.spatialHorizon / this.config.speedLimit;\n const dynamicFrameTime = temporalHorizon / this.config.numDynamicFrames;\n\n for (const [i, p] of [\n xyObstacleGrid.update(this.config, xyWidth, xyHeight, xyCenterPoint, vehicleXform, staticObstacles),\n slObstacleGrid.update(this.config, slWidth, slHeight, slCenterPoint, xyCenterPoint),\n ...slObstacleGridDilation.update(this.config, slWidth, slHeight),\n slDynamicObstacleGrid.update(this.config, slWidth, slHeight, slCenterPoint, vehicleStation, startTime, dynamicFrameTime, dynamicObstacles),\n xyslMap.update(this.config, xyWidth, xyHeight, xyCenterPoint),\n ...optimizeCubicPaths.update(this.config, vehiclePose),\n optimizeQuinticPaths.update(this.config, vehiclePose),\n ...pathFromVehicleCosts.update(this.config, vehiclePose, xyCenterPoint, slCenterPoint, this.previousFirstLatticePoint, this.previousSecondLatticePoint, dynamicFrameTime),\n graphSearch.update(this.config, vehiclePose, xyCenterPoint, slCenterPoint, this.previousFirstLatticePoint, this.previousSecondLatticePoint, dynamicFrameTime)\n ].entries()) {\n this.gpgpu.updateProgram(i, p);\n }\n\n this.gpgpu.updateSharedTextures({\n centerline: {\n width: centerline.length,\n height: 1,\n channels: 3,\n filter: 'linear',\n data: centerlineData\n },\n costTable: {\n width: PathPlanner_NUM_ACCELERATION_PROFILES * PathPlanner_NUM_VELOCITY_RANGES * PathPlanner_NUM_TIME_RANGES,\n height: this.config.lattice.numLatitudes,\n depth: this.config.lattice.numStations,\n channels: 4,\n textureType: '2DArray'\n },\n lattice: {\n width: this.config.lattice.numLatitudes,\n height: this.config.lattice.numStations,\n channels: 4,\n data: lattice\n }\n });\n\n this.gpgpu._graphSearchCostTable = null;\n this.gpgpu._dynamicObstacleGrid = null;\n\n let start = performance.now();\n const outputs = this.gpgpu.run();\n const costTable = this.gpgpu._graphSearchCostTable;\n const cubicPathParams = outputs[6];\n const cubicPathFromVehicleParams = outputs[7];\n const quinticPathFromVehicleParams = outputs[8];\n\n let bestEntry = [Number.POSITIVE_INFINITY];\n let bestEntryIndex;\n const numEntries = costTable.length / 4;\n\n for (let i = 0; i < numEntries; i++) {\n const entryUnpacked = this._unpackCostTableIndex(i);\n const entry = [\n costTable[i * 4],\n costTable[i * 4 + 1],\n costTable[i * 4 + 2],\n costTable[i * 4 + 3]\n ];\n\n if (entry[0] < 0) continue;\n\n entry[0] += this._terminalCost(entryUnpacked, entry);\n\n if (entry[0] < bestEntry[0]) {\n bestEntryIndex = i;\n bestEntry = entry;\n }\n }\n\n const inverseVehicleXform = (new THREE.Matrix3()).getInverse(vehicleXform);\n let bestTrajectory = null;\n let fromVehicleSegment = null;\n let fromVehicleParams = null;\n let firstLatticePoint = -1;\n let firstAcceleration = -1;\n let secondLatticePoint = -1;\n let secondAcceleration = -1;\n\n if (isFinite(bestEntry[0])) {\n [bestTrajectory, fromVehicleSegment, fromVehicleParams, firstLatticePoint, firstAcceleration, secondLatticePoint, secondAcceleration] = this._reconstructTrajectory(\n bestEntryIndex,\n costTable,\n cubicPathParams,\n cubicPathFromVehicleParams,\n quinticPathFromVehicleParams,\n vehiclePose,\n lattice\n );\n\n fromVehicleSegment.forEach(p => {\n p.pos = p.pos.applyMatrix3(inverseVehicleXform);\n p.rot += vehiclePose.rot;\n });\n\n bestTrajectory.forEach(p => {\n p.pos = p.pos.applyMatrix3(inverseVehicleXform);\n p.rot += vehiclePose.rot;\n });\n }\n\n this.previousFirstLatticePoint = firstLatticePoint;\n this.previousFirstAcceleration = firstAcceleration;\n this.previousSecondLatticePoint = secondLatticePoint;\n this.previousSecondAcceleration = secondAcceleration;\n\n return {\n path: bestTrajectory,\n fromVehicleSegment: fromVehicleSegment,\n fromVehicleParams: fromVehicleParams,\n latticeStartStation: this.previousStartStation,\n dynamicObstacleGrid: { data: this.gpgpu._dynamicObstacleGrid, width: slWidth, height: slHeight }\n };\n }\n\n _buildLattice(lanePath, startStation, vehicleRot, vehicleXform) {\n const centerline = lanePath.sampleStations(startStation, this.config.lattice.numStations, this._latticeStationInterval());\n const offset = Math.floor(this.config.lattice.numLatitudes / 2);\n const lattice = new Float32Array(this.config.lattice.numStations * this.config.lattice.numLatitudes * 4);\n let index = 0;\n\n for (let s = 0; s < centerline.length; s++) {\n const sample = centerline[s];\n\n for (let l = 0; l < this.config.lattice.numLatitudes; l++) {\n const latitude = (l - offset) / offset * this.config.roadWidth / 2;\n const rot = sample.rot - vehicleRot;\n const pos = THREE.Vector2.fromAngle(rot + Math.PI / 2).multiplyScalar(latitude).add(sample.pos.clone().applyMatrix3(vehicleXform));\n const curv = sample.curv == 0 ? 0 : 1 / (1 / sample.curv - latitude);\n\n lattice[index++] = pos.x;\n lattice[index++] = pos.y;\n lattice[index++] = rot;\n lattice[index++] = curv;\n }\n }\n\n return lattice;\n }\n\n _latticeStationInterval() {\n return this.config.spatialHorizon / this.config.lattice.numStations;\n }\n\n _terminalCost([stationIndex, latitudeIndex, timeIndex, velocityIndex, accelerationIndex], [cost, finalVelocity, finalTime, incomingIndex]) {\n // Only consider vertices that reach the end of the spatial or temporal horizon\n if (stationIndex != this.config.lattice.numStations - 1 && finalVelocity > 0.05)\n return Number.POSITIVE_INFINITY;\n\n const station = (this.config.spatialHorizon / this.config.lattice.numStations) * (stationIndex + 1);\n\n return station * -this.config.stationReachDiscount + finalTime * this.config.extraTimePenalty;\n }\n\n _unpackCostTableIndex(index) {\n if (index < 0) return [-1, index + 2, null, null, null];\n\n const numPerTime = PathPlanner_NUM_ACCELERATION_PROFILES * PathPlanner_NUM_VELOCITY_RANGES;\n const numPerLatitude = numPerTime * PathPlanner_NUM_TIME_RANGES;\n const numPerStation = this.config.lattice.numLatitudes * numPerLatitude;\n\n const stationIndex = Math.floor(index / numPerStation);\n index -= stationIndex * numPerStation;\n\n const latitudeIndex = Math.floor(index / numPerLatitude);\n index -= latitudeIndex * numPerLatitude;\n\n const timeIndex = Math.floor(index / numPerTime);\n index -= timeIndex * numPerTime;\n\n const velocityIndex = Math.floor(index / PathPlanner_NUM_ACCELERATION_PROFILES);\n const accelerationIndex = index % PathPlanner_NUM_ACCELERATION_PROFILES;\n\n return [stationIndex, latitudeIndex, timeIndex, velocityIndex, accelerationIndex];\n }\n\n _reconstructTrajectory(index, costTable, cubicPathParams, cubicPathFromVehicleParams, quinticPathFromVehicleParams, vehiclePose, lattice) {\n let unpacked = this._unpackCostTableIndex(index);\n unpacked.push(costTable[index * 4 + 1]);\n const nodes = [unpacked];\n\n let count = 0;\n while (unpacked[0] >= 0 && count++ < 100) {\n index = costTable[index * 4 + 3];\n unpacked = this._unpackCostTableIndex(index);\n\n const finalVelocity = unpacked[0] >= 0 ? costTable[index * 4 + 1] : vehiclePose.velocity;\n unpacked.push(finalVelocity);\n\n nodes.unshift(unpacked);\n }\n if (count >= 100) throw new Error('Infinite loop encountered while reconstructing trajectory.');\n\n const points = [];\n let fromVehicleSegment = [];\n let fromVehicleParams = null;\n\n for (let i = 0; i < nodes.length - 1; i++) {\n const [prevStation, prevLatitude, _pt, _pv, _pa, prevVelocity] = nodes[i];\n const [station, latitude, _t, _v, _a, velocity] = nodes[i + 1];\n\n let length;\n let pathBuilder;\n\n if (prevStation < 0) {\n const start = {\n pos: new THREE.Vector2(0, 0),\n rot: 0,\n curv: vehiclePose.curv\n };\n\n const endIndex = (station * this.config.lattice.numLatitudes + latitude) * 4;\n const end = {\n pos: new THREE.Vector2(lattice[endIndex], lattice[endIndex + 1]),\n rot: lattice[endIndex + 2],\n curv: lattice[endIndex + 3]\n };\n\n if (prevLatitude == 0) { // Cubic path from vehicle to lattice node\n length = cubicPathFromVehicleParams[endIndex + 2];\n\n const params = {\n p1: cubicPathFromVehicleParams[endIndex],\n p2: cubicPathFromVehicleParams[endIndex + 1],\n sG: length\n };\n\n pathBuilder = new CubicPath(start, end, params);\n\n fromVehicleParams = { type: 'cubic', params: params };\n } else { // Quintic path from vehicle to lattice node\n length = quinticPathFromVehicleParams[endIndex + 2];\n\n const params = {\n p3: quinticPathFromVehicleParams[endIndex],\n p4: quinticPathFromVehicleParams[endIndex + 1],\n sG: length\n };\n\n pathBuilder = new QuinticPath(start, end, params);\n\n fromVehicleParams = { type: 'quintic', params: params };\n }\n } else {\n const startIndex = (prevStation * this.config.lattice.numLatitudes + prevLatitude) * 4;\n const endIndex = (station * this.config.lattice.numLatitudes + latitude) * 4;\n\n const start = {\n pos: new THREE.Vector2(lattice[startIndex], lattice[startIndex + 1]),\n rot: lattice[startIndex + 2],\n curv: lattice[startIndex + 3]\n };\n\n const end = {\n pos: new THREE.Vector2(lattice[endIndex], lattice[endIndex + 1]),\n rot: lattice[endIndex + 2],\n curv: lattice[endIndex + 3]\n };\n\n const slIndex = station * this.config.lattice.numLatitudes + latitude;\n const connectivityIndex = (prevStation - station + this.config.lattice.stationConnectivity) * this.config.lattice.latitudeConnectivity + prevLatitude - latitude + Math.floor(this.config.lattice.latitudeConnectivity / 2);\n const cubicPathIndex = (connectivityIndex * this.config.lattice.numStations * this.config.lattice.numLatitudes + slIndex) * 4;\n\n length = cubicPathParams[cubicPathIndex + 2];\n\n pathBuilder = new CubicPath(start, end, {\n p1: cubicPathParams[cubicPathIndex],\n p2: cubicPathParams[cubicPathIndex + 1],\n sG: length\n });\n }\n\n const path = pathBuilder.buildPath(Math.ceil(length / 0.25));\n\n const prevVelocitySq = prevVelocity * prevVelocity;\n const accel = (velocity * velocity - prevVelocitySq) / 2 / length;\n const ds = length / (path.length - 1);\n let s = 0;\n\n for (let p = 0; p < path.length; p++) {\n path[p].velocity = Math.sqrt(2 * accel * s + prevVelocitySq);\n path[p].acceleration = accel;\n s += ds;\n }\n\n if (prevStation < 0) {\n fromVehicleSegment = path;\n } else {\n if (i > 0) path.shift();\n points.push(...path);\n }\n }\n\n let firstLatticePoint = null\n let firstAcceleration = null;\n let secondLatticePoint = null;\n let secondAcceleration = null;\n\n if (nodes.length >= 2) {\n firstLatticePoint = nodes[1][0] * this.config.lattice.numLatitudes + nodes[1][1];\n firstAcceleration = nodes[1][4];\n }\n\n if (nodes.length >= 3) {\n secondLatticePoint = nodes[2][0] * this.config.lattice.numLatitudes + nodes[2][1];\n secondAcceleration = nodes[2][4];\n }\n\n return [points, fromVehicleSegment, fromVehicleParams, firstLatticePoint, firstAcceleration, secondLatticePoint, secondAcceleration];\n }\n}\n\nfunction vehicleTransform({ pos, rot }) {\n const translate = new THREE.Matrix3();\n translate.set(\n 1, 0, -pos.x,\n 0, 1, -pos.y,\n 0, 0, 1\n );\n\n const cosRot = Math.cos(rot);\n const sinRot = Math.sin(rot);\n\n const rotate = new THREE.Matrix3();\n rotate.set(\n cosRot, sinRot, 0,\n -sinRot, cosRot, 0,\n 0, 0, 1\n );\n\n return rotate.multiply(translate);\n}\n\nfunction obstacleTransform(vehicleXform, xyCenterPoint, width, height) {\n const translate = new THREE.Matrix3();\n translate.set(\n 1, 0, -xyCenterPoint.x,\n 0, 1, -xyCenterPoint.y,\n 0, 0, 1\n );\n\n const scale = new THREE.Matrix3();\n scale.set(\n 2 / width, 0, 0,\n 0, 2 / height, 0,\n 0, 0, 1\n );\n\n return scale.multiply(translate).multiply(vehicleXform);\n}\n\n;// CONCATENATED MODULE: ./js/autonomy/path-planning/ExternalPlanner.js\n\nclass ExternalPathPlanner {\n _PLANNING_SERVER_URL = 'http://127.0.0.1:9999/'\n\n plan(vehiclePose, vehicleStation, lanePath, startTime, staticObstacles, dynamicObstacles) {\n const state = {\n vehiclePose: vehiclePose,\n vehicleStation: vehicleStation,\n lanePath: lanePath,\n startTime: startTime,\n staticObstacles: staticObstacles,\n dynamicObstacles: dynamicObstacles,\n };\n\n var jsonToSend = JSON.stringify(state);\n const response = this._send_request(jsonToSend, 'plan');\n const path = JSON.parse(response)['states'];\n\n return {\n planner_state: \"ok\",\n path: path,\n fromVehicleSegment: [],\n fromVehicleParams: { type:'null' },\n latticeStartStation: null,\n dynamicObstacleGrid: null\n };\n }\n\n reset() {\n //this.notify_scenario_status({status: \"restart\"});\n }\n\n notify_scenario_status(status) {\n var jsonToSend = JSON.stringify(status);\n this._send_request(jsonToSend, 'notify_case_status');\n }\n\n _send_request(jsonToSend, request_name) {\n var url = this._PLANNING_SERVER_URL + request_name;\n\n var xhr = new XMLHttpRequest();\n xhr.timeout = 5000;\n xhr.open('POST', url, false); // the 'false' makes the request synchronous\n xhr.setRequestHeader('Content-Type', 'application/json');\n xhr.send(jsonToSend);\n\n if (xhr.status === 200) {\n return xhr.responseText;\n } else {\n console.error('There was an error with the request');\n }\n }\n}\n\n;// CONCATENATED MODULE: ./js/autonomy/LanePath.js\nconst halfLaneWidth = 3.7;\n\nconst centerlineGeometry = new THREE.Geometry();\nconst leftBoundaryGeometry = new THREE.Geometry();\nconst rightBoundaryGeometry = new THREE.Geometry();\n\nclass LanePath {\n static hydrate(obj) {\n Object.setPrototypeOf(obj, LanePath.prototype);\n }\n\n constructor() {\n this.anchors = [];\n this.centerlines = [];\n this.sampleLengths = [];\n this.arcLengths = [];\n this.leftBoundaries = [];\n this.rightBoundaries = [];\n }\n\n get centerline() {\n return [].concat(...this.centerlines);\n }\n\n get leftBoundary() {\n return [].concat(...this.leftBoundaries);\n }\n\n get rightBoundary() {\n return [].concat(...this.rightBoundaries);\n }\n\n get arcLength() {\n return this.arcLengths.reduce((sum, l) => sum + l, 0);\n }\n\n sampleStations(startStation, num, interval) {\n const samples = [];\n let anchorIndex = 0;\n let sampleIndex = 0;\n let totalLength = 0;\n let nextStation = startStation;\n\n while (totalLength + this.arcLengths[anchorIndex] < nextStation) {\n totalLength += this.arcLengths[anchorIndex];\n\n if (++anchorIndex >= this.arcLengths.length)\n return samples;\n }\n\n for (let i = 0; i < num; i++) {\n let length = this.sampleLengths[anchorIndex][sampleIndex];\n while (totalLength + length < nextStation) {\n totalLength += length;\n\n if (++sampleIndex >= this.sampleLengths[anchorIndex].length) {\n sampleIndex = 0;\n\n if (++anchorIndex >= this.sampleLengths.length)\n return samples;\n }\n\n length = this.sampleLengths[anchorIndex][sampleIndex];\n }\n\n const [p0, p1, p2, p3] = this.anchorsForSplineIndex(anchorIndex);\n const weight = (sampleIndex + (nextStation - totalLength) / length) / this.sampleLengths[anchorIndex].length;\n const pos = catmullRomVec(weight, p0, p1, p2, p3);\n const tangent = tangentAt(weight, p0, p1, p2, p3);\n const rot = Math.atan2(tangent.y, tangent.x);\n const curv = curvatureAt(weight, p0, p1, p2, p3);\n\n samples.push({ pos, rot, curv });\n nextStation += interval;\n }\n\n return samples;\n }\n\n stationLatitudeFromPosition(position, aroundAnchorIndex = null) {\n const [anchorIndex, sampleIndex, sampleStation, prevSampleStation] = this._findClosestSample(position, aroundAnchorIndex);\n\n if (anchorIndex === undefined) return [0, 0, 0];\n\n let prevPoint;\n let nextPoint;\n let prevStation;\n let nextStation;\n\n if (anchorIndex == 0 && sampleIndex == 0) {\n prevPoint = this.centerlines[anchorIndex][sampleIndex];\n nextPoint = this.centerlines[anchorIndex][sampleIndex + 1];\n prevStation = 0;\n nextStation = this.sampleLengths[anchorIndex][sampleIndex];\n } else if (anchorIndex == this.centerlines.length - 1 && sampleIndex == this.centerlines[anchorIndex].length - 1) {\n prevPoint = this.centerlines[anchorIndex][sampleIndex - 1];\n nextPoint = this.centerlines[anchorIndex][sampleIndex];\n prevStation = prevSampleStation;\n nextStation = sampleStation;\n } else {\n prevPoint = sampleIndex == 0 ? this.centerlines[anchorIndex - 1][this.centerlines[anchorIndex - 1].length - 1] : this.centerlines[anchorIndex][sampleIndex - 1];\n nextPoint = sampleIndex == this.centerlines[anchorIndex].length - 1 ? this.centerlines[anchorIndex + 1][0] : this.centerlines[anchorIndex][sampleIndex + 1];\n\n const possibleNext = this.centerlines[anchorIndex][sampleIndex];\n const possibleProgress = position.clone().sub(prevPoint).dot(possibleNext.clone().sub(prevPoint)) / prevPoint.distanceToSquared(possibleNext);\n\n if (possibleProgress < 1) {\n nextPoint = possibleNext;\n prevStation = prevSampleStation;\n nextStation = sampleStation;\n } else {\n prevPoint = possibleNext;\n prevStation = sampleStation;\n nextStation = sampleStation + this.sampleLengths[anchorIndex][sampleIndex];\n }\n }\n\n const progress = Math.clamp(position.clone().sub(prevPoint).dot(nextPoint.clone().sub(prevPoint)) / prevPoint.distanceToSquared(nextPoint), 0, 1);\n const projectedPosition = nextPoint.clone().sub(prevPoint).multiplyScalar(progress).add(prevPoint);\n\n const station = prevStation + (nextStation - prevStation) * progress;\n const latitude = Math.sign((nextPoint.x - prevPoint.x) * (position.y - prevPoint.y) - (nextPoint.y - prevPoint.y) * (position.x - prevPoint.x)) * position.distanceTo(projectedPosition);\n\n return [station, latitude, anchorIndex];\n }\n\n _findClosestSample(position, aroundAnchorIndex = null) {\n let closest = Number.POSITIVE_INFINITY;\n let bestAnchorIndex;\n let bestSampleIndex;\n let bestStation;\n let bestPrevStation;\n\n let currStation = 0;\n let prevStation = 0;\n\n let startAnchorIndex = 0;\n let endAnchorIndex = this.centerlines.length - 1;\n\n if (aroundAnchorIndex !== null) {\n startAnchorIndex = Math.max(0, aroundAnchorIndex - 2);\n endAnchorIndex = Math.min(this.centerlines.length - 1, aroundAnchorIndex + 2);\n }\n\n if (startAnchorIndex > 0) {\n for (let anchorIndex = 0; anchorIndex < startAnchorIndex; anchorIndex++) {\n currStation += this.arcLengths[anchorIndex];\n }\n\n prevStation = currStation - this.sampleLengths[startAnchorIndex - 1][this.sampleLengths[startAnchorIndex - 1].length - 1];\n }\n\n for (let anchorIndex = startAnchorIndex; anchorIndex <= endAnchorIndex; anchorIndex++) {\n const centerline = this.centerlines[anchorIndex];\n for (let sampleIndex = 0; sampleIndex < centerline.length; sampleIndex++) {\n const distSq = position.distanceToSquared(centerline[sampleIndex]);\n if (distSq < closest) {\n closest = distSq;\n bestAnchorIndex = anchorIndex;\n bestSampleIndex = sampleIndex;\n bestStation = currStation;\n bestPrevStation = prevStation;\n }\n\n prevStation = currStation;\n currStation += this.sampleLengths[anchorIndex][sampleIndex];\n }\n }\n\n return [bestAnchorIndex, bestSampleIndex, bestStation, bestPrevStation];\n }\n\n addAnchor(position, resample = true) {\n const index = this.anchors.push(position) - 1;\n\n if (resample) {\n for (let i = index - 2; i < index; i++)\n this.resample(i);\n }\n }\n\n updateAnchor(index, position) {\n this.anchors[index] = position;\n\n for (let i = index - 2; i <= index + 1; i++)\n this.resample(i);\n }\n\n removeAnchor(index) {\n if (index < 0 || index >= this.anchors.length) return;\n\n this.anchors.splice(index, 1);\n\n const segmentIndex = index < this.anchors.length ? index : index - 1;\n this.centerlines.splice(segmentIndex, 1);\n this.sampleLengths.splice(segmentIndex, 1);\n this.leftBoundaries.splice(segmentIndex, 1);\n this.rightBoundaries.splice(segmentIndex, 1);\n this.arcLengths.splice(segmentIndex, 1);\n\n for (let i = segmentIndex - 2; i <= segmentIndex; i++)\n this.resample(i);\n }\n\n resample(index) {\n if (index < 0 || index > this.anchors.length - 2) return;\n\n const [p0, p1, p2, p3] = this.anchorsForSplineIndex(index);\n const points = [];\n const lengths = [];\n const leftBoundary = [];\n const rightBoundary = [];\n let prevPoint = null;\n\n const pointsPerSegment = Math.max(10, Math.ceil(p1.distanceTo(p2) / 1));\n const numPoints = index == this.anchors.length - 2 ? pointsPerSegment + 1 : pointsPerSegment;\n\n for (let i = 0; i < numPoints; i++) {\n const t = i / pointsPerSegment;\n const point = catmullRomVec(t, p0, p1, p2, p3);\n points.push(point);\n\n if (prevPoint != null)\n lengths.push(prevPoint.distanceTo(point));\n prevPoint = point;\n\n const tangent = tangentAt(t, p0, p1, p2, p3);\n const normal = new THREE.Vector2(-tangent.y, tangent.x);\n\n leftBoundary.push(normal.clone().multiplyScalar(-halfLaneWidth).add(point));\n rightBoundary.push(normal.clone().multiplyScalar(halfLaneWidth).add(point));\n }\n\n lengths.push(prevPoint.distanceTo(p2));\n\n this.centerlines[index] = points;\n this.sampleLengths[index] = lengths;\n this.leftBoundaries[index] = leftBoundary;\n this.rightBoundaries[index] = rightBoundary;\n this.arcLengths[index] = lengths.reduce((sum, l) => sum + l, 0);\n }\n\n resampleAll() {\n for (let i = 0; i < this.anchors.length; i++)\n this.resample(i);\n }\n\n anchorsForSplineIndex(index) {\n let p;\n if (index == 0)\n p = [this.anchors[0]].concat(this.anchors.slice(0, 3));\n else\n p = this.anchors.slice(index - 1, index + 3);\n\n if (p[3] === undefined)\n p[3] = p[2];\n\n return p;\n }\n}\n\nfunction catmullRom(t, p0, p1, p2, p3) {\n const v0 = (p2 - p0) * 0.5;\n const v1 = (p3 - p1) * 0.5;\n const t2 = t * t;\n const t3 = t * t2;\n return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;\n}\n\nfunction catmullRomVec(t, p0, p1, p2, p3) {\n return new THREE.Vector2(catmullRom(t, p0.x, p1.x, p2.x, p3.x), catmullRom(t, p0.y, p1.y, p2.y, p3.y));\n}\n\nfunction tangentAt(t, p0, p1, p2, p3) {\n const delta = 0.0001;\n let t1 = t - delta;\n let t2 = t + delta;\n\n if (t1 < 0) t1 = 0;\n if (t2 > 1) t2 = 1;\n\n const prev = catmullRomVec(t1, p0, p1, p2, p3);\n const next = catmullRomVec(t2, p0, p1, p2, p3);\n\n return next.sub(prev).normalize();\n}\n\nfunction curvatureAt(t2, p0, p1, p2, p3) {\n const delta = 0.0001;\n\n // If we're estimating curvature at one of the endpoints of the spline,\n // slightly shift it inwards to avoid infinite curvature.\n if (t2 == 0) t2 = delta;\n if (t2 == 1) t2 = 1 - delta;\n\n let t1 = t2 - delta;\n let t3 = t2 + delta;\n\n if (t1 < 0) t1 = 0;\n if (t3 > 1) t3 = 1;\n\n const pt1 = catmullRomVec(t1, p0, p1, p2, p3);\n const pt2 = catmullRomVec(t2, p0, p1, p2, p3);\n const pt3 = catmullRomVec(t3, p0, p1, p2, p3);\n\n return (Math.atan2(pt3.y - pt2.y, pt3.x - pt2.x) - Math.atan2(pt2.y - pt1.y, pt2.x - pt1.x)) / pt2.distanceTo(pt1);\n}\n\n;// CONCATENATED MODULE: ./js/autonomy/StaticObstacle.js\nclass StaticObstacle {\n static hydrate(obj) {\n Object.setPrototypeOf(obj, StaticObstacle.prototype);\n Object.setPrototypeOf(obj.pos, THREE.Vector2.prototype);\n }\n\n static fromJSON(json) {\n return new StaticObstacle(new THREE.Vector2(json.p[0], json.p[1]), json.r, json.w, json.h);\n }\n\n constructor(pos, rot, width, height) {\n this.pos = pos;\n this.rot = rot;\n this.width = width;\n this.height = height;\n\n this.updateVertices();\n }\n\n toJSON() {\n const trunc = n => +n.toFixed(5);\n\n return {\n p: [trunc(this.pos.x), trunc(this.pos.y)],\n r: trunc(this.rot),\n w: trunc(this.width),\n h: trunc(this.height)\n };\n }\n\n updateVertices() {\n this.vertices = [];\n\n const cosRot = Math.cos(this.rot);\n const sinRot = Math.sin(this.rot);\n const halfWidth = this.width / 2;\n const halfHeight = this.height / 2;\n\n const hWcR = halfWidth * cosRot;\n const hWsR = halfWidth * sinRot;\n const hHcR = halfHeight * cosRot;\n const hHsR = halfHeight * sinRot;\n\n const v1 = [-hWcR - hHsR + this.pos.x, -hWsR + hHcR + this.pos.y];\n const v2 = [-hWcR + hHsR + this.pos.x, -hWsR - hHcR + this.pos.y];\n const v3 = [hWcR + hHsR + this.pos.x, hWsR - hHcR + this.pos.y];\n const v4 = [hWcR - hHsR + this.pos.x, hWsR + hHcR + this.pos.y];\n\n this.vertices = [\n v1[0], v1[1],\n v2[0], v2[1],\n v3[0], v3[1],\n v3[0], v3[1],\n v4[0], v4[1],\n v1[0], v1[1]\n ];\n }\n}\n\n;// CONCATENATED MODULE: ./js/autonomy/DynamicObstacle.js\n// Half width and half height\nconst VEHICLE_SIZE = { w: 2.5, h: 1 };\nconst CYCLIST_SIZE = { w: 1.2, h: 0.6 };\nconst PEDESTRIAN_SIZE = { w: 0.6, h: 0.6 };\n\nclass DynamicObstacle {\n static hydrate(obj) {\n Object.setPrototypeOf(obj, DynamicObstacle.prototype);\n Object.setPrototypeOf(obj.startPos, THREE.Vector2.prototype);\n Object.setPrototypeOf(obj.velocity, THREE.Vector2.prototype);\n }\n\n constructor(type, startPos, velocity, parallel) {\n this.type = type;\n this.startPos = startPos;\n this.velocity = velocity;\n this.parallel = parallel;\n\n switch (type) {\n case 'cyclist':\n this.size = Object.assign({}, CYCLIST_SIZE);\n break;\n\n case 'pedestrian':\n this.size = Object.assign({}, PEDESTRIAN_SIZE);\n break;\n\n default:\n this.size = Object.assign({}, VEHICLE_SIZE);\n }\n\n if (!parallel)\n [this.size.w, this.size.h] = [this.size.h, this.size.w];\n }\n\n positionAtTime(time) {\n return this.velocity.clone().multiplyScalar(time).add(this.startPos);\n }\n\n positionsInTimeRange(startTime, endTime, numFrames) {\n const dt = (endTime - startTime) / numFrames;\n const positions = [];\n let time = startTime;\n\n for (let i = 0; i <= numFrames; i++) {\n positions.push(this.positionAtTime(time));\n time += dt;\n }\n\n return positions;\n }\n\n verticesInTimeRange(startTime, endTime, config) {\n const positions = this.positionsInTimeRange(startTime, endTime, config.numDynamicSubframes);\n const vertices = [];\n\n // Hazard dilation (drawn behind, z = 0.75)\n const hazardHalfWidth = this.size.w + config.dynamicHazardDilationS + config.collisionDilationS;\n const hazardHalfHeight = this.size.h + config.dynamicHazardDilationL + config.collisionDilationL;\n\n positions.forEach(p => {\n const v1 = [-hazardHalfWidth + p.x, hazardHalfHeight + p.y];\n const v2 = [hazardHalfWidth + p.x, hazardHalfHeight + p.y];\n const v3 = [hazardHalfWidth + p.x, -hazardHalfHeight + p.y];\n const v4 = [-hazardHalfWidth + p.x, -hazardHalfHeight + p.y];\n\n vertices.push(\n v1[0], v1[1], 0.75,\n v2[0], v2[1], 0.75,\n v3[0], v3[1], 0.75,\n v3[0], v3[1], 0.75,\n v4[0], v4[1], 0.75,\n v1[0], v1[1], 0.75\n );\n });\n\n // Collision dilation (drawn in front, z = 0.25)\n const collisionHalfWidth = this.size.w + config.collisionDilationS;\n const collisionHalfHeight = this.size.h + config.collisionDilationL;\n\n positions.forEach(p => {\n const v1 = [-collisionHalfWidth + p.x, collisionHalfHeight + p.y];\n const v2 = [collisionHalfWidth + p.x, collisionHalfHeight + p.y];\n const v3 = [collisionHalfWidth + p.x, -collisionHalfHeight + p.y];\n const v4 = [-collisionHalfWidth + p.x, -collisionHalfHeight + p.y];\n\n vertices.push(\n v1[0], v1[1], 0.25,\n v2[0], v2[1], 0.25,\n v3[0], v3[1], 0.25,\n v3[0], v3[1], 0.25,\n v4[0], v4[1], 0.25,\n v1[0], v1[1], 0.25\n );\n });\n\n return vertices;\n }\n}\n\n;// CONCATENATED MODULE: ./workers/PathPlannerWorker.js\n\n\n\n\n\n\n\n\nfunction init() {\n let pathPlanner;\n try {\n // pathPlanner = new PathPlanner();\n pathPlanner = new ExternalPathPlanner()\n } catch (e) {\n console.log('Error initializing path planner:');\n console.log(e);\n self.postMessage({ error: \"initialization_failed\" });\n return;\n }\n\n self.onmessage = function(event) {\n if (event.data.type === 'notify_case_status') {\n pathPlanner.notify_scenario_status(event.data.status);\n return;\n }\n if (event.data.type != 'plan') {\n console.log(\"unkonwn posted message type: \" + event);\n return;\n }\n\n const { config, vehiclePose, vehicleStation, lanePath, startTime, staticObstacles, dynamicObstacles, reset } = event.data;\n\n LanePath.hydrate(lanePath);\n staticObstacles.forEach(o => StaticObstacle.hydrate(o));\n dynamicObstacles.forEach(o => DynamicObstacle.hydrate(o));\n\n if (reset) pathPlanner.reset();\n\n pathPlanner.config = config;\n\n let should_retry = true;\n while (should_retry) {\n let planner_result;\n try {\n planner_result = pathPlanner.plan(vehiclePose, vehicleStation, lanePath, startTime, staticObstacles, dynamicObstacles);\n should_retry = planner_result.planner_state == \"unavailable\";\n } catch (error) {\n if (error.name != \"TimeoutError\" && error.name != \"NetworkError\") {\n console.log('Planning request error: ');\n console.log(error);\n self.postMessage({ error: error.toString() });\n should_retry = false;\n break;\n }\n }\n\n if (should_retry) {\n self.postMessage({ error: \"planner_unavailable\" });\n } else {\n const {\n path,\n fromVehicleSegment,\n fromVehicleParams,\n latticeStartStation,\n dynamicObstacleGrid\n } = planner_result;\n\n self.postMessage({\n path,\n fromVehicleSegment,\n fromVehicleParams,\n vehiclePose,\n vehicleStation,\n latticeStartStation,\n config,\n dynamicObstacleGrid });\n }\n }\n };\n}\n\nif (typeof(window) === 'undefined') {\n init();\n} else {\n window.dash_initPathPlannerWorker = init;\n}\n//# sourceURL=[module]\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"691.js","mappings":";;;;;;AAAe;AACf;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,aAAa;AACb;;AAEA;AACA;AACA;;AAEA;AACA,YAAY,OAAO;AACnB;AACA;AACA;;AAEA;AACA,YAAY,OAAO;AACnB;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB,qBAAqB;AACrB;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;;AAEA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;;AAEA,2BAA2B;AAC3B,wBAAwB;AACxB,8BAA8B;AAC9B,6BAA6B;AAC7B,0CAA0C;AAC1C,iBAAiB;AACjB;AACA,gCAAgC;AAChC,yBAAyB;AACzB;AACA,0BAA0B,OAAO;AACjC,yBAAyB;AACzB,2BAA2B;AAC3B,+BAA+B;AAC/B,0BAA0B;AAC1B,2BAA2B;AAC3B,yDAAyD;AACzD,8BAA8B;;;ACzH9B;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACe,MAAM,mBAAS;AAC9B;AACA,iCAAiC;AACjC,+BAA+B;;AAE/B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,oCAAoC,YAAY,wCAAwC;AACxF;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,oBAAoB,2BAA2B;AAC/C;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,oBAAoB,uBAAuB;AAC3C;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,YAAY,qBAAqB;;AAEjC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,2BAA2B,yBAAyB;AACpD;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,YAAY,qBAAqB;;AAEjC;AACA;;AAEA;AACA;AACA;AACA;;AAEA,oBAAoB,gGAAgG;AACpH;AACA;AACA;AACA;AACA;AACA;;AAEA,oBAAoB,aAAa;AACjC;AACA;AACA;AACA;;AAEA;AACA;;AAEA,kBAAkB,4FAA4F;;AAE9G;AACA;AACA;AACA;;AAEA,gBAAgB,wFAAwF;;AAExG;AACA;AACA;;;AC5MA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,oEAAe;AACf;AACA;AACA;AACA;AACA,gBAAgB,wBAAwB;AACxC;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,CAAC;;;AC1ED;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA,oEAAe;AACf;AACA;AACA;AACA,gBAAgB,wBAAwB;AACxC;AACA,0BAA0B,uBAAuB;AACjD,0BAA0B,eAAe;AACzC,0BAA0B,eAAe;AACzC,yBAAyB,cAAc;AACvC,yBAAyB,cAAc;AACvC,qCAAqC,eAAe;AACpD,sBAAsB;AACtB;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;AClDD;;AAEA;AACA;AACA;;AAEA,kBAAkB,wBAAwB;AAC1C;AACA;AACA;;AAEA,sCAAsC,yCAAyC;AAC/E;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA,4EAAe;AACf;AACA;AACA,QAAQ;AACR;AACA,kBAAkB,sCAAsC;AACxD;AACA,4BAA4B,uBAAuB;AACnD,mBAAmB,cAAc;AACjC,+BAA+B,aAAa;AAC5C,4BAA4B;AAC5B;AACA,OAAO;AACP,QAAQ;AACR;AACA,kBAAkB,+BAA+B;AACjD;AACA,4BAA4B,6DAA6D;AACzF,mBAAmB,cAAc;AACjC,+BAA+B,aAAa;AAC5C,4BAA4B;AAC5B;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;ACvED;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,IAAI,sCAAgB;AACpB,IAAI,mCAAa;AACjB;;AAEA;AACA,2EAAe;AACf;AACA;AACA;AACA;AACA,gBAAgB,gFAAgF;AAChG;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA,4BAA4B,0BAA0B;AACtD;AACA;AACA;AACA;;AAEA;AACA;;AAEA,cAAc,sCAAgB;AAC9B;;AAEA;AACA,2CAA2C,sCAAgB;AAC3D;AACA;;AAEA;AACA,sDAAsD,mCAAa;;AAEnE,2CAA2C,sCAAgB;;AAE3D;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA,IAAI,sCAAgB;;AAEpB;AACA,wBAAwB,0BAA0B;AAClD;AACA,MAAM,sCAAgB;AACtB;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,IAAI,mCAAa;;AAEjB;AACA;AACA;AACA;AACA;AACA,CAAC;;;AClHD;;AAEA;AACA;;AAEA;AACA;AACA;AACA,kBAAkB,gBAAgB;AAClC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,6DAAe;AACf;AACA;AACA;AACA,gBAAgB,mCAAmC;AACnD;AACA,sBAAsB,uBAAuB;AAC7C,yBAAyB,cAAc;AACvC,0BAA0B,cAAc;AACxC,qCAAqC;AACrC;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;ACvFD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,kBAAkB,yBAAyB;AAC3C;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,kBAAkB,2BAA2B;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,kBAAkB,uBAAuB;AACzC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA,wEAAe;AACf;AACA;AACA,QAAQ;AACR;AACA,kBAAkB,gCAAgC;AAClD;AACA,qBAAqB,uBAAuB;AAC5C,yBAAyB,aAAa;AACtC,0BAA0B,aAAa;AACvC,iCAAiC,aAAa;AAC9C,kCAAkC;AAClC;AACA,OAAO;AACP,QAAQ;AACR;AACA,kBAAkB,2CAA2C;AAC7D;AACA,qBAAqB,uBAAuB;AAC5C,yBAAyB;AACzB;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;AC5QD;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,kBAAkB,yBAAyB;AAC3C;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,kBAAkB,2BAA2B;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,kBAAkB,uBAAuB;AACzC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,0EAAe;AACf;AACA;AACA;AACA,gBAAgB,6CAA6C;AAC7D;AACA,mBAAmB,uBAAuB;AAC1C,uBAAuB,eAAe;AACtC,wBAAwB,eAAe;AACvC,yBAAyB;AACzB;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;AC3MD;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,yCAAyC;;AAEzC;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA,wCAAwC;;AAExC;AACA;;AAEA;AACA;;AAEA,kBAAkB,gBAAgB;AAClC;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,kBAAkB,gBAAgB;AAClC,sCAAsC;;AAEtC;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA,IAAI,mCAAmC;AACvC;AACA;AACA,IAAI;AACJ;AACA;;AAEA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA,kBAAkB,g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AwB,sCAAsC;AAC9D,iDAAiD,YAAY;AAC7D;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA,aAAa,yBAAyB,GAAG,mBAAmB,GAAG,eAAe;AAC9E;AACA;AACA;AACA,OAAO;AACP,gCAAgC,EAAE,kBAAkB;AACpD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B,yBAAyB;AACnD,uBAAuB,mBAAmB;AAC1C,kBAAkB,eAAe;AACjC;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,CAAC;;;AC1QD;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA,yDAAe;AACf;AACA;AACA;AACA,gBAAgB,wCAAwC;AACxD;AACA,mBAAmB,uBAAuB;AAC1C,0BAA0B,sDAAsD;AAChF,yBAAyB,cAAc;AACvC,0BAA0B,cAAc;AACxC,yBAAyB,cAAc;AACvC,0BAA0B;AAC1B;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;AC3CkC;AACI;AACA;AACI;AACqB;AACA;AACgB;AACF;AAC5B;AACsB;AACI;AACA;AAClB;AACc;;AAExE,MAAM,qCAAyB;AAC/B,MAAM,+BAAmB;AACzB,MAAM,2BAAe;;AAErB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEe;AACf;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,OAAO,qBAAqB;;AAE3D;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA,gDAAgD,SAAS,6FAA6F;;AAEtJ;AACA;AACA;;AAEA,oBAAoB,uBAAuB;AAC3C;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA,eAAe,qCAAyB,GAAG,+BAAmB,GAAG,2BAAe;AAChF;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,oBAAoB,gBAAgB;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,OAAO;;AAEP;AACA;AACA;AACA,OAAO;AACP;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,6BAA6B;AAC7B;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,oBAAoB,uBAAuB;AAC3C;;AAEA,sBAAsB,sCAAsC;AAC5D;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA,uBAAuB,qCAAyB,GAAG,+BAAmB;AACtE,wCAAwC,2BAAe;AACvD;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA,6CAA6C,qCAAyB;AACtE,sCAAsC,qCAAyB;;AAE/D;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,oBAAoB,sBAAsB;AAC1C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,iCAAiC;AACjC;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,gCAAgC;AAChC,UAAU,OAAO;AACjB;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA,gCAAgC;AAChC;AACA,QAAQ;AACR;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA,sBAAsB,iBAAiB;AACvC;AACA;AACA;AACA;;AAEA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,4BAA4B,UAAU;AACtC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;;ACpde;AACf;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,2BAA2B,aAAa;AACxC;AACA;AACA;AACA;;AAEA;AACA,mCAAmC,kBAAkB;AACrD;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,kCAAkC;AAClC;AACA;;AAEA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;;;ACpDA;;AAEA;AACA;AACA;;AAEe;AACf;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA,oBAAoB,SAAS;AAC7B;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,qBAAqB,gBAAgB;AACrC;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;AACA;AACA;AACA,MAAM;AACN;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,gCAAgC,gCAAgC;AAChE;AACA;;AAEA;AACA;;AAEA,6CAA6C,+BAA+B;AAC5E;AACA,gCAAgC,iCAAiC;AACjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,8BAA8B,WAAW;AACzC;AACA;AACA;;AAEA;AACA;;AAEA,4BAA4B,gBAAgB;AAC5C;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,mCAAmC,mBAAmB;AACtD;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,oBAAoB,eAAe;AACnC;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,oBAAoB,yBAAyB;AAC7C;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;;AClTe;AACf;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACzDA;AACA,uBAAuB;AACvB,uBAAuB;AACvB,0BAA0B;;AAEX;AACf;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,sCAAsC;AACtC;;AAEA;AACA,sCAAsC;AACtC;;AAEA;AACA,sCAAsC;AACtC;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,oBAAoB,gBAAgB;AACpC;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;;;AClGqD;AACJ;AACqB;AACY;AAChC;AACY;AACE;;AAEhE;AACA;AACA;AACA;AACA,sBAAsB,mBAAmB;AACzC,IAAI;AACJ;AACA;AACA,uBAAuB,gCAAgC;AACvD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,YAAY,qGAAqG;;AAEjH,IAAI,QAAQ;AACZ,iCAAiC,cAAc;AAC/C,kCAAkC,eAAe;;AAEjD;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;AACR;AACA;AACA;AACA,6BAA6B,yBAAyB;AACtD;AACA;AACA;AACA;;AAEA;AACA,2BAA2B,8BAA8B;AACzD,QAAQ;AACR;AACA;AACA;AACA;AACA;AACA;AACA,UAAU;;AAEV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B;AAC/B;AACA;AACA;AACA;;AAEA;AACA;AACA,EAAE;AACF;AACA","sources":["webpack://dash/./js/physics/Car.js?2c0e","webpack://dash/./js/autonomy/path-planning/CubicPath.js?940c","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/xyObstacleGrid.js?d78c","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/slObstacleGrid.js?e54b","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/slObstacleGridDilation.js?1749","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/slDynamicObstacleGrid.js?6c0e","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/xyslMap.js?5ba9","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/optimizeCubicPaths.js?153d","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/optimizeQuinticPaths.js?c05d","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/graphSearchShared.js?2052","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/pathFromVehicleCosts.js?e50c","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/graphSearch.js?4c88","webpack://dash/./js/autonomy/path-planning/gpgpu-programs/xyObstacleCostGrid.js?c974","webpack://dash/./js/autonomy/path-planning/PathPlanner.js?d326","webpack://dash/./js/autonomy/path-planning/ExternalPlanner.js?c0b9","webpack://dash/./js/autonomy/LanePath.js?0fa4","webpack://dash/./js/autonomy/StaticObstacle.js?8906","webpack://dash/./js/autonomy/DynamicObstacle.js?2e70","webpack://dash/./workers/PathPlannerWorker.js?4e76"],"sourcesContent":["export default class Car {\n  constructor(x = 0, y = 0, rotation = 0) {\n    this.setPose(x, y, rotation);\n  }\n\n  static getFrontAxlePosition(pos, rot) {\n    return THREE.Vector2.fromAngle(rot).multiplyScalar(Car.WHEEL_BASE).add(pos);\n  }\n\n  static getFakeAxlePosition(pos, rot) {\n    return Car.frontToRearAxlePosition(pos, rot);\n  }\n\n  static centerToRearAxlePosition(pos, rot) {\n    return THREE.Vector2.fromAngle(rot).multiplyScalar(Car.REAR_AXLE_POS).add(pos);\n  }\n\n  static frontToRearAxlePosition(pos, rot) {\n    return THREE.Vector2.fromAngle(rot).multiplyScalar(-Car.WHEEL_BASE).add(pos);\n  }\n\n  get pose() {\n    return { pos: this.rearAxlePosition.clone(), rot: this.rotation, velocity: this.velocity, curv: this.curvature, dCurv: this.dCurv, ddCurv: this.ddCurv };\n  }\n\n  get curvature() {\n    return Math.tan(this.wheelAngle) / Car.WHEEL_BASE;\n  }\n\n  get rearAxlePosition() {\n    const { x, y } = this.position;\n    const rot = this.rotation;\n    return new THREE.Vector2(x + Math.cos(rot) * Car.REAR_AXLE_POS, y + Math.sin(rot) * Car.REAR_AXLE_POS);\n  }\n\n  get frontAxlePosition() {\n    const { x, y } = this.position;\n    const rot = this.rotation;\n    return new THREE.Vector2(x + Math.cos(rot) * Car.FRONT_AXLE_POS, y + Math.sin(rot) * Car.FRONT_AXLE_POS);\n  }\n\n  setPose(x, y, rotation) {\n    // Translate so that x and y become the center of the vehicle (instead of the center of the rear axle)\n    x -= Car.REAR_AXLE_POS * Math.cos(rotation);\n    y -= Car.REAR_AXLE_POS * Math.sin(rotation);\n\n    this.position = new THREE.Vector2(x, y);\n    this.rotation = Math.wrapAngle(rotation);\n    this.velocity = 0;\n    this.acceleration = 0;\n    this.wheelAngle = 0;\n    this.wheelAngularVelocity = 0;\n    this.dCurv = 0; // derivative with respect to arc length\n    this.ddCurv = 0; // derivative with respect to arc length\n  }\n\n  step(dt) {\n    const curvPrev = this.curvature;\n    const dCurvPrev = this.dCurv;\n\n    const drag = (0.5 * Car.DRAG_COEFF * Car.FRONTAL_AREA * Car.DENSITY_OF_AIR * Math.abs(this.velocity) + Car.ROLL_RESIST) * -this.velocity;\n    this.velocity += (this.acceleration + drag / Car.MASS) * dt;\n\n    const velocitySq = this.velocity * this.velocity;\n    const maxWheelAngle = Math.clamp(Math.atan(Car.MAX_LATERAL_ACCEL * Car.WHEEL_BASE / velocitySq), 0.07, Car.MAX_WHEEL_ANGLE);\n    this.wheelAngle = Math.clamp(Math.wrapAngle(this.wheelAngle + this.wheelAngularVelocity * dt), -maxWheelAngle, maxWheelAngle);\n\n    const angularVelocity = this.velocity * this.curvature;\n    this.rotation = Math.wrapAngle(this.rotation + angularVelocity * dt);\n\n    const dist = this.velocity * dt;\n    this.position = THREE.Vector2.fromAngle(this.rotation).multiplyScalar(dist).add(this.position);\n\n    this.dCurv = dist > 0.1 ? (this.curvature - curvPrev) / dist : 0;\n    this.ddCurv = dist > 0.1 ? (this.dCurv - dCurvPrev) / dist : 0;\n  }\n\n  update(controls, dt) {\n    const gas = Math.clamp(controls.gas, -1, +1);\n    const brake = Math.clamp(controls.brake, 0, 1);\n    const steer = Math.clamp(controls.steer, -1, +1);\n\n    if (brake > 0) {\n      this.acceleration = -Math.sign(this.velocity) * Car.MAX_BRAKE_DECEL * brake;\n      const newVelocity = this.velocity + this.acceleration * dt;\n\n      // If applying the braking deceleration at the next step would cause the velocity\n      // to change directions, then just set the car as stopped.\n      if (Math.sign(newVelocity) != Math.sign(this.velocity)) {\n        this.velocity = 0;\n        this.acceleration = 0;\n      }\n    } else {\n      this.acceleration = Car.MAX_GAS_ACCEL * gas;\n    }\n\n    if (steer != 0) {\n      this.wheelAngularVelocity = steer * Car.MAX_STEER_SPEED;\n    } else {\n      this.wheelAngularVelocity = Math.clamp(-this.wheelAngle / Car.MAX_WHEEL_ANGLE * this.velocity * this.velocity * dt, -Car.MAX_STEER_SPEED, Car.MAX_STEER_SPEED);\n    }\n  }\n}\n\nCar.HALF_CAR_LENGTH = 2.5; // meters\nCar.HALF_CAR_WIDTH = 1; // meters\nCar.HALF_WHEEL_LENGTH = 0.38; // meters\nCar.HALF_WHEEL_WIDTH = 0.12; // meters\nCar.MAX_WHEEL_ANGLE = 32 / 180 * Math.PI; // radians\nCar.MASS = 1600; // kg\nCar.DRAG_COEFF = 0.7;\nCar.DENSITY_OF_AIR = 1.8580608; // (kg/m^3)\nCar.FRONTAL_AREA = 1.85; // m^2\nCar.ROLL_RESIST = 0;\nCar.MAX_STEER_SPEED = 0.8;//1.2; // Radians per second\nCar.MAX_GAS_ACCEL = 3.0; // m / s^2\nCar.MAX_BRAKE_DECEL = 3.0; // m / s^2\nCar.WHEEL_LATERAL_POS = 0.843; // meters\nCar.FRONT_AXLE_POS = 1.6; // meters\nCar.REAR_AXLE_POS = -1.43; // meters\nCar.WHEEL_BASE = Car.FRONT_AXLE_POS - Car.REAR_AXLE_POS; // meters\nCar.MAX_LATERAL_ACCEL = 5.81; // m / s^2\n","const SIMPSONS_INTERVALS = 8;\nconst NEWTON_ITERATIONS = 16;\nconst RELAXATION_ITERATIONS = 32;\nconst CONVERGENCE_ERROR = 0.01;\n\nconst jacobian = new THREE.Matrix3();\nconst invJacobian = new THREE.Matrix3();\n\n// Alternate reference implementation: https://github.com/ApolloAuto/apollo/blob/master/modules/planning/math/spiral_curve/cubic_spiral_curve.cc\nexport default class CubicPath {\n  constructor(start, end, params = null) {\n    this.start = Object.assign({}, start);\n    this.end = Object.assign({}, end);\n\n    if (start.pos) {\n      this.start.x = start.pos.x;\n      this.start.y = start.pos.y\n    }\n\n    if (end.pos) {\n      this.end.x = end.pos.x;\n      this.end.y = end.pos.y\n    }\n\n    const diffX = this.end.x - this.start.x;\n    const diffY = this.end.y - this.start.y;\n    const sinRot = Math.sin(this.start.rot);\n    const cosRot = Math.cos(this.start.rot);\n\n    this.goal = {\n      x: cosRot * diffX + sinRot * diffY,\n      y: -sinRot * diffX + cosRot * diffY,\n      rot: Math.wrapAngle(this.end.rot - this.start.rot),\n      curv: this.end.curv\n    };\n\n    if (params)\n      this.params = Object.assign({}, params, { p0: this.start.curv, p3: this.end.curv });\n    else\n      this.guessInitialParams();\n\n    this.converged = false;\n  }\n\n  guessInitialParams() {\n    const originalGoal = this.goal;\n    const dStartCurv = this.start.curv / RELAXATION_ITERATIONS;\n    const dGoalY = originalGoal.y / RELAXATION_ITERATIONS;\n    const dGoalRot = originalGoal.rot / RELAXATION_ITERATIONS;\n    const dGoalCurv = originalGoal.curv / RELAXATION_ITERATIONS;\n\n    this.goal = {\n      x: originalGoal.x,\n      y: 0,\n      rot: 0,\n      curv: 0\n    };\n\n    this.params = {\n      p0: 0,\n      p1: 0,\n      p2: 0,\n      p3: 0,\n      sG: originalGoal.x\n    };\n\n    for (let i = 0; i < RELAXATION_ITERATIONS; i++) {\n      this.params.p0 += dStartCurv;\n      this.params.p3 += dGoalCurv;\n      this.goal.y += dGoalY;\n      this.goal.rot += dGoalRot;\n      this.goal.curv += dGoalCurv;\n\n      this.iterate();\n    }\n\n    this.goal = originalGoal;\n  }\n\n  optimize() {\n    for (let i = 0; i < NEWTON_ITERATIONS; i++) {\n      if (this.iterate()) {\n        this.converged = true;\n        return true;\n      }\n    }\n\n    this.converged = false;\n    return false;\n  }\n\n  iterate() {\n    const { p0, p1, p2, p3, sG } = this.params;\n\n    const ds = sG / SIMPSONS_INTERVALS;\n    const sG_2 = sG * sG;\n    const sG_3 = sG_2 * sG;\n\n    let dX_p1 = 0;\n    let dX_p2 = 0;\n    let dX_sG = 0;\n    let dY_p1 = 0;\n    let dY_p2 = 0;\n    let dY_sG = 0;\n    let guessX = 0;\n    let guessY = 0;\n\n    let theta, cosTheta, sinTheta, dT_p1, dT_p2, dT_sG;\n\n    for (let i = 0, s = 0; i <= SIMPSONS_INTERVALS; i++, s += ds) {\n      const coeff = i == 0 || i == SIMPSONS_INTERVALS ? 1 : i % 2 == 0 ? 2 : 4;\n\n      const a = p0;\n      const b = (-5.5 * p0 + 9 * p1 - 4.5 * p2 + p3) / sG;\n      const c = (9 * p0 - 22.5 * p1 + 18 * p2 - 4.5 * p3) / sG_2;\n      const d = (-4.5 * (p0 - 3 * p1 + 3 * p2 - p3)) / sG_3;\n\n      theta = (((d * s / 4 + c / 3) * s + b / 2) * s + a) * s;\n      cosTheta = Math.cos(theta);\n      sinTheta = Math.sin(theta);\n\n      const s_sG = s / sG;\n      dT_p1 = ((3.375 * s_sG - 7.5) * s_sG + 4.5) * s_sG * s;\n      dT_p2 = ((-3.375 * s_sG + 6) * s_sG - 2.25) * s_sG * s;\n      dT_sG = ((3.375 * (p0 - 3 * p1 + 3 * p2 - p3) * s_sG - 3 * (2 * p0 - 5 * p1 + 4 * p2 - p3)) * s_sG + 0.25 * (11 * p0 - 18 * p1 + 9 * p2 - 2 * p3)) * s_sG * s_sG;\n\n      dX_p1 -= coeff * sinTheta * dT_p1;\n      dX_p2 -= coeff * sinTheta * dT_p2;\n      dX_sG -= coeff * sinTheta * dT_sG;\n\n      dY_p1 += coeff * cosTheta * dT_p1;\n      dY_p2 += coeff * cosTheta * dT_p2;\n      dY_sG += coeff * cosTheta * dT_sG;\n\n      guessX += coeff * cosTheta;\n      guessY += coeff * sinTheta;\n    }\n\n    // After the Simpson's integration loop, `theta`, `cosTheta`, `sinTheta`,\n    // `dT_p1`, `dT_p2`, and `dT_sG` hold the appropriate values for `sG`.\n\n    const hOver3 = sG / SIMPSONS_INTERVALS / 3;\n\n    const deltaX = this.goal.x - guessX * hOver3;\n    const deltaY = this.goal.y - guessY * hOver3;\n    const deltaRot = Math.wrapAngle(this.goal.rot - theta);\n\n    if (Math.abs(deltaX) + Math.abs(deltaY) + Math.abs(deltaRot) < CONVERGENCE_ERROR)\n      return true;\n\n    jacobian.set(\n      dX_p1 * hOver3, dX_p2 * hOver3, cosTheta + dX_sG * hOver3,\n      dY_p1 * hOver3, dY_p2 * hOver3, sinTheta + dY_sG * hOver3,\n      dT_p1, dT_p2, dT_sG\n    );\n\n    const [m11, m21, m31, m12, m22, m32, m13, m23, m33] = invJacobian.getInverse(jacobian).elements;\n\n    this.params.p1 += m11 * deltaX + m12 * deltaY + m13 * deltaRot;\n    this.params.p2 += m21 * deltaX + m22 * deltaY + m23 * deltaRot;\n    this.params.sG += m31 * deltaX + m32 * deltaY + m33 * deltaRot;\n\n    return false;\n  }\n\n  buildPath(num) {\n    const { p0, p1, p2, p3, sG } = this.params;\n\n    const sG_2 = sG * sG;\n    const sG_3 = sG_2 * sG;\n\n    const a = p0;\n    const b = (-5.5 * p0 + 9 * p1 - 4.5 * p2 + p3) / sG;\n    const c = (9 * p0 - 22.5 * p1 + 18 * p2 - 4.5 * p3) / sG_2;\n    const d = (-4.5 * (p0 - 3 * p1 + 3 * p2 - p3)) / sG_3;\n\n    const path = [{ pos: new THREE.Vector2(this.start.x, this.start.y), rot: this.start.rot, curv: this.start.curv }];\n    const ds = sG / (num - 1);\n    let s = ds;\n    let dx = 0;\n    let dy = 0;\n    let prevCosRot = Math.cos(path[0].rot);\n    let prevSinRot = Math.sin(path[0].rot);\n\n    for (let i = 1; i < num - 1; i++) {\n      const rot = (((d * s / 4 + c / 3) * s + b / 2) * s + a) * s + this.start.rot;\n      const curv = ((d * s + c) * s + b) * s + a;\n      const cosRot = Math.cos(rot);\n      const sinRot = Math.sin(rot);\n\n      dx = dx * (i - 1) / i + (cosRot + prevCosRot) / (2 * i);\n      dy = dy * (i - 1) / i + (sinRot + prevSinRot) / (2 * i);\n\n      path.push({ pos: new THREE.Vector2(s * dx + this.start.x, s * dy + this.start.y), rot: rot, curv: curv });\n\n      s += ds;\n      prevCosRot = cosRot;\n      prevSinRot = sinRot;\n    }\n\n    path.push({ pos: new THREE.Vector2(this.end.x, this.end.y), rot: this.end.rot, curv: this.end.curv });\n\n    return path;\n  }\n}\n","const OBSTACLE_VERTEX_SHADER = `#version 300 es\nuniform mat3 xform;\nin vec2 position;\n\nvoid main(void) {\n  gl_Position = vec4((xform * vec3(position, 1)).xy, 0, 1);\n}\n`;\n\nconst OBSTACLE_KERNEL = `\n  vec4 kernel() {\n    return vec4(1, 0, 0, 1);\n  }\n`;\n\nlet obstacleVertices;\nlet obstacleXform;\n\n// Draw obstacle triangles to XY-space obstacle grid\nexport default {\n  setUp() {\n    return {\n      kernel: OBSTACLE_KERNEL,\n      vertexShader: OBSTACLE_VERTEX_SHADER,\n      output: { name: 'xyObstacleGrid' },\n      draw: (gpgpu, program) => {\n        const gl = gpgpu.gl;\n\n        gl.clearColor(0, 0, 0, 0);\n        gl.clear(gl.COLOR_BUFFER_BIT);\n\n        if (obstacleVertices.length > 0) {\n          const buf = gl.createBuffer();\n\n          gl.bindBuffer(gl.ARRAY_BUFFER, buf);\n          gl.bufferData(gl.ARRAY_BUFFER, obstacleVertices, gl.STATIC_DRAW);\n          gl.enableVertexAttribArray(program.positionLocation);\n          gl.vertexAttribPointer(program.positionLocation, 2, gl.FLOAT, false, 0, 0);\n\n          const xformLocation = gl.getUniformLocation(program.glProgram, 'xform');\n          gl.uniformMatrix3fv(xformLocation, false, obstacleXform.elements);\n\n          gl.drawArrays(gl.TRIANGLES, 0, obstacleVertices.length / 2);\n\n          gl.deleteBuffer(buf);\n        }\n      }\n    };\n  },\n\n  update(config, xyWidth, xyHeight, xyCenterPoint, vehicleXform, obstacles) {\n    obstacleVertices = new Float32Array(Array.prototype.concat.apply([], obstacles.map(o => o.vertices)));\n\n    const translate = new THREE.Matrix3();\n    translate.set(\n      1, 0, -xyCenterPoint.x,\n      0, 1, -xyCenterPoint.y,\n      0, 0, 1\n    );\n\n    const scale = new THREE.Matrix3();\n    scale.set(\n      2 / (xyWidth * config.xyGridCellSize), 0, 0,\n      0, 2 / (xyHeight * config.xyGridCellSize), 0,\n      0, 0, 1\n    );\n\n    obstacleXform = scale.multiply(translate).multiply(vehicleXform);\n\n    return {\n      width: xyWidth,\n      height: xyHeight\n    }\n  }\n}\n","const SL_OBSTACLE_KERNEL = `\n\nvec4 kernel() {\n  float centerlineWidth = float(textureSize(centerline, 0).x);\n\n  vec2 sl = (kernelPosition - 0.5) * vec2(kernelSize) * vec2(slGridCellSize) + slCenterPoint;\n  float centerlineCoord = sl.x / centerlineStationInterval / centerlineWidth * (centerlineWidth - 1.0) / centerlineWidth + (0.5 / centerlineWidth);\n  if (centerlineCoord < 0.0 || centerlineCoord > 1.0) return vec4(0);\n\n  vec3 centerlineSample = texture(centerline, vec2(centerlineCoord, 0)).xyz;\n  float perpindicular = centerlineSample.z + radians(90.0);\n  vec2 xy = centerlineSample.xy + sl.yy * vec2(cos(perpindicular), sin(perpindicular));\n\n  vec2 xyTexCoords = (xy - xyCenterPoint) / vec2(textureSize(xyObstacleGrid, 0)) / vec2(xyGridCellSize) + 0.5;\n  return texture(xyObstacleGrid, xyTexCoords);\n}\n\n`;\n\n// Convert XY-space obstacle grid to SL-space obstacle grid\nexport default {\n  setUp() {\n    return {\n      kernel: SL_OBSTACLE_KERNEL,\n      output: { name: 'slObstacleGrid' },\n      uniforms: {\n        xyObstacleGrid: { type: 'outputTexture' },\n        slGridCellSize: { type: 'float' },\n        xyGridCellSize: { type: 'float' },\n        slCenterPoint: { type: 'vec2' },\n        xyCenterPoint: { type: 'vec2' },\n        centerlineStationInterval: { type: 'float' },\n        centerline: { type: 'sharedTexture' }\n      }\n    }\n  },\n\n  update(config, slWidth, slHeight, slCenterPoint, xyCenterPoint) {\n    return {\n      width: slWidth,\n      height: slHeight,\n      uniforms: {\n        slGridCellSize: config.slGridCellSize,\n        xyGridCellSize: config.xyGridCellSize,\n        slCenterPoint: [slCenterPoint.x, slCenterPoint.y],\n        xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y],\n        centerlineStationInterval: config.centerlineStationInterval\n      }\n    }\n  }\n}\n","const SL_OBSTACLE_DILATION_KERNEL = `\n\n// TODO: test performance of returning early if non-zero pixel found\nvec4 kernel() {\n  float val = 0.0;\n\n  for (int d = 0; d <= collisionDilation; d++) {\n    val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(d)).r);\n    val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(-d)).r);\n  }\n\n  for (int d = collisionDilation + 1; d <= collisionDilation + hazardDilation; d++) {\n    val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(d)).r * 0.5);\n    val = max(val, texture(slObstacleGrid, kernelPosition + delta * vec2(-d)).r * 0.5);\n  }\n\n  val = max(val, step(0.1, val) * 0.5);\n\n  return vec4(val, 0, 0, 1);\n}\n\n`;\n\nexport default {\n  setUp() {\n    return [\n      { // SL-space obstacle grid S dilation\n        kernel: SL_OBSTACLE_DILATION_KERNEL,\n        output: { name: 'slObstacleGridStationDilated' },\n        uniforms: {\n          slObstacleGrid: { type: 'outputTexture' },\n          delta: { type: 'vec2' },\n          collisionDilation: { type: 'int' },\n          hazardDilation: { type: 'int' }\n        }\n      },\n      { // SL-space obstacle grid L dilation\n        kernel: SL_OBSTACLE_DILATION_KERNEL,\n        output: { name: 'slObstacleGridDilated' },\n        uniforms: {\n          slObstacleGrid: { type: 'outputTexture', name: 'slObstacleGridStationDilated' },\n          delta: { type: 'vec2' },\n          collisionDilation: { type: 'int' },\n          hazardDilation: { type: 'int' }\n        }\n      }\n    ];\n  },\n\n  update(config, slWidth, slHeight) {\n    return [\n      { // SL-space obstacle grid S dilation\n        width: slWidth,\n        height: slHeight,\n        uniforms: {\n          delta: [1 / slWidth, 0],\n          collisionDilation: Math.ceil(config.collisionDilationS / config.slGridCellSize),\n          hazardDilation: Math.ceil(config.hazardDilationS / config.slGridCellSize)\n        }\n      },\n      { // SL-space obstacle grid L dilation\n        width: slWidth,\n        height: slHeight,\n        uniforms: {\n          delta: [0, 1 / slHeight],\n          collisionDilation: Math.ceil(config.collisionDilationL / config.slGridCellSize),\n          hazardDilation: Math.ceil(config.hazardDilationL / config.slGridCellSize)\n        }\n      }\n    ];\n  }\n}\n","const DYNAMIC_OBSTACLE_VERTEX_SHADER = `#version 300 es\nuniform mat3 xform;\nin vec3 position;\nout float color;\n\nvoid main(void) {\n  gl_Position = vec4((xform * vec3(position.xy, 1)).xy, position.z, 1);\n\n  // The z coordinate is 0.25 for collision zone and 0.75 for hazard zone,\n  // so that the collision zone is drawn on top.\n  // Convert this to 1.0 for collision zone, 0.5 for hazard zone\n  color = (1.0 - step(0.5, position.z)) * 0.5 + 0.5;\n}\n`;\n\nconst DYNAMIC_OBSTACLE_KERNEL = `\n  in float color;\n\n  vec4 kernel() {\n    return vec4(color, 0, 0, 1);\n  }\n`;\n\nlet obstacleVertices;\nlet obstacleXform;\nconst numDynamicFrames = 20;\n\n// Draw dynamic obstacle triangles to SL-space obstacle grid\nexport default {\n  setUp() {\n    return {\n      kernel: DYNAMIC_OBSTACLE_KERNEL,\n      vertexShader: DYNAMIC_OBSTACLE_VERTEX_SHADER,\n      output: { name: 'slDynamicObstacleGrid', textureType: '2DArray', depth: numDynamicFrames },\n      draw: (gpgpu, program) => {\n        const gl = gpgpu.gl;\n\n        gl.enable(gl.DEPTH_TEST);\n\n        const renderbuffer = gl.createRenderbuffer();\n        gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer);\n        gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, program.inputWidth, program.inputHeight);\n        gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, renderbuffer);\n\n        for (let frame = 0; frame < numDynamicFrames; frame++) {\n          gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, program.outputTexture, 0, frame);\n          const frameBufferStatus = (gl.checkFramebufferStatus(gl.FRAMEBUFFER) == gl.FRAMEBUFFER_COMPLETE);\n          if (!frameBufferStatus)\n            throw new Error('Error attaching float texture to framebuffer. Your device is probably incompatible.');\n\n          gl.clearColor(0, 0, 0, 0);\n          gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);\n\n          if (obstacleVertices[frame].length > 0) {\n            const buf = gl.createBuffer();\n\n            gl.bindBuffer(gl.ARRAY_BUFFER, buf);\n            gl.bufferData(gl.ARRAY_BUFFER, obstacleVertices[frame], gl.STATIC_DRAW);\n            gl.enableVertexAttribArray(program.positionLocation);\n            gl.vertexAttribPointer(program.positionLocation, 3, gl.FLOAT, false, 0, 0);\n\n            const xformLocation = gl.getUniformLocation(program.glProgram, 'xform');\n            gl.uniformMatrix3fv(xformLocation, false, obstacleXform.elements);\n\n            gl.drawArrays(gl.TRIANGLES, 0, obstacleVertices[frame].length / 3);\n\n            if (frame == 0) {\n              const obstacleGrid = new Float32Array(program.inputWidth * program.inputHeight * 4);\n              gl.readPixels(0, 0, program.inputWidth, program.inputHeight, gl.RGBA, gl.FLOAT, obstacleGrid);\n              gpgpu._dynamicObstacleGrid = obstacleGrid;\n            }\n\n            gl.deleteBuffer(buf);\n          }\n        }\n\n        gl.bindRenderbuffer(gl.RENDERBUFFER, null);\n        gl.deleteRenderbuffer(renderbuffer);\n        gl.disable(gl.DEPTH_TEST);\n      }\n    };\n  },\n\n  update(config, slWidth, slHeight, slCenterPoint, vehicleStation, startTime, dynamicFrameTime, dynamicObstacles) {\n    obstacleVertices = [];\n\n    let time = startTime;\n    for (let frame = 0; frame < numDynamicFrames; frame++) {\n      const vertices = Array.prototype.concat.apply([], dynamicObstacles.map(o => o.verticesInTimeRange(time, time + dynamicFrameTime, config)));\n      obstacleVertices.push(new Float32Array(vertices));\n      time += dynamicFrameTime;\n    }\n\n    const translate = new THREE.Matrix3();\n    translate.set(\n      1, 0, -slCenterPoint.x - vehicleStation,\n      0, 1, -slCenterPoint.y,\n      0, 0, 1\n    );\n\n    const scale = new THREE.Matrix3();\n    scale.set(\n      2 / (slWidth * config.slGridCellSize), 0, 0,\n      0, 2 / (slHeight * config.slGridCellSize), 0,\n      0, 0, 1\n    );\n\n    obstacleXform = scale.multiply(translate);\n\n    return {\n      width: slWidth,\n      height: slHeight\n    }\n  }\n}\n","const XYSL_MAP_KERNEL = `\n\nvec4 kernel() {\n  vec2 xy = (kernelPosition - 0.5) * vec2(kernelSize) * vec2(xyGridCellSize) + xyCenterPoint;\n\n  int numSamples = textureSize(centerline, 0).x;\n  int closest = 0;\n  float closestDist = distance(xy, texelFetch(centerline, ivec2(0, 0), 0).xy);\n  for (int i = 1; i < numSamples; i++) {\n    float dist = distance(xy, texelFetch(centerline, ivec2(i, 0), 0).xy);\n    if (dist < closestDist) {\n      closestDist = dist;\n      closest = i;\n    }\n  }\n\n  vec2 closestPos = texelFetch(centerline, ivec2(closest, 0), 0).xy;\n  vec2 prev, next;\n  int prevIndex, nextIndex;\n\n  if (closest == 0) {\n    prevIndex = 0;\n    nextIndex = 1;\n    prev = closestPos;\n    next = texelFetch(centerline, ivec2(1, 0), 0).xy;\n  } else if (closest == numSamples - 1) {\n    prevIndex = closest - 1;\n    nextIndex = closest;\n    prev = texelFetch(centerline, ivec2(prevIndex, 0), 0).xy;\n    next = closestPos;\n  } else {\n    vec2 before = texelFetch(centerline, ivec2(closest - 1, 0), 0).xy;\n    vec2 after = texelFetch(centerline, ivec2(closest + 1, 0), 0).xy;\n\n    if (distance(before, xy) < distance(after, xy)) {\n      prevIndex = closest - 1;\n      nextIndex = closest;\n      prev = before;\n      next = closestPos;\n    } else {\n      prevIndex = closest;\n      nextIndex = closest + 1;\n      prev = closestPos;\n      next = after;\n    }\n  }\n\n  float dist = distance(prev, next);\n  float progress = clamp(dot(xy - prev, next - prev) / dist / dist, 0.0, 1.0);\n  vec2 projectedPos = (next - prev) * vec2(progress) + prev;\n\n  return vec4(\n    (float(prevIndex) + progress) * centerlineStationInterval,\n    sign(determinant(mat2(next - prev, xy - prev))) * distance(xy, projectedPos),\n    0,\n    0\n  );\n}\n\n`;\n\n// Build XY-SL map\nexport default {\n  setUp() {\n    return {\n      kernel: XYSL_MAP_KERNEL,\n      output: { name: 'xyslMap', filter: 'linear' },\n      uniforms: {\n        centerline: { type: 'sharedTexture' },\n        xyCenterPoint: { type: 'vec2' },\n        xyGridCellSize: { type: 'float'},\n        centerlineStationInterval: { type: 'float'}\n      }\n    };\n  },\n\n  update(config, xyWidth, xyHeight, xyCenterPoint) {\n    return {\n      width: xyWidth,\n      height: xyHeight,\n      uniforms: {\n        xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y],\n        xyGridCellSize: config.xyGridCellSize,\n        centerlineStationInterval: config.centerlineStationInterval\n      }\n    };\n  }\n}\n","// Config:\n// num stations\n// num latitudes\n// station connectivity\n// latitude connectivity\n//\n// Shared:\n// lattice\n\nconst OPTIMIZE_CUBIC_SHARED = `\n\nconst int NEWTON_ITERATIONS = 16;\nconst int RELAXATION_ITERATIONS = 16;\nconst float CONVERGENCE_ERROR = 0.01;\n\n// These two consts must stay in sync.\nconst int SIMPSONS_INTERVALS = 8;\n//const float SIMPSONS_COEFFS[SIMPSONS_INTERVALS + 1] = float[](1.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 1.0);\nconst float SIMPSONS_COEFFS[SIMPSONS_INTERVALS + 1] = float[](1.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 1.0);\n\nconst float PI = 3.1415926535897932384626433832795;\nconst float TWO_PI = PI + PI;\n\nconst float RELAXATION_ITERATIONS_F = float(RELAXATION_ITERATIONS);\nconst float SIMPSONS_INTERVALS_F = float(SIMPSONS_INTERVALS);\n\nfloat wrapAngle(float angle) {\n  angle = mod(angle, TWO_PI);\n  if (angle <= -PI) return angle + TWO_PI;\n  else if (angle > PI) return angle - TWO_PI;\n  return angle;\n}\n\nvec4 iterate(vec4 goal, float p0, float p1, float p2, float p3, float sG) {\n  float ds = sG / SIMPSONS_INTERVALS_F;\n  float sG_2 = sG * sG;\n  float sG_3 = sG_2 * sG;\n\n  vec3 dX_p = vec3(0.0);\n  vec3 dY_p = vec3(0.0);\n  vec2 guess = vec2(0.0);\n  float s = 0.0;\n\n  float theta, cosTheta, sinTheta;\n  vec3 dT_p;\n\n  for (int i = 0; i <= SIMPSONS_INTERVALS; i++) {\n    float coeff = SIMPSONS_COEFFS[i];\n\n    float a = p0;\n    float b = (-5.5 * p0 + 9.0 * p1 - 4.5 * p2 + p3) / sG;\n    float c = (9.0 * p0 - 22.5 * p1 + 18.0 * p2 - 4.5 * p3) / sG_2;\n    float d = (-4.5 * (p0 - 3.0 * p1 + 3.0 * p2 - p3)) / sG_3;\n\n    theta = (((d * s / 4.0 + c / 3.0) * s + b / 2.0) * s + a) * s;\n    cosTheta = cos(theta);\n    sinTheta = sin(theta);\n\n    float s_sG = s / sG;\n\n    dT_p = vec3(\n      // p1\n      ((3.375 * s_sG - 7.5) * s_sG + 4.5) * s_sG * s,\n\n      // p2\n      ((-3.375 * s_sG + 6.0) * s_sG - 2.25) * s_sG * s,\n\n      // sG\n      ((3.375 * (p0 - 3.0 * p1 + 3.0 * p2 - p3) * s_sG - 3.0 * (2.0 * p0 - 5.0 * p1 + 4.0 * p2 - p3)) * s_sG + 0.25 * (11.0 * p0 - 18.0 * p1 + 9.0 * p2 - 2.0 * p3)) * s_sG * s_sG\n    );\n\n    dX_p -= coeff * sinTheta * dT_p;\n    dY_p += coeff * cosTheta * dT_p;\n\n    guess += coeff * vec2(cosTheta, sinTheta);\n\n    s += ds;\n  }\n\n  float hOver3 = sG / SIMPSONS_INTERVALS_F / 3.0;\n\n  vec3 delta;\n  delta.xy = goal.xy - guess * hOver3;\n  delta.z = wrapAngle(goal.z - theta);\n\n  if (abs(delta.x) + abs(delta.y) + abs(delta.z) < CONVERGENCE_ERROR)\n    return vec4(p1, p2, sG, 1.0);\n\n  dX_p.xyz *= hOver3;\n  dY_p.xyz *= hOver3;\n  dX_p.z += cosTheta;\n  dY_p.z += sinTheta;\n\n  mat3 invJacobian = inverse(transpose(mat3(dX_p, dY_p, dT_p)));\n\n  vec3 deltaP = invJacobian * delta;\n  vec4 params = vec4(p1, p2, sG, 0.0);\n  params.xyz += deltaP;\n\n  return params;\n}\n\n/* Input:\n *   start: (vec4)\n *     x: x position,\n *     y: y position,\n *     z: theta rotation,\n *     w: k curvature\n *   end: (vec4)\n *     x: x position,\n *     y: y position,\n *     z: theta rotation,\n *     w: k curvature\n *\n * Output: (vec4)\n *   x: p1,\n *   y: p2,\n *   z: sG,\n *   w: 1 if converged, 0 if not\n */\n\nvec4 optimize(vec4 start, vec4 end) {\n  // Translate and rotate start and end so that start is at the origin\n  float sinRot = sin(start.z);\n  float cosRot = cos(start.z);\n\n  vec4 diff = end - start;\n  vec4 goal;\n  goal.xy = mat2(cosRot, -sinRot, sinRot, cosRot) * diff.xy;\n  goal.z = wrapAngle(diff.z);\n  goal.w = end.w;\n\n  vec4 originalGoal = goal;\n  vec4 dGoal;\n  dGoal.x = 0.0;\n  dGoal.yzw = goal.yzw / RELAXATION_ITERATIONS_F;\n  float dK0 = start.w / RELAXATION_ITERATIONS_F;\n\n  // Relax the goal to (x, 0, 0, 0)\n  goal.yzw = vec3(0, 0, 0);\n\n  // Relax the params to (0, 0, 0, 0, goal.x)\n  float p0 = 0.0;\n  float p1 = 0.0;\n  float p2 = 0.0;\n  float p3 = 0.0;\n  float sG = goal.x;\n\n  if (sG < 0.1) return vec4(0.0);\n\n  for (int i = 0; i < RELAXATION_ITERATIONS; i++) {\n    p0 += dK0;\n    p3 += dGoal.w;\n    goal += dGoal;\n    \n    vec4 result = iterate(goal, p0, p1, p2, p3, sG);\n    p1 = result.x;\n    p2 = result.y;\n    sG = result.z;\n  }\n\n  goal = originalGoal;\n\n  for (int i = 0; i < NEWTON_ITERATIONS; i++) {\n    vec4 result = iterate(goal, p0, p1, p2, p3, sG);\n    if (result.w == 1.0) {\n      result.w = step(0.0, result.z);\n      return result;\n    }\n\n    p1 = result.x;\n    p2 = result.y;\n    sG = result.z;\n  }\n\n  return vec4(p1, p2, sG, 0.0);\n}\n\n`;\n\nconst OPTIMIZE_CUBIC_KERNEL = OPTIMIZE_CUBIC_SHARED + `\n\n// width: station * latitude index\n// height: station_conn * lattice_conn\n//\n// lattice:\n// width: latitudes\n// height: stations\n\nvec4 kernel() {\n  ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize));\n\n  int endStation = indexes.x / numLatitudes;\n  int endLatitude = int(mod(float(indexes.x), float(numLatitudes)));\n\n  int startStation = endStation - stationConnectivity + indexes.y / latitudeConnectivity;\n  int startLatitude = endLatitude - latitudeConnectivity / 2 + int(mod(float(indexes.y), float(latitudeConnectivity)));\n\n  if (startStation < 0 || startStation >= numStations || startLatitude < 0 || startLatitude >= numLatitudes)\n    return vec4(0.0);\n\n  vec4 start = texelFetch(lattice, ivec2(startLatitude, startStation), 0);\n  vec4 end = texelFetch(lattice, ivec2(endLatitude, endStation), 0);\n\n  return optimize(start, end);\n}\n\n`;\n\nconst OPTIMIZE_CUBIC_FROM_VEHICLE_KERNEL = OPTIMIZE_CUBIC_SHARED + `\n\nvec4 kernel() {\n  ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize));\n\n  vec4 start = vec4(0, 0, 0, curvVehicle);\n  vec4 end = texelFetch(lattice, indexes, 0);\n\n  return optimize(start, end);\n}\n\n`;\n\nexport default {\n  setUp() {\n    return [\n      { // Cubic paths between lattice nodes\n        kernel: OPTIMIZE_CUBIC_KERNEL,\n        output: { name: 'cubicPaths', read: true },\n        uniforms: {\n          lattice: { type: 'sharedTexture' },\n          numStations: { type: 'int' },\n          numLatitudes: { type: 'int' },\n          stationConnectivity: { type: 'int' },\n          latitudeConnectivity: { type: 'int' }\n        }\n      },\n      { // Cubic paths from vehicle to lattice nodes\n        kernel: OPTIMIZE_CUBIC_FROM_VEHICLE_KERNEL,\n        output: { name: 'cubicPathsFromVehicle', read: true },\n        uniforms: {\n          lattice: { type: 'sharedTexture' },\n          curvVehicle: { type: 'float' }\n        }\n      }\n    ]\n  },\n\n  update(config, pose) {\n    return [\n      { // Cubic paths between lattice nodes\n        width: config.lattice.numStations * config.lattice.numLatitudes,\n        height: config.lattice.stationConnectivity * config.lattice.latitudeConnectivity,\n        uniforms: {\n          numStations: config.lattice.numStations,\n          numLatitudes: config.lattice.numLatitudes,\n          stationConnectivity: config.lattice.stationConnectivity,\n          latitudeConnectivity: config.lattice.latitudeConnectivity,\n        }\n      },\n      { // Cubic paths from vehicle to lattice nodes\n        width: config.lattice.numLatitudes,\n        height: config.lattice.stationConnectivity,\n        uniforms: {\n          curvVehicle: pose.curv\n        }\n      }\n    ];\n  }\n}\n","const OPTIMIZE_KERNEL = `\n\nconst int NEWTON_ITERATIONS = 32;\nconst int RELAXATION_ITERATIONS = 32;\nconst float CONVERGENCE_ERROR = 0.01;\n\n// These two consts must stay in sync.\nconst int SIMPSONS_INTERVALS = 8;\nconst float SIMPSONS_COEFFS[SIMPSONS_INTERVALS + 1] = float[](1.0, 4.0, 2.0, 4.0, 2.0, 4.0, 2.0, 4.0, 1.0);\n\nconst float PI = 3.1415926535897932384626433832795;\nconst float TWO_PI = PI + PI;\n\nconst float RELAXATION_ITERATIONS_F = float(RELAXATION_ITERATIONS);\nconst float SIMPSONS_INTERVALS_F = float(SIMPSONS_INTERVALS);\n\nfloat wrapAngle(float angle) {\n  angle = mod(angle, TWO_PI);\n  if (angle <= -PI) return angle + TWO_PI;\n  else if (angle > PI) return angle - TWO_PI;\n  return angle;\n}\n\nvec4 iterate(vec4 goal, float p0, float p1, float p2, float p3, float p4, float p5, float sG) {\n  float ds = sG / SIMPSONS_INTERVALS_F;\n  float sG_2 = sG * sG;\n  float sG_3 = sG_2 * sG;\n\n  vec3 dX_p = vec3(0.0);\n  vec3 dY_p = vec3(0.0);\n  vec2 guess = vec2(0.0);\n  float s = 0.0;\n\n  float theta, cosTheta, sinTheta;\n  vec3 dT_p;\n\n  for (int i = 0; i <= SIMPSONS_INTERVALS; i++) {\n    float coeff = SIMPSONS_COEFFS[i];\n\n    float a = p0;\n    float b = p1;\n    float c = p2 / 2.0;\n    float d = (-71.875 * p0 + 81.0 * p3 - 10.125 * p4 + p5 - 21.25 * p1 * sG - 2.75 * p2 * sG_2) / sG_3;\n    float e = (166.5 * p0 - 202.5 * p3 + 40.5 * p4 - 4.5 * p5 + 45.0 * p1 * sG + 4.5 * p2 * sG_2) / (sG_2 * sG_2);\n    float f = (-95.625 * p0 + 121.5 * p3 - 30.375 * p4 + 4.5 * p5 - 24.75 * p1 * sG - 2.25 * p2 * sG_2) / (sG_2 * sG_3);\n\n    theta = (((((f * s / 6.0 + e / 5.0) * s + d / 4.0) * s + c / 3.0) * s + b / 2.0) * s + a) * s;\n    cosTheta = cos(theta);\n    sinTheta = sin(theta);\n\n    float s_2 = s * s;\n    float s_sG = s / sG;\n    float s_sG_2 = s_sG * s_sG;\n    float s_sG_3 = s_sG_2 * s_sG;\n    float s_sG_4 = s_sG_3 * s_sG;\n    float s_sG_5 = s_sG_4 * s_sG;\n\n    dT_p = vec3(\n      // p3\n      ((20.25 * s_sG - 40.5) * s_sG + 20.25) * s_sG_3 * s,\n\n      // p4\n      ((-5.0625 * s_sG + 8.1) * s_sG - 2.53125) * s_sG_3 * s,\n\n      // sG\n      (53.90625 * p0 - 60.75 * p3 + 7.59375 * p4 - 0.75 * p5) * s_sG_4 + 10.625 * p1 * s * s_sG_3 + 0.6875 * p2 * s_2 * s_sG_2 + (-133.2 * p0 + 162.0 * p3 - 32.4 * p4 + 3.6 * p5) * s_sG_5 + (-27.0) * p1 * s * s_sG_4 - 1.8 * p2 * s_2 * s_sG_3 + (79.6875 * p0 - 101.25 * p3 + 25.3125 * p4 - 3.75 * p5) * s_sG_5 * s_sG + 16.5 * p1 * s * s_sG_5 + 1.125 * p2 * s_2 * s_sG_4\n    );\n\n    dX_p -= coeff * sinTheta * dT_p;\n    dY_p += coeff * cosTheta * dT_p;\n\n    guess += coeff * vec2(cosTheta, sinTheta);\n\n    s += ds;\n  }\n\n  float hOver3 = sG / SIMPSONS_INTERVALS_F / 3.0;\n\n  vec3 delta;\n  delta.xy = goal.xy - guess * hOver3;\n  delta.z = wrapAngle(goal.z - theta);\n\n  if (abs(delta.x) + abs(delta.y) + abs(delta.z) < CONVERGENCE_ERROR)\n    return vec4(p3, p4, sG, 1.0);\n\n  dX_p.xyz *= hOver3;\n  dY_p.xyz *= hOver3;\n  dX_p.z += cosTheta;\n  dY_p.z += sinTheta;\n\n  mat3 invJacobian = inverse(transpose(mat3(dX_p, dY_p, dT_p)));\n\n  vec3 deltaP = invJacobian * delta;\n  vec4 params = vec4(p3, p4, sG, 0.0);\n  params.xyz += deltaP;\n\n  return params;\n}\n\nvec4 optimize(vec4 start, vec4 end) {\n  // Translate and rotate start and end so that start is at the origin\n  float sinRot = sin(start.z);\n  float cosRot = cos(start.z);\n\n  vec4 diff = end - start;\n  vec4 goal;\n  goal.xy = mat2(cosRot, -sinRot, sinRot, cosRot) * diff.xy;\n  goal.z = wrapAngle(diff.z);\n  goal.w = end.w;\n\n  vec4 originalGoal = goal;\n  vec4 dGoal;\n  dGoal.x = 0.0;\n  dGoal.yzw = goal.yzw / RELAXATION_ITERATIONS_F;\n  float d_K0 = start.w / RELAXATION_ITERATIONS_F;\n  float d_dK0 = dCurvVehicle / RELAXATION_ITERATIONS_F;\n  float d_ddK0 = ddCurvVehicle / RELAXATION_ITERATIONS_F;\n\n  // Relax the goal to (x, 0, 0, 0)\n  goal.yzw = vec3(0, 0, 0);\n\n  // Relax the params to (0, 0, 0, 0, goal.x)\n  float p0 = 0.0;\n  float p1 = 0.0;\n  float p2 = 0.0;\n  float p3 = 0.0;\n  float p4 = 0.0;\n  float p5 = 0.0;\n  float sG = goal.x;\n\n  if (sG < 0.1) return vec4(0.0);\n\n  for (int i = 0; i < RELAXATION_ITERATIONS; i++) {\n    p0 += d_K0;\n    p1 += d_dK0;\n    p2 += d_ddK0;\n    p5 += dGoal.w;\n    goal += dGoal;\n    \n    vec4 result = iterate(goal, p0, p1, p2, p3, p4, p5, sG);\n    p3 = result.x;\n    p4 = result.y;\n    sG = result.z;\n  }\n\n  goal = originalGoal;\n\n  for (int i = 0; i < NEWTON_ITERATIONS; i++) {\n    vec4 result = iterate(goal, p0, p1, p2, p3, p4, p5, sG);\n    if (result.w == 1.0) {\n      result.w = step(0.0, result.z);\n      return result;\n    }\n\n    p3 = result.x;\n    p4 = result.y;\n    sG = result.z;\n  }\n\n  return vec4(p3, p4, sG, 0.0);\n}\n\nvec4 kernel() {\n  ivec2 latticeIndexes = ivec2(kernelPosition * vec2(kernelSize));\n\n  vec4 start = vec4(0, 0, 0, curvVehicle);\n  vec4 end = texelFetch(lattice, latticeIndexes, 0);\n\n  return optimize(start, end);\n}\n\n`;\n\n// Quintic spiral path optimizer\n//   * Start of paths is the vehicle pose\n//     * x-pos, y-pos, and rotation aren't needed, since the lattice origin is the vehicle pose\n//     * So assume position and rotation are 0\n//   * Ends of paths are all latitudes within the first (stationConnectivity) stations\nexport default {\n  setUp() {\n    return {\n      kernel: OPTIMIZE_KERNEL,\n      output: { name: 'quinticPathsFromVehicle', read: true },\n      uniforms: {\n        lattice: { type: 'sharedTexture' },\n        curvVehicle: { type: 'float' },\n        dCurvVehicle: { type: 'float' },\n        ddCurvVehicle: { type: 'float' }\n      }\n    };\n  },\n\n  update(config, pose) {\n    return {\n      width: config.lattice.numLatitudes,\n      height: config.lattice.stationConnectivity,\n      uniforms: {\n        curvVehicle: pose.curv,\n        dCurvVehicle: pose.dCurv,\n        ddCurvVehicle: pose.ddCurv\n      }\n    };\n  }\n}\n","const SHARED_SHADER = `\n\nconst float smallV = 0.01;\nvec4 pathSamples[128];\nfloat pathSampleCurvRates[128];\n\nfloat calculateAcceleration(int index, float initialVelocitySq, float distance) {\n  if (index <= 4) {\n    // [aMaxHard, aMinHard, aMaxSoft, aMinSoft, 0]\n    return accelerationProfiles[index];\n  } else {\n    float finalVelocity = finalVelocityProfiles[index - 5];\n    if (distance < 0.001) return 0.0;\n    return clamp((finalVelocity * finalVelocity - initialVelocitySq) / (2.0 * distance), accelerationProfiles[1], accelerationProfiles[0]);\n  }\n}\n\nvec2 xy2sl(vec4 xytk) {\n  vec2 xy = xytk.xy + rearAxleToCenter * vec2(cos(xytk.z), sin(xytk.z));\n  vec2 xyTexCoords = (xy - xyCenterPoint) / vec2(textureSize(xyslMap, 0)) / vec2(xyGridCellSize) + 0.5;\n  return texture(xyslMap, xyTexCoords).xy;\n}\n\nfloat sampleStaticCost(vec4 xytk) {\n  vec2 sl = xy2sl(xytk);\n  vec2 slTexCoords = (sl - slCenterPoint) / vec2(textureSize(slObstacleGrid, 0)) / vec2(slGridCellSize) + 0.5;\n  float obstacleCost = texture(slObstacleGrid, slTexCoords).r;\n\n  if (obstacleCost >= 0.75) return -1.0; // Infinite cost\n\n  obstacleCost = step(0.25, obstacleCost) * obstacleHazardCost;\n\n  float absLatitude = abs(sl.y);\n  if (absLatitude >= laneShoulderLatitude) return -1.0;\n\n  float laneCost = abs(absLatitude - laneCenterLatitude) * laneCostSlope + step(0.0, -sl.y * sign(lanePreference)) * lanePreferenceDiscount;\n\n  return obstacleCost + laneCost;\n}\n\nfloat sampleDynamicCost(vec4 xytk, float time, float velocity, float acceleration) {\n  vec2 sl = xy2sl(xytk);\n  vec2 slTexCoords = (sl - slCenterPoint) / vec2(textureSize(slDynamicObstacleGrid, 0).xy) / vec2(slGridCellSize) + 0.5;\n  float dynamicFrame = floor(time / dynamicFrameTime);\n\n  float obstacleCost = texture(slDynamicObstacleGrid, vec3(slTexCoords, dynamicFrame)).r;\n\n  if (obstacleCost > 0.75) return -1.0; // Infinite cost\n\n  return step(0.25, obstacleCost) * obstacleHazardCost;\n}\n\nfloat calculateAverageStaticCost(int numSamples) {\n  float averageStaticCost = 0.0;\n\n  for (int i = 0; i < numSamples; i++) {\n    float cost = sampleStaticCost(pathSamples[i]);\n\n    if (cost < 0.0) return cost;\n\n    averageStaticCost += cost;\n  }\n\n  averageStaticCost /= float(numSamples);\n\n  return averageStaticCost;\n}\n\nfloat calculateAverageDynamicCost(int numSamples, float pathLength, float initialTime, float initialVelocity, float acceleration, float abandonThreshold) {\n  float s = 0.0;\n  float ds = pathLength / float(numSamples - 1);\n  float averageDynamicCost = 0.0;\n  float maxVelocity = 0.0;\n  float maxLateralAcceleration = 0.0;\n  float numSamples_f = float(numSamples);\n\n  for (int i = 0; i < numSamples; i++) {\n    vec4 pathSample = pathSamples[i]; // vec4(x-pos, y-pos, theta (rotation), kappa (curvature))\n\n    float velocitySq = 2.0 * acceleration * s + initialVelocity * initialVelocity;\n    float velocity = max(smallV, sqrt(max(0.0, velocitySq)));\n    maxVelocity = max(maxVelocity, velocity);\n    maxLateralAcceleration = max(maxLateralAcceleration, abs(pathSample.w * velocity * velocity));\n\n    float time = 2.0 * s / (initialVelocity + velocity) + initialTime;\n\n    float dCurv = pathSampleCurvRates[i] * velocity;\n    if (dCurv > dCurvatureMax) return -1.0;\n\n    float cost = sampleDynamicCost(pathSample, time, velocity, acceleration);\n    if (cost < 0.0) return cost;\n\n    averageDynamicCost += cost;\n    if (averageDynamicCost / numSamples_f >= abandonThreshold) return -1.0;\n\n    s += ds;\n  }\n\n  averageDynamicCost /= numSamples_f;\n\n  // Apply speeding penality if any velocity along the trajectory is over the speed limit\n  averageDynamicCost += step(speedLimit, maxVelocity) * speedLimitPenalty;\n\n  // Apply hard acceleration/deceleration penalties if the acceleration/deceleration exceeds the soft limits\n  averageDynamicCost += step(accelerationProfiles[2] + 0.0001, acceleration) * hardAccelerationPenalty;\n  averageDynamicCost += (1.0 - step(accelerationProfiles[3], acceleration)) * hardDecelerationPenalty;\n\n  // Penalize lateral acceleration\n  averageDynamicCost += step(softLateralAccelerationLimit, maxLateralAcceleration) * softLateralAccelerationPenalty;\n  averageDynamicCost += linearLateralAccelerationPenalty * maxLateralAcceleration;\n\n  return averageDynamicCost;\n}\n\nvec3 calculateAVT(int accelerationIndex, float initialVelocity, float initialTime, float pathLength) {\n  float initialVelocitySq = initialVelocity * initialVelocity;\n  float acceleration = calculateAcceleration(accelerationIndex, initialVelocitySq, pathLength);\n\n  float finalVelocitySq = 2.0 * acceleration * pathLength + initialVelocitySq;\n  float finalVelocity = max(smallV, sqrt(max(0.0, finalVelocitySq)));\n\n  float finalTime = initialTime;\n\n  if (acceleration == 0.0) {\n    finalTime += pathLength / finalVelocity;\n  } else if (finalVelocitySq <= 0.0) { // Calculate final time if the vehicle stops before the end of the trajectory\n    float distanceLeft = pathLength - (smallV * smallV - initialVelocitySq) / (2.0 * acceleration);\n    finalTime += (finalVelocity - initialVelocity) / acceleration + distanceLeft / smallV;\n  } else {\n    finalTime += 2.0 * pathLength / (finalVelocity + initialVelocity);\n  }\n\n  return vec3(acceleration, finalVelocity, finalTime);\n}\n\n`;\n\nconst SAMPLE_CUBIC_PATH_FN = `\n\nint sampleCubicPath(vec4 start, vec4 end, vec4 cubicPathParams) {\n  float p0 = start.w;\n  float p1 = cubicPathParams.x;\n  float p2 = cubicPathParams.y;\n  float p3 = end.w;\n  float sG = cubicPathParams.z;\n\n  if (sG <= 0.0) return 0;\n\n  int numSamples = int(ceil(sG / pathSamplingStep)) + 1;\n\n  float sG_2 = sG * sG;\n  float sG_3 = sG_2 * sG;\n\n  float a = p0;\n  float b = (-5.5 * p0 + 9.0 * p1 - 4.5 * p2 + p3) / sG;\n  float c = (9.0 * p0 - 22.5 * p1 + 18.0 * p2 - 4.5 * p3) / sG_2;\n  float d = (-4.5 * (p0 - 3.0 * p1 + 3.0 * p2 - p3)) / sG_3;\n\n  pathSamples[0] = start;\n\n  float ds = sG / float(numSamples - 1);\n  float s = ds;\n  vec2 dxy = vec2(0);\n  vec2 prevCosSin = vec2(cos(start.z), sin(start.z));\n\n  for (int i = 1; i < numSamples; i++) {\n    float rot = (((d * s / 4.0 + c / 3.0) * s + b / 2.0) * s + a) * s + start.z;\n    float curv = ((d * s + c) * s + b) * s + a;\n\n    vec2 cosSin = vec2(cos(rot), sin(rot));\n    dxy = dxy * vec2(float(i - 1) / float(i)) + (cosSin + prevCosSin) / vec2(2 * i);\n\n    pathSamples[i] = vec4(dxy * vec2(s) + start.xy, rot, curv);\n    pathSampleCurvRates[i] = b + s * (2.0 * c + 3.0 * d * s);\n\n    s += ds;\n    prevCosSin = cosSin;\n  }\n\n  return numSamples;\n}\n\n`;\n\nconst SAMPLE_QUINTIC_PATH_FN = `\n\nint sampleQuinticPath(vec4 start, vec4 end, vec4 quinticPathParams) {\n  float p0 = start.w;\n  float p1 = dCurvVehicle;\n  float p2 = ddCurvVehicle;\n  float p3 = quinticPathParams.x;\n  float p4 = quinticPathParams.y;\n  float p5 = end.w;\n  float sG = quinticPathParams.z;\n\n  if (sG <= 0.0) return 0;\n\n  int numSamples = int(ceil(sG / pathSamplingStep)) + 1;\n\n  float sG_2 = sG * sG;\n  float sG_3 = sG_2 * sG;\n\n  float a = p0;\n  float b = p1;\n  float c = p2 / 2.0;\n  float d = (-71.875 * p0 + 81.0 * p3 - 10.125 * p4 + p5 - 21.25 * p1 * sG - 2.75 * p2 * sG_2) / sG_3;\n  float e = (166.5 * p0 - 202.5 * p3 + 40.5 * p4 - 4.5 * p5 + 45.0 * p1 * sG + 4.5 * p2 * sG_2) / (sG_2 * sG_2);\n  float f = (-95.625 * p0 + 121.5 * p3 - 30.375 * p4 + 4.5 * p5 - 24.75 * p1 * sG - 2.25 * p2 * sG_2) / (sG_2 * sG_3);\n\n  pathSamples[0] = start;\n\n  float ds = sG / float(numSamples - 1);\n  float s = ds;\n  vec2 dxy = vec2(0);\n  vec2 prevCosSin = vec2(cos(start.z), sin(start.z));\n\n  for (int i = 1; i < numSamples; i++) {\n    float rot = (((((f * s / 6.0 + e / 5.0) * s + d / 4.0) * s + c / 3.0) * s + b / 2.0) * s + a) * s + start.z;\n    float curv = ((((f * s + e) * s + d) * s + c) * s + b) * s + a;\n\n    vec2 cosSin = vec2(cos(rot), sin(rot));\n    dxy = dxy * vec2(float(i - 1) / float(i)) + (cosSin + prevCosSin) / vec2(2 * i);\n\n    pathSamples[i] = vec4(dxy * vec2(s) + start.xy, rot, curv);\n    pathSampleCurvRates[i] = b + s * (2.0 * c + s * (3.0 * d + s * (4.0 * e + 5.0 * f * s)));\n\n    s += ds;\n    prevCosSin = cosSin;\n  }\n\n  return numSamples;\n}\n\n`;\n\nconst NUM_ACCELERATION_PROFILES = 8;\nconst NUM_VELOCITY_RANGES = 4;\nconst NUM_TIME_RANGES = 2;\n\nconst SHARED_UNIFORMS = {\n  xyslMap: { type: 'outputTexture' },\n  slObstacleGrid: { type: 'outputTexture', name: 'slObstacleGridDilated' },\n  slDynamicObstacleGrid: { type: 'outputTexture', name: 'slDynamicObstacleGrid', textureType: '2DArray' },\n  accelerationProfiles: { type: 'float', length: 5 },\n  finalVelocityProfiles: { type: 'float', length: 3 },\n  xyCenterPoint: { type: 'vec2' },\n  xyGridCellSize: { type: 'float' },\n  slCenterPoint: { type: 'vec2' },\n  slGridCellSize: { type: 'float'},\n  laneCenterLatitude: { type: 'float'},\n  laneShoulderLatitude: { type: 'float'},\n  laneCostSlope: { type: 'float'},\n  lanePreference: { type: 'float' },\n  lanePreferenceDiscount: { type: 'float' },\n  obstacleHazardCost: { type: 'float' },\n  speedLimit: { type: 'float' },\n  speedLimitPenalty: { type: 'float' },\n  hardAccelerationPenalty: { type: 'float' },\n  hardDecelerationPenalty: { type: 'float' },\n  softLateralAccelerationLimit: { type: 'float' },\n  softLateralAccelerationPenalty: { type: 'float' },\n  linearLateralAccelerationPenalty: { type: 'float' },\n  dCurvatureMax: { type: 'float' },\n  pathSamplingStep: { type: 'float' },\n  rearAxleToCenter: { type: 'float' },\n  dynamicFrameTime: { type: 'float' }\n};\n\nfunction buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime) {\n  return {\n    accelerationProfiles: [3.5, -6.5, 2.0, -3.0, 0],\n    finalVelocityProfiles: [0.999 * config.speedLimit, 1.0, 0.01],\n    xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y],\n    xyGridCellSize: config.xyGridCellSize,\n    slCenterPoint: [slCenterPoint.x, slCenterPoint.y],\n    slGridCellSize: config.slGridCellSize,\n    laneCenterLatitude: config.laneCenterLatitude,\n    laneShoulderLatitude: config.laneShoulderLatitude,\n    laneCostSlope: config.laneCostSlope,\n    lanePreference: config.lanePreference,\n    lanePreferenceDiscount: config.lanePreferenceDiscount,\n    obstacleHazardCost: config.obstacleHazardCost,\n    speedLimit: config.speedLimit,\n    speedLimitPenalty: config.speedLimitPenalty,\n    hardAccelerationPenalty: config.hardAccelerationPenalty,\n    hardDecelerationPenalty: config.hardDecelerationPenalty,\n    softLateralAccelerationLimit: config.softLateralAccelerationLimit,\n    softLateralAccelerationPenalty: config.softLateralAccelerationPenalty,\n    linearLateralAccelerationPenalty: config.linearLateralAccelerationPenalty,\n    dCurvatureMax: config.dCurvatureMax,\n    pathSamplingStep: config.pathSamplingStep,\n    rearAxleToCenter: config.rearAxleToCenter,\n    dynamicFrameTime: dynamicFrameTime\n  };\n}\n\nexport {\n  SHARED_SHADER,\n  SAMPLE_CUBIC_PATH_FN,\n  SAMPLE_QUINTIC_PATH_FN,\n\n  NUM_ACCELERATION_PROFILES,\n  NUM_VELOCITY_RANGES,\n  NUM_TIME_RANGES,\n\n  SHARED_UNIFORMS,\n  buildUniformValues\n}\n","import { SHARED_SHADER, SAMPLE_CUBIC_PATH_FN, SAMPLE_QUINTIC_PATH_FN, NUM_ACCELERATION_PROFILES, SHARED_UNIFORMS, buildUniformValues } from \"./graphSearchShared.js\";\n\nfunction fromVehiclePathCostsKernel(pathType) {\n  return SHARED_SHADER + (pathType == 'cubic' ? SAMPLE_CUBIC_PATH_FN : SAMPLE_QUINTIC_PATH_FN) +\n\n`\n\n/* Calculate cost of a {cubic|quintic} path from vehicle to (stationConnectivity * numLatitudes * numAccelerations) nodes\n *   width: numLatitudes\n *   height: station * numAccelerations\n */\nvec4 kernel() {\n  ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize));\n\n  int latitude = indexes.x;\n  int station = indexes.y / numAccelerations;\n  int accelerationIndex = int(mod(float(indexes.y), float(numAccelerations)));\n\n  vec4 pathStart = vec4(0, 0, 0, curvVehicle);\n  vec4 pathEnd = texelFetch(lattice, ivec2(latitude, station), 0);\n\n  vec4 pathParams = texelFetch(pathsFromVehicle, ivec2(latitude, station), 0);\n\n  // If the path didn't converge\n  if (pathParams.w == 0.0) return vec4(-1);\n\n  int numSamples = ${pathType == 'cubic' ? 'sampleCubicPath' : 'sampleQuinticPath'}(pathStart, pathEnd, pathParams);\n  float pathLength = pathParams.z;\n\n  if (numSamples < 2) return vec4(-1);\n\n  float averageStaticCost = calculateAverageStaticCost(numSamples);\n  if (averageStaticCost < 0.0) return vec4(-1);\n\n  int slIndex = station * kernelSize.x + latitude;\n  float hysteresisAdjustment = (slIndex == firstLatticePoint || slIndex == secondLatticePoint) ?  0.0 : hysteresisDiscount;\n  averageStaticCost += hysteresisAdjustment;\n\n  vec3 avt = calculateAVT(accelerationIndex, velocityVehicle, 0.0, pathLength);\n  float acceleration = avt.x;\n  float finalVelocity = avt.y;\n  float finalTime = avt.z;\n\n  float averageDynamicCost = calculateAverageDynamicCost(numSamples, pathLength, 0.0, velocityVehicle, acceleration, 1.0 / 0.0);\n  if (averageDynamicCost < 0.0) return vec4(-1);\n\n  averageDynamicCost += accelerationChangePenalty;\n\n  // The cost of a trajectory is the average sample cost scaled by the path length\n  float totalCost = (averageStaticCost + averageDynamicCost + ${pathType == 'cubic' ? '(cubicPathPenalty * velocityVehicle * velocityVehicle)' : '0.0'}) * pathLength;\n  ${pathType != 'cubic' ? 'totalCost = -1.0;' : ''}\n\n  return vec4(totalCost, finalVelocity, finalTime, ${pathType == 'cubic' ? '-2' : '-1'});\n}\n\n`;\n}\n\nexport default {\n  setUp() {\n    return [\n      {\n        kernel: fromVehiclePathCostsKernel('cubic'),\n        output: { name: 'cubicPathFromVehicleCosts' },\n        uniforms: Object.assign({}, SHARED_UNIFORMS, {\n          lattice: { type: 'sharedTexture' },\n          pathsFromVehicle: { type: 'outputTexture', name: 'cubicPathsFromVehicle' },\n          firstLatticePoint: { type: 'int' },\n          secondLatticePoint: { type: 'int' },\n          velocityVehicle: { type: 'float' },\n          curvVehicle: { type: 'float' },\n          numAccelerations: { type: 'int' },\n          cubicPathPenalty: { type: 'float' },\n          hysteresisDiscount: { type: 'float' },\n          accelerationChangePenalty: { type: 'float' }\n        })\n      },\n      {\n        kernel: fromVehiclePathCostsKernel('quintic'),\n        output: { name: 'quinticPathFromVehicleCosts' },\n        uniforms: Object.assign({}, SHARED_UNIFORMS, {\n          lattice: { type: 'sharedTexture' },\n          pathsFromVehicle: { type: 'outputTexture', name: 'quinticPathsFromVehicle' },\n          firstLatticePoint: { type: 'int' },\n          secondLatticePoint: { type: 'int' },\n          velocityVehicle: { type: 'float' },\n          curvVehicle: { type: 'float' },\n          dCurvVehicle: { type: 'float' },\n          ddCurvVehicle: { type: 'float' },\n          numAccelerations: { type: 'int' },\n          hysteresisDiscount: { type: 'float' },\n          accelerationChangePenalty: { type: 'float' }\n        })\n      }\n    ];\n  },\n\n  update(config, pose, xyCenterPoint, slCenterPoint, firstLatticePoint, secondLatticePoint, dynamicFrameTime) {\n    return [\n      {\n        width: config.lattice.numLatitudes,\n        height: config.lattice.stationConnectivity * NUM_ACCELERATION_PROFILES,\n        uniforms: Object.assign({}, buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime), {\n          firstLatticePoint: firstLatticePoint,\n          secondLatticePoint: secondLatticePoint,\n          velocityVehicle: pose.velocity,\n          curvVehicle: pose.curv,\n          numAccelerations: NUM_ACCELERATION_PROFILES,\n          cubicPathPenalty: config.cubicPathPenalty,\n          hysteresisDiscount: config.hysteresisDiscount,\n          accelerationChangePenalty: config.accelerationChangePenalty\n        })\n      },\n      {\n        width: config.lattice.numLatitudes,\n        height: config.lattice.stationConnectivity * NUM_ACCELERATION_PROFILES,\n        uniforms: Object.assign({}, buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime), {\n          firstLatticePoint: firstLatticePoint,\n          secondLatticePoint: secondLatticePoint,\n          velocityVehicle: pose.velocity,\n          curvVehicle: pose.curv,\n          dCurvVehicle: pose.dCurv,\n          ddCurvVehicle: pose.ddCurv,\n          numAccelerations: NUM_ACCELERATION_PROFILES,\n          hysteresisDiscount: config.hysteresisDiscount,\n          accelerationChangePenalty: config.accelerationChangePenalty\n        })\n      }\n    ];\n  }\n}\n","/* State Lattice Cost Map\n * \n * 5-dimensional node: station, latitude, acceleration profile, velocity, time\n *\n * A draw call per station s\n *   * Input to kernel: latitude l, acceleration profile a, velocity range v, time range t\n *   * Find all SL vertices that can connect to this node\n *   * For each of those vertices, check if any terminate in this specific velocity and time range\n *     * Based on initial velocity, initial time, and acceleration\n *     * Each connected SL vertex should have a * v * t nodes that could possibly terminate at this node\n *   * For all valid edges, find the one with the lowest cost\n *\n * Input:\n *   * 2D texture array cost map\n *     * Height: num of latitudes (~20)\n *     * Width: num of acceleration profiles * num of time ranges * num of velocity ranges (8 * 2 * 4 = ~64)\n *       * A flattened 3D array:\n *         d1: acceleration\n *         d2: velocity\n *         d3: time\n *     * Layer: num of stations (~10)\n *   \n * Output:\n *   * 2D texture slice of the next station in the input 2D texture array cost map\n *\n * Cost Map Elements:\n *   * Traversal cost so far\n *   * Ending velocity\n *   * Ending time\n *   * Index of parent node\n *\n * Since one cubic path can be shared between multiple trajectories, they need to be pre-optimized.\n *\n * Quintic Paths:\n *   Stations 0 through (numStations - 1) correspond to the stations on the lattice; however,\n *   a new station (station -1) will be used to signifiy the single vehicle pose node. Either\n *   a cubic path or quintic path can be used to connect this single node to the lattice\n *   (depending on vehicle velocity). At station -1, latitude 0 will correspond to a cubic path,\n *   and latitude 1 will correspond to a quintic path. All other latitudes will be skipped.\n */\n\nimport { SHARED_SHADER, SAMPLE_CUBIC_PATH_FN, SAMPLE_QUINTIC_PATH_FN, NUM_ACCELERATION_PROFILES, NUM_VELOCITY_RANGES, NUM_TIME_RANGES, SHARED_UNIFORMS, buildUniformValues } from \"./graphSearchShared.js\";\n\nconst SOLVE_STATION_KERNEL =\n  SHARED_SHADER +\n  SAMPLE_CUBIC_PATH_FN +\n  SAMPLE_QUINTIC_PATH_FN +\n\n`\n\nvec4 kernel() {\n  ivec2 indexes = ivec2(kernelPosition * vec2(kernelSize));\n\n  int latitude = indexes.y;\n\n  int numPerTime = numAccelerations * numVelocities;\n  int timeIndex = indexes.x / numPerTime;\n  indexes.x -= timeIndex * numPerTime;\n  int velocityIndex = indexes.x / numAccelerations;\n  int accelerationIndex = int(mod(float(indexes.x), float(numAccelerations)));\n\n  int minLatitude = max(latitude - latitudeConnectivity / 2, 0);\n  int maxLatitude = min(latitude + latitudeConnectivity / 2, numLatitudes - 1);\n\n  int slIndex = station * numLatitudes + latitude;\n\n  vec4 pathEnd = texelFetch(lattice, ivec2(latitude, station), 0);\n\n  float minVelocity = velocityRanges[velocityIndex];\n  float maxVelocity = velocityRanges[velocityIndex + 1];\n\n  float minTime = timeRanges[timeIndex];\n  float maxTime = timeRanges[timeIndex + 1];\n\n  vec4 bestTrajectory = vec4(-1); // -1 means infinite cost\n  float bestTerminalCost = 1.0 / 0.0;\n\n  float hysteresisAdjustment = (slIndex == firstLatticePoint || slIndex == secondLatticePoint) ?  0.0 : hysteresisDiscount;\n\n  for (int prevStation = max(station - stationConnectivity, 0); prevStation < station; prevStation++) {\n    int stationConnectivityIndex = prevStation - station + stationConnectivity;\n\n    for (int prevLatitude = minLatitude; prevLatitude <= maxLatitude; prevLatitude++) {\n      int latitudeConnectivityIndex = prevLatitude - latitude + latitudeConnectivity / 2;\n      int connectivityIndex = stationConnectivityIndex * latitudeConnectivity + latitudeConnectivityIndex;\n\n      vec4 pathStart = texelFetch(lattice, ivec2(prevLatitude, prevStation), 0);\n      vec4 cubicPathParams = texelFetch(cubicPaths, ivec2(slIndex, connectivityIndex), 0);\n\n      // If the path didn't converge\n      if (cubicPathParams.w == 0.0) continue;\n\n      int numSamples = sampleCubicPath(pathStart, pathEnd, cubicPathParams);\n      float pathLength = cubicPathParams.z;\n\n      if (numSamples < 2) continue;\n\n      float averageStaticCost = calculateAverageStaticCost(numSamples);\n      if (averageStaticCost < 0.0) continue;\n\n      averageStaticCost += hysteresisAdjustment;\n\n      if (averageStaticCost * pathLength >= bestTerminalCost) continue;\n\n      for (int prevVelocity = 0; prevVelocity < numVelocities; prevVelocity++) {\n        for (int prevTime = 0; prevTime < numTimes; prevTime++) {\n          for (int prevAccel = 0; prevAccel < numAccelerations; prevAccel++) {\n            int avtIndex = prevTime * numPerTime + prevVelocity * numAccelerations + prevAccel;\n\n            // Cost table entry:\n            //   x: cost so far\n            //   y: end velocity\n            //   z: end time\n            //   w: parent index\n            vec4 costTableEntry = texelFetch(costTable, ivec3(avtIndex, prevLatitude, prevStation), 0);\n\n            // If cost entry is infinity\n            if (costTableEntry.x < 0.0 || averageStaticCost * pathLength + costTableEntry.x >= bestTerminalCost) continue;\n\n            vec3 avt = calculateAVT(accelerationIndex, costTableEntry.y, costTableEntry.z, pathLength);\n            float acceleration = avt.x;\n            float finalVelocity = avt.y;\n            float finalTime = avt.z;\n\n            if (averageStaticCost * pathLength + costTableEntry.x + extraTimePenalty * finalTime >= bestTerminalCost) continue;\n\n            // If the calculated final velocity does not match this fragment's velocity range, then skip this trajectory\n            if (finalVelocity < minVelocity || finalVelocity >= maxVelocity) continue;\n\n            // If the calculated final time does not match this fragment's time range, then skip this trajectory\n            if (finalTime < minTime || finalTime >= maxTime) continue;\n\n            float abandonThreshold = (bestTerminalCost - extraTimePenalty * finalTime - costTableEntry.x) / pathLength - averageStaticCost;\n            float averageDynamicCost = calculateAverageDynamicCost(numSamples, pathLength, costTableEntry.z, costTableEntry.y, acceleration, abandonThreshold);\n            if (averageDynamicCost < 0.0) continue;\n\n            if (accelerationIndex != prevAccel)\n              averageDynamicCost += accelerationChangePenalty;\n\n            // The cost of a trajectory is the average sample cost scaled by the path length\n            float totalCost = (averageStaticCost + averageDynamicCost) * pathLength + costTableEntry.x;\n\n            float terminalCost = totalCost + extraTimePenalty * finalTime;\n            if (terminalCost >= bestTerminalCost) continue;\n            bestTerminalCost = terminalCost;\n\n            int incomingIndex = avtIndex + numPerTime * numTimes * (prevLatitude + numLatitudes * prevStation);\n            bestTrajectory = vec4(totalCost, finalVelocity, finalTime, incomingIndex);\n          }\n        }\n      }\n    }\n  }\n\n  if (station < stationConnectivity) {\n    ivec2 slaIndex = ivec2(latitude, station * numAccelerations + accelerationIndex);\n\n    vec4 costTableEntry = texelFetch(cubicPathFromVehicleCosts, slaIndex, 0);\n    float terminalCost;\n\n    if (costTableEntry.x >= 0.0) {\n      terminalCost = costTableEntry.x + extraTimePenalty * costTableEntry.z;\n\n      if (terminalCost < bestTerminalCost) {\n        bestTerminalCost = terminalCost;\n        bestTrajectory = costTableEntry;\n      }\n    }\n\n    costTableEntry = texelFetch(quinticPathFromVehicleCosts, slaIndex, 0);\n\n    if (costTableEntry.x >= 0.0) {\n      terminalCost = costTableEntry.x + extraTimePenalty * costTableEntry.z;\n\n      if (terminalCost < bestTerminalCost) {\n        bestTerminalCost = terminalCost;\n        bestTrajectory = costTableEntry;\n      }\n    }\n  }\n\n  return bestTrajectory;\n}\n\n`;\n\nexport default {\n  setUp() {\n    return {\n      kernel: SOLVE_STATION_KERNEL,\n      output: { name: 'graphSearch' },\n      uniforms: Object.assign({}, SHARED_UNIFORMS, {\n        lattice: { type: 'sharedTexture' },\n        costTable: { type: 'sharedTexture', textureType: '2DArray' },\n        cubicPaths: { type: 'outputTexture' },\n        cubicPathFromVehicleCosts: { type: 'outputTexture' },\n        quinticPathFromVehicleCosts: { type: 'outputTexture' },\n        firstLatticePoint: { type: 'int' },\n        secondLatticePoint: { type: 'int' },\n        velocityVehicle: { type: 'float' },\n        curvVehicle: { type: 'float' },\n        dCurvVehicle: { type: 'float' },\n        ddCurvVehicle: { type: 'float' },\n        extraTimePenalty: { type: 'float' },\n        hysteresisDiscount: { type: 'float' },\n        accelerationChangePenalty: { type: 'float' },\n        numStations: { type: 'int' },\n        numLatitudes: { type: 'int' },\n        numAccelerations: { type: 'int' },\n        numVelocities: { type: 'int' },\n        numTimes: { type: 'int' },\n        stationConnectivity: { type: 'int' },\n        latitudeConnectivity: { type: 'int' },\n        velocityRanges: { type: 'float', length: NUM_VELOCITY_RANGES + 1 },\n        timeRanges: { type: 'float', length: NUM_TIME_RANGES + 1 },\n        station: { type: 'int' } // Updated in `drawProxy`\n      }),\n      drawProxy: (gpgpu, program, draw) => {\n        const width = NUM_ACCELERATION_PROFILES * NUM_VELOCITY_RANGES * NUM_TIME_RANGES;\n        const height = program.meta.lattice.numLatitudes;\n        const costTable = new Float32Array(width * height * program.meta.lattice.numStations * 4);\n\n        for (let s = 0; s < program.meta.lattice.numStations; s++) {\n          gpgpu.updateProgramUniforms(program, { station: s });\n          draw();\n\n          gpgpu.gl.readPixels(0, 0, width, height, gpgpu.gl.RGBA, gpgpu.gl.FLOAT, costTable, s * width * height * 4);\n\n          gpgpu.gl.bindTexture(gpgpu.gl.TEXTURE_2D_ARRAY, gpgpu.sharedTextures.costTable);\n          gpgpu.gl.copyTexSubImage3D(gpgpu.gl.TEXTURE_2D_ARRAY, 0, 0, 0, s, 0, 0, width, height);\n        }\n\n        gpgpu._graphSearchCostTable = costTable;\n      }\n    };\n  },\n\n  update(config, pose, xyCenterPoint, slCenterPoint, firstLatticePoint, secondLatticePoint, dynamicFrameTime) {\n    return {\n      width: NUM_ACCELERATION_PROFILES * NUM_VELOCITY_RANGES * NUM_TIME_RANGES,\n      height: config.lattice.numLatitudes,\n      meta: {\n        lattice: config.lattice\n      },\n      uniforms: Object.assign({}, buildUniformValues(config, xyCenterPoint, slCenterPoint, dynamicFrameTime), {\n        firstLatticePoint: firstLatticePoint,\n        secondLatticePoint: secondLatticePoint,\n        velocityVehicle: pose.velocity,\n        curvVehicle: pose.curv,\n        dCurvVehicle: pose.dCurv,\n        ddCurvVehicle: pose.ddCurv,\n        extraTimePenalty: config.extraTimePenalty,\n        hysteresisDiscount: config.hysteresisDiscount,\n        accelerationChangePenalty: config.accelerationChangePenalty,\n        numStations: config.lattice.numStations,\n        numLatitudes: config.lattice.numLatitudes,\n        numAccelerations: NUM_ACCELERATION_PROFILES,\n        numVelocities: NUM_VELOCITY_RANGES,\n        numTimes: NUM_TIME_RANGES,\n        stationConnectivity: config.lattice.stationConnectivity,\n        latitudeConnectivity: config.lattice.latitudeConnectivity,\n        velocityRanges: [0, config.speedLimit / 3, config.speedLimit * 2 / 3, config.speedLimit, 1000000],\n        timeRanges: [0, 10, 1000000]\n      })\n    };\n  }\n}\n","const XY_OBSTACLE_COST_KERNEL = `\n\nvec4 kernel() {\n  vec2 xy = (kernelPosition - 0.5) * vec2(kernelSize) * vec2(xyGridCellSize) + xyCenterPoint;\n\n  vec2 xyTexCoords = (xy - xyCenterPoint) / vec2(textureSize(xyslMap, 0)) / vec2(xyGridCellSize) + 0.5;\n  vec2 sl = texture(xyslMap, xyTexCoords).xy;\n\n  vec2 slTexCoords = (sl - slCenterPoint) / vec2(textureSize(slObstacleGrid, 0)) / vec2(slGridCellSize) + 0.5;\n  return texture(slObstacleGrid, slTexCoords);\n}\n\n`;\n\n// Build XY obstacle costs using XYSL map\nexport default {\n  setUp() {\n    return {\n      kernel: XY_OBSTACLE_COST_KERNEL,\n      output: { name: 'xyObstacleCostGrid', read: true },\n      uniforms: {\n        xyslMap: { type: 'outputTexture' },\n        slObstacleGrid: { type: 'outputTexture', name: 'slObstacleGridDilated' },\n        xyCenterPoint: { type: 'vec2' },\n        xyGridCellSize: { type: 'float'},\n        slCenterPoint: { type: 'vec2' },\n        slGridCellSize: { type: 'float'}\n      }\n    };\n  },\n\n  update(config, xyWidth, xyHeight, xyCenterPoint, slCenterPoint) {\n    return {\n      width: xyWidth,\n      height: xyHeight,\n      uniforms: {\n        xyCenterPoint: [xyCenterPoint.x, xyCenterPoint.y],\n        xyGridCellSize: config.xyGridCellSize,\n        slCenterPoint: [slCenterPoint.x, slCenterPoint.y],\n        slGridCellSize: config.slGridCellSize\n      }\n    };\n  }\n}\n","import GPGPU from \"../../GPGPU.js\";\nimport Car from \"../../physics/Car.js\";\nimport CubicPath from \"./CubicPath.js\";\nimport QuinticPath from \"./QuinticPath.js\";\nimport xyObstacleGrid from \"./gpgpu-programs/xyObstacleGrid.js\";\nimport slObstacleGrid from \"./gpgpu-programs/slObstacleGrid.js\";\nimport slObstacleGridDilation from \"./gpgpu-programs/slObstacleGridDilation.js\";\nimport slDynamicObstacleGrid from \"./gpgpu-programs/slDynamicObstacleGrid.js\";\nimport xyslMap from \"./gpgpu-programs/xyslMap.js\";\nimport optimizeCubicPaths from \"./gpgpu-programs/optimizeCubicPaths.js\";\nimport optimizeQuinticPaths from \"./gpgpu-programs/optimizeQuinticPaths.js\";\nimport pathFromVehicleCosts from \"./gpgpu-programs/pathFromVehicleCosts.js\";\nimport graphSearch from \"./gpgpu-programs/graphSearch.js\";\nimport xyObstacleCostGrid from \"./gpgpu-programs/xyObstacleCostGrid.js\";\n\nconst NUM_ACCELERATION_PROFILES = 8;\nconst NUM_VELOCITY_RANGES = 4;\nconst NUM_TIME_RANGES = 2;\n\n/* Obstacle cost map:\n *\n * 1. Rasterize triangles from polygonal obstacles into XY-space occupancy grid\n * 2. Convert occupancy grid to SL-space\n *    * Width is spatial horizon of the state lattice\n *    * Height is lane width\n *    * Resolution should be higher than XY-grid\n *    * Get XY position from centerline texture\n *    * Lookup XY in XY occupancy grid (nearest)\n * 3. Dilate SL-space grid using two passes (along station, then along latitude)\n *    * collision area: half car size + 0.3m\n *    * high cost area: 1 meter\n * 4. Convert back to XY-space using XYSL map\n */\n\nexport default class PathPlanner {\n  constructor() {\n    this.previousStartStation = null;\n    this.previousFirstLatticePoint = -1;\n    this.previousSecondLatticePoint = -1;\n    this.previousFirstAcceleration = -1;\n    this.previousSecondLatticePoint = -1;\n\n    let start = performance.now();\n    const programs = [\n      xyObstacleGrid.setUp(),\n      slObstacleGrid.setUp(),\n      ...slObstacleGridDilation.setUp(),\n      slDynamicObstacleGrid.setUp(),\n      xyslMap.setUp(),\n      ...optimizeCubicPaths.setUp(),\n      optimizeQuinticPaths.setUp(),\n      ...pathFromVehicleCosts.setUp(),\n      graphSearch.setUp(),\n    ].map(p => Object.assign({}, p, { width: 1, height: 1 }));\n\n    this.gpgpu = new GPGPU(programs);\n  }\n\n  reset() {\n    this.previousStartStation = null;\n    this.previousFirstLatticePoint = -1;\n    this.previousSecondLatticePoint = -1;\n    this.previousFirstAcceleration = -1;\n    this.previousSecondLatticePoint = -1;\n  }\n\n  plan(vehiclePose, vehicleStation, lanePath, startTime, staticObstacles, dynamicObstacles) {\n    const latticeStationInterval = this._latticeStationInterval();\n\n    const centerlineRaw = lanePath.sampleStations(vehicleStation, Math.ceil((this.config.spatialHorizon + latticeStationInterval) / this.config.centerlineStationInterval) + 1, this.config.centerlineStationInterval);\n\n    // Transform all centerline points into vehicle frame\n    const vehicleXform = vehicleTransform(vehiclePose);\n    const centerline = centerlineRaw.map(c => { return { pos: c.pos.clone().applyMatrix3(vehicleXform), rot: c.rot - vehiclePose.rot, curv: c.curv } });\n\n    const centerlineData = new Float32Array(centerline.length * 3);\n    const maxPoint = new THREE.Vector2(0, 0);\n    const minPoint = new THREE.Vector2(0, 0);\n\n    for (let i = 0; i < centerline.length; i++) {\n      const sample = centerline[i];\n      const pos = sample.pos;\n      centerlineData[i * 3 + 0] = pos.x;\n      centerlineData[i * 3 + 1] = pos.y;\n      centerlineData[i * 3 + 2] = sample.rot;\n\n      maxPoint.max(pos);\n      minPoint.min(pos);\n    }\n\n    const diff = maxPoint.clone().sub(minPoint);\n    const xyCenterPoint = minPoint.clone().add(maxPoint).divideScalar(2);\n\n    // Sizes of the xy grids (in pixels, not meters)\n    const xyWidth = Math.ceil((diff.x + this.config.gridMargin * 2) / this.config.xyGridCellSize);\n    const xyHeight = Math.ceil((diff.y + this.config.gridMargin * 2) / this.config.xyGridCellSize);\n\n    const stationWidth = this.config.spatialHorizon + latticeStationInterval * 2;\n    const slCenterPoint = new THREE.Vector2(this.config.spatialHorizon / 2, 0);\n\n    // Sizes of the sl grids (in pixels, not meters)\n    const slWidth = Math.ceil(stationWidth / this.config.slGridCellSize);\n    const slHeight = Math.ceil((this.config.roadWidth + this.config.gridMargin * 2) / this.config.slGridCellSize);\n\n    let startStation;\n\n    if (this.previousStartStation === null || vehicleStation + latticeStationInterval / 2 > this.previousStartStation) {\n      startStation = (this.previousStartStation === null ? vehicleStation : this.previousStartStation) + latticeStationInterval;\n      this.previousStartStation = startStation;\n      this.previousFirstLatticePoint -= this.config.lattice.numLatitudes;\n      this.previousSecondLatticePoint -= this.config.lattice.numLatitudes;\n    } else {\n      startStation = this.previousStartStation;\n    }\n\n    const lattice = this._buildLattice(lanePath, startStation, vehiclePose.rot, vehicleXform);\n\n    const temporalHorizon = this.config.spatialHorizon / this.config.speedLimit;\n    const dynamicFrameTime = temporalHorizon / this.config.numDynamicFrames;\n\n    for (const [i, p] of [\n      xyObstacleGrid.update(this.config, xyWidth, xyHeight, xyCenterPoint, vehicleXform, staticObstacles),\n      slObstacleGrid.update(this.config, slWidth, slHeight, slCenterPoint, xyCenterPoint),\n      ...slObstacleGridDilation.update(this.config, slWidth, slHeight),\n      slDynamicObstacleGrid.update(this.config, slWidth, slHeight, slCenterPoint, vehicleStation, startTime, dynamicFrameTime, dynamicObstacles),\n      xyslMap.update(this.config, xyWidth, xyHeight, xyCenterPoint),\n      ...optimizeCubicPaths.update(this.config, vehiclePose),\n      optimizeQuinticPaths.update(this.config, vehiclePose),\n      ...pathFromVehicleCosts.update(this.config, vehiclePose, xyCenterPoint, slCenterPoint, this.previousFirstLatticePoint, this.previousSecondLatticePoint, dynamicFrameTime),\n      graphSearch.update(this.config, vehiclePose, xyCenterPoint, slCenterPoint, this.previousFirstLatticePoint, this.previousSecondLatticePoint, dynamicFrameTime)\n    ].entries()) {\n      this.gpgpu.updateProgram(i, p);\n    }\n\n    this.gpgpu.updateSharedTextures({\n      centerline: {\n        width: centerline.length,\n        height: 1,\n        channels: 3,\n        filter: 'linear',\n        data: centerlineData\n      },\n      costTable: {\n        width: NUM_ACCELERATION_PROFILES * NUM_VELOCITY_RANGES * NUM_TIME_RANGES,\n        height: this.config.lattice.numLatitudes,\n        depth: this.config.lattice.numStations,\n        channels: 4,\n        textureType: '2DArray'\n      },\n      lattice: {\n        width: this.config.lattice.numLatitudes,\n        height: this.config.lattice.numStations,\n        channels: 4,\n        data: lattice\n      }\n    });\n\n    this.gpgpu._graphSearchCostTable = null;\n    this.gpgpu._dynamicObstacleGrid = null;\n\n    let start = performance.now();\n    const outputs = this.gpgpu.run();\n    const costTable = this.gpgpu._graphSearchCostTable;\n    const cubicPathParams = outputs[6];\n    const cubicPathFromVehicleParams = outputs[7];\n    const quinticPathFromVehicleParams = outputs[8];\n\n    let bestEntry = [Number.POSITIVE_INFINITY];\n    let bestEntryIndex;\n    const numEntries = costTable.length / 4;\n\n    for (let i = 0; i < numEntries; i++) {\n      const entryUnpacked = this._unpackCostTableIndex(i);\n      const entry = [\n        costTable[i * 4],\n        costTable[i * 4 + 1],\n        costTable[i * 4 + 2],\n        costTable[i * 4 + 3]\n      ];\n\n      if (entry[0] < 0) continue;\n\n      entry[0] += this._terminalCost(entryUnpacked, entry);\n\n      if (entry[0] < bestEntry[0]) {\n        bestEntryIndex = i;\n        bestEntry = entry;\n      }\n    }\n\n    const inverseVehicleXform = (new THREE.Matrix3()).getInverse(vehicleXform);\n    let bestTrajectory = null;\n    let fromVehicleSegment = null;\n    let fromVehicleParams = null;\n    let firstLatticePoint = -1;\n    let firstAcceleration = -1;\n    let secondLatticePoint = -1;\n    let secondAcceleration = -1;\n\n    if (isFinite(bestEntry[0])) {\n      [bestTrajectory, fromVehicleSegment, fromVehicleParams, firstLatticePoint, firstAcceleration, secondLatticePoint, secondAcceleration] = this._reconstructTrajectory(\n        bestEntryIndex,\n        costTable,\n        cubicPathParams,\n        cubicPathFromVehicleParams,\n        quinticPathFromVehicleParams,\n        vehiclePose,\n        lattice\n      );\n\n      fromVehicleSegment.forEach(p => {\n        p.pos = p.pos.applyMatrix3(inverseVehicleXform);\n        p.rot += vehiclePose.rot;\n      });\n\n      bestTrajectory.forEach(p => {\n        p.pos = p.pos.applyMatrix3(inverseVehicleXform);\n        p.rot += vehiclePose.rot;\n      });\n    }\n\n    this.previousFirstLatticePoint = firstLatticePoint;\n    this.previousFirstAcceleration = firstAcceleration;\n    this.previousSecondLatticePoint = secondLatticePoint;\n    this.previousSecondAcceleration = secondAcceleration;\n\n    return {\n      path: bestTrajectory,\n      fromVehicleSegment: fromVehicleSegment,\n      fromVehicleParams: fromVehicleParams,\n      latticeStartStation: this.previousStartStation,\n      dynamicObstacleGrid: { data: this.gpgpu._dynamicObstacleGrid, width: slWidth, height: slHeight }\n    };\n  }\n\n  _buildLattice(lanePath, startStation, vehicleRot, vehicleXform) {\n    const centerline = lanePath.sampleStations(startStation, this.config.lattice.numStations, this._latticeStationInterval());\n    const offset = Math.floor(this.config.lattice.numLatitudes / 2);\n    const lattice = new Float32Array(this.config.lattice.numStations * this.config.lattice.numLatitudes * 4);\n    let index = 0;\n\n    for (let s = 0; s < centerline.length; s++) {\n      const sample = centerline[s];\n\n      for (let l = 0; l < this.config.lattice.numLatitudes; l++) {\n        const latitude = (l - offset) / offset * this.config.roadWidth / 2;\n        const rot = sample.rot - vehicleRot;\n        const pos = THREE.Vector2.fromAngle(rot + Math.PI / 2).multiplyScalar(latitude).add(sample.pos.clone().applyMatrix3(vehicleXform));\n        const curv = sample.curv == 0 ? 0 : 1 / (1 / sample.curv - latitude);\n\n        lattice[index++] = pos.x;\n        lattice[index++] = pos.y;\n        lattice[index++] = rot;\n        lattice[index++] = curv;\n      }\n    }\n\n    return lattice;\n  }\n\n  _latticeStationInterval() {\n    return this.config.spatialHorizon / this.config.lattice.numStations;\n  }\n\n  _terminalCost([stationIndex, latitudeIndex, timeIndex, velocityIndex, accelerationIndex], [cost, finalVelocity, finalTime, incomingIndex]) {\n    // Only consider vertices that reach the end of the spatial or temporal horizon\n    if (stationIndex != this.config.lattice.numStations - 1 && finalVelocity > 0.05)\n      return Number.POSITIVE_INFINITY;\n\n    const station = (this.config.spatialHorizon / this.config.lattice.numStations) * (stationIndex + 1);\n\n    return station * -this.config.stationReachDiscount + finalTime * this.config.extraTimePenalty;\n  }\n\n  _unpackCostTableIndex(index) {\n    if (index < 0) return [-1, index + 2, null, null, null];\n\n    const numPerTime = NUM_ACCELERATION_PROFILES * NUM_VELOCITY_RANGES;\n    const numPerLatitude = numPerTime * NUM_TIME_RANGES;\n    const numPerStation = this.config.lattice.numLatitudes * numPerLatitude;\n\n    const stationIndex = Math.floor(index / numPerStation);\n    index -= stationIndex * numPerStation;\n\n    const latitudeIndex = Math.floor(index / numPerLatitude);\n    index -= latitudeIndex * numPerLatitude;\n\n    const timeIndex = Math.floor(index / numPerTime);\n    index -= timeIndex * numPerTime;\n\n    const velocityIndex = Math.floor(index / NUM_ACCELERATION_PROFILES);\n    const accelerationIndex = index % NUM_ACCELERATION_PROFILES;\n\n    return [stationIndex, latitudeIndex, timeIndex, velocityIndex, accelerationIndex];\n  }\n\n  _reconstructTrajectory(index, costTable, cubicPathParams, cubicPathFromVehicleParams, quinticPathFromVehicleParams, vehiclePose, lattice) {\n    let unpacked = this._unpackCostTableIndex(index);\n    unpacked.push(costTable[index * 4 + 1]);\n    const nodes = [unpacked];\n\n    let count = 0;\n    while (unpacked[0] >= 0 && count++ < 100) {\n      index = costTable[index * 4 + 3];\n      unpacked = this._unpackCostTableIndex(index);\n\n      const finalVelocity = unpacked[0] >= 0 ? costTable[index * 4 + 1] : vehiclePose.velocity;\n      unpacked.push(finalVelocity);\n\n      nodes.unshift(unpacked);\n    }\n    if (count >= 100) throw new Error('Infinite loop encountered while reconstructing trajectory.');\n\n    const points = [];\n    let fromVehicleSegment = [];\n    let fromVehicleParams = null;\n\n    for (let i = 0; i < nodes.length - 1; i++) {\n      const [prevStation, prevLatitude, _pt, _pv, _pa, prevVelocity] = nodes[i];\n      const [station, latitude, _t, _v, _a, velocity] = nodes[i + 1];\n\n      let length;\n      let pathBuilder;\n\n      if (prevStation < 0) {\n        const start = {\n          pos: new THREE.Vector2(0, 0),\n          rot: 0,\n          curv: vehiclePose.curv\n        };\n\n        const endIndex = (station * this.config.lattice.numLatitudes + latitude) * 4;\n        const end = {\n          pos: new THREE.Vector2(lattice[endIndex], lattice[endIndex + 1]),\n          rot: lattice[endIndex + 2],\n          curv: lattice[endIndex + 3]\n        };\n\n        if (prevLatitude == 0) { // Cubic path from vehicle to lattice node\n          length = cubicPathFromVehicleParams[endIndex + 2];\n\n          const params = {\n            p1: cubicPathFromVehicleParams[endIndex],\n            p2: cubicPathFromVehicleParams[endIndex + 1],\n            sG: length\n          };\n\n          pathBuilder = new CubicPath(start, end, params);\n\n          fromVehicleParams = { type: 'cubic', params: params };\n        } else { // Quintic path from vehicle to lattice node\n          length = quinticPathFromVehicleParams[endIndex + 2];\n\n          const params = {\n            p3: quinticPathFromVehicleParams[endIndex],\n            p4: quinticPathFromVehicleParams[endIndex + 1],\n            sG: length\n          };\n\n          pathBuilder = new QuinticPath(start, end, params);\n\n          fromVehicleParams = { type: 'quintic', params: params };\n        }\n      } else {\n        const startIndex = (prevStation * this.config.lattice.numLatitudes + prevLatitude) * 4;\n        const endIndex = (station * this.config.lattice.numLatitudes + latitude) * 4;\n\n        const start = {\n          pos: new THREE.Vector2(lattice[startIndex], lattice[startIndex + 1]),\n          rot: lattice[startIndex + 2],\n          curv: lattice[startIndex + 3]\n        };\n\n        const end = {\n          pos: new THREE.Vector2(lattice[endIndex], lattice[endIndex + 1]),\n          rot: lattice[endIndex + 2],\n          curv: lattice[endIndex + 3]\n        };\n\n        const slIndex = station * this.config.lattice.numLatitudes + latitude;\n        const connectivityIndex = (prevStation - station + this.config.lattice.stationConnectivity) * this.config.lattice.latitudeConnectivity + prevLatitude - latitude + Math.floor(this.config.lattice.latitudeConnectivity / 2);\n        const cubicPathIndex = (connectivityIndex * this.config.lattice.numStations * this.config.lattice.numLatitudes + slIndex) * 4;\n\n        length = cubicPathParams[cubicPathIndex + 2];\n\n        pathBuilder = new CubicPath(start, end, {\n          p1: cubicPathParams[cubicPathIndex],\n          p2: cubicPathParams[cubicPathIndex + 1],\n          sG: length\n        });\n      }\n\n      const path = pathBuilder.buildPath(Math.ceil(length / 0.25));\n\n      const prevVelocitySq = prevVelocity * prevVelocity;\n      const accel = (velocity * velocity - prevVelocitySq) / 2 / length;\n      const ds = length / (path.length - 1);\n      let s = 0;\n\n      for (let p = 0; p < path.length; p++) {\n        path[p].velocity = Math.sqrt(2 * accel * s + prevVelocitySq);\n        path[p].acceleration = accel;\n        s += ds;\n      }\n\n      if (prevStation < 0) {\n        fromVehicleSegment = path;\n      } else {\n        if (i > 0) path.shift();\n        points.push(...path);\n      }\n    }\n\n    let firstLatticePoint = null\n    let firstAcceleration = null;\n    let secondLatticePoint = null;\n    let secondAcceleration = null;\n\n    if (nodes.length >= 2) {\n      firstLatticePoint = nodes[1][0] * this.config.lattice.numLatitudes + nodes[1][1];\n      firstAcceleration = nodes[1][4];\n    }\n\n    if (nodes.length >= 3) {\n      secondLatticePoint = nodes[2][0] * this.config.lattice.numLatitudes + nodes[2][1];\n      secondAcceleration = nodes[2][4];\n    }\n\n    return [points, fromVehicleSegment, fromVehicleParams, firstLatticePoint, firstAcceleration, secondLatticePoint, secondAcceleration];\n  }\n}\n\nfunction vehicleTransform({ pos, rot }) {\n  const translate = new THREE.Matrix3();\n  translate.set(\n    1, 0, -pos.x,\n    0, 1, -pos.y,\n    0, 0, 1\n  );\n\n  const cosRot = Math.cos(rot);\n  const sinRot = Math.sin(rot);\n\n  const rotate = new THREE.Matrix3();\n  rotate.set(\n    cosRot, sinRot, 0,\n    -sinRot, cosRot, 0,\n    0, 0, 1\n  );\n\n  return rotate.multiply(translate);\n}\n\nfunction obstacleTransform(vehicleXform, xyCenterPoint, width, height) {\n  const translate = new THREE.Matrix3();\n  translate.set(\n    1, 0, -xyCenterPoint.x,\n    0, 1, -xyCenterPoint.y,\n    0, 0, 1\n  );\n\n  const scale = new THREE.Matrix3();\n  scale.set(\n    2 / width, 0, 0,\n    0, 2 / height, 0,\n    0, 0, 1\n  );\n\n  return scale.multiply(translate).multiply(vehicleXform);\n}\n","\nexport default class ExternalPathPlanner {\n  _PLANNING_SERVER_URL = 'http://127.0.0.1:9999/'\n\n  plan(vehiclePose, vehicleStation, lanePath, startTime, staticObstacles, dynamicObstacles) {\n    const state = {\n      vehiclePose: vehiclePose,\n      vehicleStation: vehicleStation,\n      lanePath: lanePath,\n      startTime: startTime,\n      staticObstacles: staticObstacles,\n      dynamicObstacles: dynamicObstacles,\n    };\n\n    var jsonToSend = JSON.stringify(state);\n    const response = this._send_request(jsonToSend, 'plan');\n    const path = JSON.parse(response)['states'];\n\n    return {\n      planner_state: \"ok\",\n      path: path,\n      fromVehicleSegment: [],\n      fromVehicleParams: { type:'null' },\n      latticeStartStation: null,\n      dynamicObstacleGrid: null\n    };\n  }\n\n  reset() {\n    //this.notify_scenario_status({status: \"restart\"});\n  }\n\n  notify_scenario_status(status) {\n    var jsonToSend = JSON.stringify(status);\n    this._send_request(jsonToSend, 'notify_case_status');\n  }\n\n  _send_request(jsonToSend, request_name) {\n    var url = this._PLANNING_SERVER_URL + request_name;\n\n    var xhr = new XMLHttpRequest();\n    xhr.timeout = 5000;\n    xhr.open('POST', url, false); // the 'false' makes the request synchronous\n    xhr.setRequestHeader('Content-Type', 'application/json');\n    xhr.send(jsonToSend);\n\n    if (xhr.status === 200) {\n      return xhr.responseText;\n    } else {\n      console.error('There was an error with the request');\n    }\n  }\n}\n","const halfLaneWidth = 3.7;\n\nconst centerlineGeometry = new THREE.Geometry();\nconst leftBoundaryGeometry = new THREE.Geometry();\nconst rightBoundaryGeometry = new THREE.Geometry();\n\nexport default class LanePath {\n  static hydrate(obj) {\n    Object.setPrototypeOf(obj, LanePath.prototype);\n  }\n\n  constructor() {\n    this.anchors = [];\n    this.centerlines = [];\n    this.sampleLengths = [];\n    this.arcLengths = [];\n    this.leftBoundaries = [];\n    this.rightBoundaries = [];\n  }\n\n  get centerline() {\n    return [].concat(...this.centerlines);\n  }\n\n  get leftBoundary() {\n    return [].concat(...this.leftBoundaries);\n  }\n\n  get rightBoundary() {\n    return [].concat(...this.rightBoundaries);\n  }\n\n  get arcLength() {\n    return this.arcLengths.reduce((sum, l) => sum + l, 0);\n  }\n\n  sampleStations(startStation, num, interval) {\n    const samples = [];\n    let anchorIndex = 0;\n    let sampleIndex = 0;\n    let totalLength = 0;\n    let nextStation = startStation;\n\n    while (totalLength + this.arcLengths[anchorIndex] < nextStation) {\n      totalLength += this.arcLengths[anchorIndex];\n\n      if (++anchorIndex >= this.arcLengths.length)\n        return samples;\n    }\n\n    for (let i = 0; i < num; i++) {\n      let length = this.sampleLengths[anchorIndex][sampleIndex];\n      while (totalLength + length < nextStation) {\n        totalLength += length;\n\n        if (++sampleIndex >= this.sampleLengths[anchorIndex].length) {\n          sampleIndex = 0;\n\n          if (++anchorIndex >= this.sampleLengths.length)\n            return samples;\n        }\n\n        length = this.sampleLengths[anchorIndex][sampleIndex];\n      }\n\n      const [p0, p1, p2, p3] = this.anchorsForSplineIndex(anchorIndex);\n      const weight = (sampleIndex + (nextStation - totalLength) / length) / this.sampleLengths[anchorIndex].length;\n      const pos = catmullRomVec(weight, p0, p1, p2, p3);\n      const tangent = tangentAt(weight, p0, p1, p2, p3);\n      const rot = Math.atan2(tangent.y, tangent.x);\n      const curv = curvatureAt(weight, p0, p1, p2, p3);\n\n      samples.push({ pos, rot, curv });\n      nextStation += interval;\n    }\n\n    return samples;\n  }\n\n  stationLatitudeFromPosition(position, aroundAnchorIndex = null) {\n    const [anchorIndex, sampleIndex, sampleStation, prevSampleStation] = this._findClosestSample(position, aroundAnchorIndex);\n\n    if (anchorIndex === undefined) return [0, 0, 0];\n\n    let prevPoint;\n    let nextPoint;\n    let prevStation;\n    let nextStation;\n\n    if (anchorIndex == 0 && sampleIndex == 0) {\n      prevPoint = this.centerlines[anchorIndex][sampleIndex];\n      nextPoint = this.centerlines[anchorIndex][sampleIndex + 1];\n      prevStation = 0;\n      nextStation = this.sampleLengths[anchorIndex][sampleIndex];\n    } else if (anchorIndex == this.centerlines.length - 1 && sampleIndex == this.centerlines[anchorIndex].length - 1) {\n      prevPoint = this.centerlines[anchorIndex][sampleIndex - 1];\n      nextPoint = this.centerlines[anchorIndex][sampleIndex];\n      prevStation = prevSampleStation;\n      nextStation = sampleStation;\n    } else {\n      prevPoint = sampleIndex == 0 ? this.centerlines[anchorIndex - 1][this.centerlines[anchorIndex - 1].length - 1] : this.centerlines[anchorIndex][sampleIndex - 1];\n      nextPoint = sampleIndex == this.centerlines[anchorIndex].length - 1 ? this.centerlines[anchorIndex + 1][0] : this.centerlines[anchorIndex][sampleIndex + 1];\n\n      const possibleNext = this.centerlines[anchorIndex][sampleIndex];\n      const possibleProgress = position.clone().sub(prevPoint).dot(possibleNext.clone().sub(prevPoint)) / prevPoint.distanceToSquared(possibleNext);\n\n      if (possibleProgress < 1) {\n        nextPoint = possibleNext;\n        prevStation = prevSampleStation;\n        nextStation = sampleStation;\n      } else {\n        prevPoint = possibleNext;\n        prevStation = sampleStation;\n        nextStation = sampleStation + this.sampleLengths[anchorIndex][sampleIndex];\n      }\n    }\n\n    const progress = Math.clamp(position.clone().sub(prevPoint).dot(nextPoint.clone().sub(prevPoint)) / prevPoint.distanceToSquared(nextPoint), 0, 1);\n    const projectedPosition = nextPoint.clone().sub(prevPoint).multiplyScalar(progress).add(prevPoint);\n\n    const station = prevStation + (nextStation - prevStation) * progress;\n    const latitude = Math.sign((nextPoint.x - prevPoint.x) * (position.y - prevPoint.y) - (nextPoint.y - prevPoint.y) * (position.x - prevPoint.x)) * position.distanceTo(projectedPosition);\n\n    return [station, latitude, anchorIndex];\n  }\n\n  _findClosestSample(position, aroundAnchorIndex = null) {\n    let closest = Number.POSITIVE_INFINITY;\n    let bestAnchorIndex;\n    let bestSampleIndex;\n    let bestStation;\n    let bestPrevStation;\n\n    let currStation = 0;\n    let prevStation = 0;\n\n    let startAnchorIndex = 0;\n    let endAnchorIndex = this.centerlines.length - 1;\n\n    if (aroundAnchorIndex !== null) {\n      startAnchorIndex = Math.max(0, aroundAnchorIndex - 2);\n      endAnchorIndex = Math.min(this.centerlines.length - 1, aroundAnchorIndex + 2);\n    }\n\n    if (startAnchorIndex > 0) {\n      for (let anchorIndex = 0; anchorIndex < startAnchorIndex; anchorIndex++) {\n        currStation += this.arcLengths[anchorIndex];\n      }\n\n      prevStation = currStation - this.sampleLengths[startAnchorIndex - 1][this.sampleLengths[startAnchorIndex - 1].length - 1];\n    }\n\n    for (let anchorIndex = startAnchorIndex; anchorIndex <= endAnchorIndex; anchorIndex++) {\n      const centerline = this.centerlines[anchorIndex];\n      for (let sampleIndex = 0; sampleIndex < centerline.length; sampleIndex++) {\n        const distSq = position.distanceToSquared(centerline[sampleIndex]);\n        if (distSq < closest) {\n          closest = distSq;\n          bestAnchorIndex = anchorIndex;\n          bestSampleIndex = sampleIndex;\n          bestStation = currStation;\n          bestPrevStation = prevStation;\n        }\n\n        prevStation = currStation;\n        currStation += this.sampleLengths[anchorIndex][sampleIndex];\n      }\n    }\n\n    return [bestAnchorIndex, bestSampleIndex, bestStation, bestPrevStation];\n  }\n\n  addAnchor(position, resample = true) {\n    const index = this.anchors.push(position) - 1;\n\n    if (resample) {\n      for (let i = index - 2; i < index; i++)\n        this.resample(i);\n    }\n  }\n\n  updateAnchor(index, position) {\n    this.anchors[index] = position;\n\n    for (let i = index - 2; i <= index + 1; i++)\n      this.resample(i);\n  }\n\n  removeAnchor(index) {\n    if (index < 0 || index >= this.anchors.length) return;\n\n    this.anchors.splice(index, 1);\n\n    const segmentIndex = index < this.anchors.length ? index : index - 1;\n    this.centerlines.splice(segmentIndex, 1);\n    this.sampleLengths.splice(segmentIndex, 1);\n    this.leftBoundaries.splice(segmentIndex, 1);\n    this.rightBoundaries.splice(segmentIndex, 1);\n    this.arcLengths.splice(segmentIndex, 1);\n\n    for (let i = segmentIndex - 2; i <= segmentIndex; i++)\n      this.resample(i);\n  }\n\n  resample(index) {\n    if (index < 0 || index > this.anchors.length - 2) return;\n\n    const [p0, p1, p2, p3] = this.anchorsForSplineIndex(index);\n    const points = [];\n    const lengths = [];\n    const leftBoundary = [];\n    const rightBoundary = [];\n    let prevPoint = null;\n\n    const pointsPerSegment = Math.max(10, Math.ceil(p1.distanceTo(p2) / 1));\n    const numPoints = index == this.anchors.length - 2 ? pointsPerSegment + 1 : pointsPerSegment;\n\n    for (let i = 0; i < numPoints; i++) {\n      const t = i / pointsPerSegment;\n      const point = catmullRomVec(t, p0, p1, p2, p3);\n      points.push(point);\n\n      if (prevPoint != null)\n        lengths.push(prevPoint.distanceTo(point));\n      prevPoint = point;\n\n      const tangent = tangentAt(t, p0, p1, p2, p3);\n      const normal = new THREE.Vector2(-tangent.y, tangent.x);\n\n      leftBoundary.push(normal.clone().multiplyScalar(-halfLaneWidth).add(point));\n      rightBoundary.push(normal.clone().multiplyScalar(halfLaneWidth).add(point));\n    }\n\n    lengths.push(prevPoint.distanceTo(p2));\n\n    this.centerlines[index] = points;\n    this.sampleLengths[index] = lengths;\n    this.leftBoundaries[index] = leftBoundary;\n    this.rightBoundaries[index] = rightBoundary;\n    this.arcLengths[index] = lengths.reduce((sum, l) => sum + l, 0);\n  }\n\n  resampleAll() {\n    for (let i = 0; i < this.anchors.length; i++)\n      this.resample(i);\n  }\n\n  anchorsForSplineIndex(index) {\n    let p;\n    if (index == 0)\n      p = [this.anchors[0]].concat(this.anchors.slice(0, 3));\n    else\n      p = this.anchors.slice(index - 1, index + 3);\n\n    if (p[3] === undefined)\n      p[3] = p[2];\n\n    return p;\n  }\n}\n\nfunction catmullRom(t, p0, p1, p2, p3) {\n  const v0 = (p2 - p0) * 0.5;\n  const v1 = (p3 - p1) * 0.5;\n  const t2 = t * t;\n  const t3 = t * t2;\n  return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;\n}\n\nfunction catmullRomVec(t, p0, p1, p2, p3) {\n  return new THREE.Vector2(catmullRom(t, p0.x, p1.x, p2.x, p3.x), catmullRom(t, p0.y, p1.y, p2.y, p3.y));\n}\n\nfunction tangentAt(t, p0, p1, p2, p3) {\n  const delta = 0.0001;\n  let t1 = t - delta;\n  let t2 = t + delta;\n\n  if (t1 < 0) t1 = 0;\n  if (t2 > 1) t2 = 1;\n\n  const prev = catmullRomVec(t1, p0, p1, p2, p3);\n  const next = catmullRomVec(t2, p0, p1, p2, p3);\n\n  return next.sub(prev).normalize();\n}\n\nfunction curvatureAt(t2, p0, p1, p2, p3) {\n  const delta = 0.0001;\n\n  // If we're estimating curvature at one of the endpoints of the spline,\n  // slightly shift it inwards to avoid infinite curvature.\n  if (t2 == 0) t2 = delta;\n  if (t2 == 1) t2 = 1 - delta;\n\n  let t1 = t2 - delta;\n  let t3 = t2 + delta;\n\n  if (t1 < 0) t1 = 0;\n  if (t3 > 1) t3 = 1;\n\n  const pt1 = catmullRomVec(t1, p0, p1, p2, p3);\n  const pt2 = catmullRomVec(t2, p0, p1, p2, p3);\n  const pt3 = catmullRomVec(t3, p0, p1, p2, p3);\n\n  return (Math.atan2(pt3.y - pt2.y, pt3.x - pt2.x) - Math.atan2(pt2.y - pt1.y, pt2.x - pt1.x)) / pt2.distanceTo(pt1);\n}\n","export default class StaticObstacle {\n  static hydrate(obj) {\n    Object.setPrototypeOf(obj, StaticObstacle.prototype);\n    Object.setPrototypeOf(obj.pos, THREE.Vector2.prototype);\n  }\n\n  static fromJSON(json) {\n    return new StaticObstacle(new THREE.Vector2(json.p[0], json.p[1]), json.r, json.w, json.h);\n  }\n\n  constructor(pos, rot, width, height) {\n    this.pos = pos;\n    this.rot = rot;\n    this.width = width;\n    this.height = height;\n\n    this.updateVertices();\n  }\n\n  toJSON() {\n    const trunc = n => +n.toFixed(5);\n\n    return {\n      p: [trunc(this.pos.x), trunc(this.pos.y)],\n      r: trunc(this.rot),\n      w: trunc(this.width),\n      h: trunc(this.height)\n    };\n  }\n\n  updateVertices() {\n    this.vertices = [];\n\n    const cosRot = Math.cos(this.rot);\n    const sinRot = Math.sin(this.rot);\n    const halfWidth = this.width / 2;\n    const halfHeight = this.height / 2;\n\n    const hWcR = halfWidth * cosRot;\n    const hWsR = halfWidth * sinRot;\n    const hHcR = halfHeight * cosRot;\n    const hHsR = halfHeight * sinRot;\n\n    const v1 = [-hWcR - hHsR + this.pos.x, -hWsR + hHcR + this.pos.y];\n    const v2 = [-hWcR + hHsR + this.pos.x, -hWsR - hHcR + this.pos.y];\n    const v3 = [hWcR + hHsR + this.pos.x, hWsR - hHcR + this.pos.y];\n    const v4 = [hWcR - hHsR + this.pos.x, hWsR + hHcR + this.pos.y];\n\n    this.vertices = [\n      v1[0], v1[1],\n      v2[0], v2[1],\n      v3[0], v3[1],\n      v3[0], v3[1],\n      v4[0], v4[1],\n      v1[0], v1[1]\n    ];\n  }\n}\n","// Half width and half height\nconst VEHICLE_SIZE = { w: 2.5, h: 1 };\nconst CYCLIST_SIZE = { w: 1.2, h: 0.6 };\nconst PEDESTRIAN_SIZE = { w: 0.6, h: 0.6 };\n\nexport default class DynamicObstacle {\n  static hydrate(obj) {\n    Object.setPrototypeOf(obj, DynamicObstacle.prototype);\n    Object.setPrototypeOf(obj.startPos, THREE.Vector2.prototype);\n    Object.setPrototypeOf(obj.velocity, THREE.Vector2.prototype);\n  }\n\n  constructor(type, startPos, velocity, parallel) {\n    this.type = type;\n    this.startPos = startPos;\n    this.velocity = velocity;\n    this.parallel = parallel;\n\n    switch (type) {\n        case 'cyclist':\n          this.size = Object.assign({}, CYCLIST_SIZE);\n          break;\n\n        case 'pedestrian':\n          this.size = Object.assign({}, PEDESTRIAN_SIZE);\n          break;\n\n        default:\n          this.size = Object.assign({}, VEHICLE_SIZE);\n    }\n\n    if (!parallel)\n      [this.size.w, this.size.h] = [this.size.h, this.size.w];\n  }\n\n  positionAtTime(time) {\n    return this.velocity.clone().multiplyScalar(time).add(this.startPos);\n  }\n\n  positionsInTimeRange(startTime, endTime, numFrames) {\n    const dt = (endTime - startTime) / numFrames;\n    const positions = [];\n    let time = startTime;\n\n    for (let i = 0; i <= numFrames; i++) {\n      positions.push(this.positionAtTime(time));\n      time += dt;\n    }\n\n    return positions;\n  }\n\n  verticesInTimeRange(startTime, endTime, config) {\n    const positions = this.positionsInTimeRange(startTime, endTime, config.numDynamicSubframes);\n    const vertices = [];\n\n    // Hazard dilation (drawn behind, z = 0.75)\n    const hazardHalfWidth = this.size.w + config.dynamicHazardDilationS + config.collisionDilationS;\n    const hazardHalfHeight = this.size.h + config.dynamicHazardDilationL + config.collisionDilationL;\n\n    positions.forEach(p => {\n      const v1 = [-hazardHalfWidth + p.x, hazardHalfHeight + p.y];\n      const v2 = [hazardHalfWidth + p.x, hazardHalfHeight + p.y];\n      const v3 = [hazardHalfWidth + p.x, -hazardHalfHeight + p.y];\n      const v4 = [-hazardHalfWidth + p.x, -hazardHalfHeight + p.y];\n\n      vertices.push(\n        v1[0], v1[1], 0.75,\n        v2[0], v2[1], 0.75,\n        v3[0], v3[1], 0.75,\n        v3[0], v3[1], 0.75,\n        v4[0], v4[1], 0.75,\n        v1[0], v1[1], 0.75\n      );\n    });\n\n    // Collision dilation (drawn in front, z = 0.25)\n    const collisionHalfWidth = this.size.w + config.collisionDilationS;\n    const collisionHalfHeight = this.size.h + config.collisionDilationL;\n\n    positions.forEach(p => {\n      const v1 = [-collisionHalfWidth + p.x, collisionHalfHeight + p.y];\n      const v2 = [collisionHalfWidth + p.x, collisionHalfHeight + p.y];\n      const v3 = [collisionHalfWidth + p.x, -collisionHalfHeight + p.y];\n      const v4 = [-collisionHalfWidth + p.x, -collisionHalfHeight + p.y];\n\n      vertices.push(\n        v1[0], v1[1], 0.25,\n        v2[0], v2[1], 0.25,\n        v3[0], v3[1], 0.25,\n        v3[0], v3[1], 0.25,\n        v4[0], v4[1], 0.25,\n        v1[0], v1[1], 0.25\n      );\n    });\n\n    return vertices;\n  }\n}\n","import THREE from \"script-loader!../vendor/three.js\";\nimport Utils from \"script-loader!../js/Utils.js\";\nimport PathPlanner from \"../js/autonomy/path-planning/PathPlanner.js\";\nimport ExternalPathPlanner from \"../js/autonomy/path-planning/ExternalPlanner.js\";\nimport LanePath from \"../js/autonomy/LanePath.js\";\nimport StaticObstacle from \"../js/autonomy/StaticObstacle.js\";\nimport DynamicObstacle from \"../js/autonomy/DynamicObstacle.js\";\n\nfunction init() {\n  let pathPlanner;\n  try {\n    // pathPlanner = new PathPlanner();\n    pathPlanner = new ExternalPathPlanner()\n  } catch (e) {\n    console.log('Error initializing path planner:');\n    console.log(e);\n    self.postMessage({ error: \"initialization_failed\" });\n    return;\n  }\n\n  self.onmessage = function(event) {\n    if (event.data.type === 'notify_case_status') {\n      pathPlanner.notify_scenario_status(event.data.status);\n      return;\n    }\n    if (event.data.type != 'plan') {\n      console.log(\"unkonwn posted message type: \" + event);\n      return;\n    }\n\n    const { config, vehiclePose, vehicleStation, lanePath, startTime, staticObstacles, dynamicObstacles, reset } = event.data;\n\n    LanePath.hydrate(lanePath);\n    staticObstacles.forEach(o => StaticObstacle.hydrate(o));\n    dynamicObstacles.forEach(o => DynamicObstacle.hydrate(o));\n\n    if (reset) pathPlanner.reset();\n\n    pathPlanner.config = config;\n\n    let should_retry = true;\n    while (should_retry) {\n      let planner_result;\n      try {\n        planner_result = pathPlanner.plan(vehiclePose, vehicleStation, lanePath, startTime, staticObstacles, dynamicObstacles);\n        should_retry = planner_result.planner_state == \"unavailable\";\n      } catch (error) {\n        if (error.name != \"TimeoutError\" && error.name != \"NetworkError\") {\n          console.log('Planning request error: ');\n          console.log(error);\n          self.postMessage({ error: error.toString() });\n          should_retry = false;\n          break;\n        }\n      }\n\n      if (should_retry) {\n        self.postMessage({ error: \"planner_unavailable\" });\n      } else {\n        const {\n          path,\n          fromVehicleSegment,\n          fromVehicleParams,\n          latticeStartStation,\n          dynamicObstacleGrid\n        } = planner_result;\n\n        self.postMessage({\n          path,\n          fromVehicleSegment,\n          fromVehicleParams,\n          vehiclePose,\n          vehicleStation,\n          latticeStartStation,\n          config,\n          dynamicObstacleGrid });\n      }\n    }\n  };\n}\n\nif (typeof(window) === 'undefined') {\n  init();\n} else {\n  window.dash_initPathPlannerWorker = init;\n}\n"],"names":[],"sourceRoot":""}\n//# sourceURL=webpack-internal:///691\n")}},__webpack_module_cache__={};function __webpack_require__(t){var c=__webpack_module_cache__[t];if(void 0!==c)return c.exports;var X=__webpack_module_cache__[t]={exports:{}};return __webpack_modules__[t](X,X.exports,__webpack_require__),X.exports}var __webpack_exports__=__webpack_require__(691)})()}void 0===typeof window&&dash_initPathPlannerWorker(); \ No newline at end of file diff --git a/seminar06-planning/simulator/images/examples/crosswalks.png b/seminar06-planning/simulator/images/examples/crosswalks.png new file mode 100644 index 0000000000000000000000000000000000000000..2c25cfa6e561291abd56901d0c8c6ee55ce37feb GIT binary patch literal 183540 zcmZ^~2UJs0(>59~Na#(9)DVhDuOdx?^bP`{H|f$rIwHOIDjfs?fzW#g=^#}=dKc*k z0@C!J==*;Ex9+{aYsG{lCwunnnP=vinG>O=B8!Jji46jQ@Z{yBUVuR0D%1mVA9!b< zzIGf0!iLyLN~+0AN%n-QLSCNfn3+4j(N_xj^mp#>5Dfb9YrpN z20jM1FXUxH~4Ldrn?kN7C;$UsuU?-dz&bi)ZI$xUP4t({N=&)q4%GmSP0K8BSOQ>MHN zJPA7&n4D}S%w`O#dOoo#s{7}J;Cdvt+vKiqQaxf+e8u)oYLK4Ch<1=Y7?+3;`wRSm z9QZLDy%+t-*ASNVaN@wMySJ;dt6!}m%A+w_6KK}`F?!(WHLKqojcBP!829x{c0r#BHa=Hi(KuU$H)`ex}@%Qol+2ilU1|;QC zBnO=3-8TTIN#HbLI|Pd4k>mQCo;-*SdVE4T8YEqXE8A$m4Sbm=#eydc*@j=K@o3`DJYSWxpHMErqztB&B$;6UiLV!`&i(LPh_tDY z4o%UgZ&eHjSdL-3PSjc0Rz0%ouqN~lkl-i5bt6v-+A!l!I4u6Kd}|i@WY);o8mZ>I zTlIXFC$H#OskFjN;R1OJ>dPgVCC*={_edzCirzC#lv*>?(JbJ6mKw;v%y*sa`%d|q zuLb80Bo>e(`?gz+8%ALfP2W$u8D(mk$fNu2xe{p+mMaxsbb1f_%W54;1Z`Pd{ikbF zhAN+`=C6ETW$ZBB2}L3dyVjiopIT(`jA0CPF|E}&6+4qV2|7tOJzkO(#o~&c>seg8 z`@!=I*O$Hn|1FJpaBhDkVH2bVEE$MH|E?-CUbcj>j^v1>2*M`i@LqKC-FNwDC@qwX zh$_4>!mRg_kyt*`9PYvpk~AeRU8q>tT8K6Eh?hV&!cHC^`Y16jv22KDYhdg00k(AP zOPL?VjB2qjUOjGP8GlSCR6_lV`hvQf`bJ3MX@*ef(-kM;rxrq=g*=>!T*zFE*4xH~ z2Bg;#H*2a zUoxes$eQFGuP5KGoW0R^I()WpCUf%b#AxeqCwpgeeR}=uo8mg#dTYO+isa;$^+g?v z9_=BoeQ?7l*RbOlUC-O#&VaY!Z{^`ST}n_XsD7ThiH?b`+VcrL?iVLbCQ)mA^mXxx z@tJBh6T10}&s}@kdSrT(*6r3udQ_!Mh?s~x62xFT($`XCQhieP(q_`CQ7gpRBn1)a z5z^tL;fCayq{We$;bBqa;j4sinYtgDauPAAGfpz`a6N|EJW6NL<(%hghB0w%Go{ea zu$(JpuqdbDr*Os}CFi6Or8%d{Cw)xwf+@y-7zrK9Njyw7OiW5UOAuk4g9$QlK^?hr zS&g~Gi{R?qTHzWcYMv$GT7_&ftU2n`YJn-QQ+kpWl8@Lv4SNr-4_hT;YH_pPXXRlf zWi2Q**K(aR$#c~BP=N@MtM$(DVfGFKl!Qp z>yMD6M3Tji%Mab%ot~|WHfXuqj?R*iuf05W>Df*%YqQPTk8{uw)NUkhOgqXrvN>9& z)r`xgb)${SAx9xXj zx8x1Fjv~$WtZ+dnn~8br?M3pTm`Jd@)L~OYlItV0ofNoIo~nuA8tbPJ^==(V4FM}& zhLs+#DvvQ{CI&fpJd`4AD@-YjGVEK}SXH#{Bb{2)BGV94*Y(u(zI8{21K2Pu6=n!4 zW0-sI`<}Ak$7H~yJ&!0)0*_&9ult7s%4n_F&yh57e9ig2?@DB*7L@@FO()ne~u10+I4;$-xz#p6+_D_ ztm#hi=IO1|AEHBs;yB+S{IQO-f&`6swHYI$?U%@JjnblJ(5pyZ&jpXH)O{ z!fMUJpK`lX>1%wFR-eb7BuAufCv)WDh+md0HMBK9uXukVdf_{Dm6o!Svb;LkS%xGo z9sYQ2K%*gMv}rW0Rc5TO|L8@UHo@GZ*>NLC6Svdk-b>q{SCU=~NS+_59^robPAaz%JZMq&W^rarBKy=P_KM89Xb1%3kqMPw6?_l++-=bWt zZ`<$PPoJA}C|uF`9)9?)b*M#XzPa{nmt$3*pmnL`+EHYs!)M^z7}DYFh{_}8*yxbw zz@}BUb8f0^ZgHu2aqef*k*e~Y_uc2q^W#Q*3fwvZhlg#?%!OZ{1}1ha&)s~z%iFmOxG*pS?I$Nzy9;`ljgy*$XwF54%Bm0oli^!CNFz7 z`=;f;ZS5Oxyw%Mf_LcY2eai97P^3V>)os?&eQl;eTcgs}7_fS8|NI%M=>LHanCYi4Fy4%dB$%09@V%cNBb5|qYkMq> z)>VJ+B)z?%!Nt=4(3NTGzzih3@!Qey&&FrbCL|%1Xj!j`p0U=8i8dI6dv1fNz69qMpLQ zOM8pgrch6NI|o-`PchivZwLdgQEzj>pnt#e+ExsvqpSv%bab(R3UKmsa>JfsL!nSn z7jsMD7g93+xg7XQ3}*fMwUaOxmxqT3rw1RWql*<6kC2cM7dI~#FE0o14Gvc?hu5Z_ z91gAw|9<4ZzawSgYUX0&^xDSJ0gC!v)0d8JufR z7wQu(9!_qq|M_j;Qc={q!fH027Ir#PHue?{uD}}4czC(FMgLy#|M}?uEcw4K)&0L; z`oBK<&!wVVs4e`jE&bEi-**9pJ;N5|`XA*#!|toa^9Rm@+D1xM6L>}k9;hcB;6Ijs z&%kRm9b6OY@FWlj4w9FW(DXz*XvcA)nfGG8SoLxK0R;t8qrZFT6h7H?fh(8La9gsB zE3ek@V*i|V_{h6x_8Uv-3r(ueEDDwkr*jmPbGzs4REw~pWV z7Ed;g&;9w6-P0X}S=Ivwhr?ln-@kv4Pe>qY_BhTdFE3|&uX+F`f}%@7anV)9@9IQ7 zPyENLxbrMTkJSd^m2i~?djqf@vJ&XVxVyhWaE=)z56LDWuBKCMUgxn|#d!=4O>zo} zEod~}OrMc9^R~l|m5{?TyDjq?38uBK@L5c8*33KE!j`vn>(9s$J0G43GST386c+xL z#`6qar@*H696r2|a9*wI=s3zG(|p2$M|%GQX8l9W*-8}?L4N)%ljNCm^8j$_@ta{VY~ls@ z=e;nT&eWc<{%{ac_``t7N%i#fbSz)fsAhRY8XWu+{mlBfiF(;%v^31ST1ZIzaczoj z8L!PScxrFUT3v-^H(6Wd=ggt7T-olGn~-=t`%b0Bjt^gWS^cL+7Op3rhPZaT{!M%D znprKRjrvIY`}?zYD8!ljL###5zwcm2lzET{fjSLgjKDSXI{UnkhsVb_L>?`l()dMd(HzKlvyaBKDy`6Xt)=+nZ&Ud%M6T@Bk*>3c|-w6sA$ z7pqQ+yfAjwLZJN%<<{dCtk5^B3HrAfFj16UM&UY z$Ymv5^o+GY0fee*-00ZY@agHP%AeQQD#81`ar~00c`oNuLBpXoN#Io58czlALICLZ zyB|*Z&E6stR+&=%klqMTjumvX`Fj+}jQQLL`7*Qi0ct^s%$1(0z1b;_=AS1ozR8z~ zwn8?HCL98(!c^y%DBaGi1-m&doM#U5+BCsZv&*d>nadCMFC{?ZX0^IR zRPz}lo%qR*792&xGG?TMXh(vLVHr1PVAuUwgrlKXvJiPUzpnnS&zIMQMY&ih-v-tn zp6w0p?CZH~G$&dh+rBY;COZxEH*)QvWIJ5YVXQiJnRCgCkn%UaBo^X0cmTK%5mA@+ zGtoKgYC@u}VDeAz6JH+qJbGLjwbttKgqL9uUvtXNzTN}T__FHzbc^4YPp6WPJAOsn zksvq+p%r7Fvqs7>tbD_3m|<#BaI*4hIg^>O$Ccsm5yCE5WoKt@#S;$6EIcB>670Zo zCIVFJvvZa5Y?0M-FDo(T$7zp;4mktijP?tN`dVv`5Rdwfj%UPY?oJ_NAy&9`XKSoF zj%hFKPU0=*HYe7q0cY?Bg?ow4op8m>0=t1J2}cnI$Pjhiy9Xxo*n9OrKJ^iR3G$G& z`TN9CoRjhyDJO3xaTHL?70a_N8iLjJaB4c;ED9QGl8r4U7g((o))eHBQ_$d^VjCCV z=l0ixQU*4cX2ja-JeF86!eF=_64(;PXV&R(I0@kdB@bg|28gqa5nU<|3Gsg?I~XWu ztsh_~xv4H+RvuMt##$G(Hc#?qudU$dz`w5LAF^1ENprI;Alx2J#-mjP+teYraX%o{ zGnxYXwA3bgN%<=**}g>J^+ei8L0Qpl>iS^;q;3tmu@EUZJW1OZEfPc<1(-&>C!jzk zzsOg@CGuq~A`na6Xd0-EZCMp(p!QL@g+e@yj$l$@~-%tS4X8RZVr+ za0v)BuDgSx4lO7)UY)KNb{WR^rf{^3%7Q5+;o_@gWMssDh!VjFGuO{kQeBj2%0?g7 zyG_JcEP-wMLz)OFC@Ec*>`t=GuX@_DuY|^y`a+@!*aK-kP zAA-y2t4c<%pPWCEl{OMuVX9=YWy{Pn1dpp~CAXS%7s;`nZb>Y%4omqL4m^*e()wDk zP#H`N9$VkK&ex`t#Yo9=lZ@6fQ+CrI5 z_-T+W3N+4xM1dngo$|_w>*_9#@u^r>P}7F~SsMw@!clH9May z;75+LmoAaE>?KW^@`*u0(HDKBwXHpU^eS*B=YpEhao<#Q!pzbDxFd|P8V z-w?doUYqb(!X3WAZePZ(tADlZ?Nq(HzhA(%{seBCBLb~}jy}7xo+2>n2jDxN5S(a@ z5`kV2vo%2(%(=bTczEmzxWFZCq9T01#PR*l^g^CgwAvIm3bF z+{|Ht6W-oL{pxs4gnqWwmrk=F5kvo(+0zhxSkmXam@k}xk7Qf7ep-*K-1t56Chum) zt}z>hR?On(M)xgXpOexmD-PW4$M%s{oDrKiW8;*IDoR>!U{?f6Zs&J>eB?|DAs~r> zzbBfoU0}46l0j#iY{V8xvjm^G;lDlL<|!6YCFkRFl+ALw68VNm#+=F@kUU+Y=98c3EAer1=VgNof zvB$W*MK4!Ls>(atH?G|{ueI9f3MO@SbNFUZ%YPfzg>I z;22FmtX`g;E=`ZqQB6@ZUVR8llQXzl7L9&{{#ZJ183mRvyf>>BhXAA5IQ=Ef*<9O` z^ADA);y)?kHKxVU*|1Y)!uo07YA?Ph$gQ7g&q-8zOnlJ4Ch<^DFV(nBpmn;F9j8Wc zWT8|NtHw$_`OQvIxM$!FZO&U=zl(WdZRkif78nI)t#2KP@-29PU`8D2Z*<)7i82a| zcx6s^u5mQg1>>ocl1haEK_bY5xE zfgkyL52RP?wgg}B1EUh9CERh7XAvUP%cn`@M_rVm zO&P&CIW;XX=b6*RI6UHj2Kqc?b=8r53M~|?yg^xzYK#&+Bf?>u&S{o=%M149MeQ za^3%C1_LCylE~9S+03b{s&k>T6zFXgwA$KhLMmQY0QfXQ#vhDm+C{UGHY_t4g&VxN z(rlcRp3r=uuV1eeZ+Io6f$$z^~(k=2{?vq(E{aB&|yZIctavRL?P*E41ogLz+u%# z_V(NIM)z{$123&*@zN-%XHyHTysr@$>k98eV|;&}K{!WHpi-UCgdH3PwZIMil`*LPj)L8tzQ(8WI9?L*6FX^-6Q61Rg{-u_{F? zTz$_=Hej3`-nRK@)K-5lnYrQ#e(pjtJEy;k}h*@>^U&bs%V zLufD_(J6;w1~LJ=9~3}$ux0mrti_t5a{{;pPINhA90a}(0?&?)D%rh__v%eBV+PV3 zDoA`+Y4!kjl$0THl(e11+ue1h=K3~8^Y1^)Y3l1|sEP@6@RVC2vn1w?rR@3Xfl~9W zZ_8P;={_F)^xa&a-97DO8~o;L`e^0Ndn9t$b?!sclVg<)FA}1z8~X5a%jOBG-4;LQ z0HsQD;AkYncLBA01u|Ir-x3T0_}QAoIt_z-bVN?{AQ>-nb4F6;jS7deWFRcSCiuZW z@eQ2cnA+;eX6o>eg{!;$OFqQSPsSmL^2L1d>-!EZ&mQp4uu4mF()X^tRVb&QR zXn>R_MxE*3lm(XGzO8S1@Gk_6IRtV%1X0Zgf#mM``uZALwZfSG=AIY<9acRQ62OT} z6NXQtU}m}~g4Bu>?G6)iUkFE^$;vI~DJK9#dQn|pzrI@nh)8`5bDn^*UdT-Sa8i+y zCV4m8G}{!f#Kn^(MTuF2dP@NkDNJ@GCx17ce=_A6)4CB#oMx<@p)b**-@+a@3FziM z^Tpzi4hjHgvT{dbwyl0Xw2%jupp=H<+p-hu#EhYj>|mqWd(GfVv>2cbbrS<|R0w=3 zV-liEy*D&lID^MDtU@jkqj1Q>6L?U+9C@ywuW$OO`_&x$lUopqmF+p&e|X(c8gx@w z!r%D1De0zQ@L2)Gz{&^gvDo`Ixz*?3P?p~ zKI|dZCbY^$@;9n}rsmp5ndLG>svbyTQ;xi>j`f29=+*S` z7U(!pJuEEJ=%=>T*q}}6lc_bk1{qp6X;4C3-^)$^nvOFhpM(33E%os@q z^vBQPRN=wZD0$vvS!yqafdqX0hr}~vX>(}K}UU` z6|(TEhU?Rh4qn?*xg1go!R@e}N{(TD?I-0Ug**lBBuh_yOV^JYdlpL9Ra#j6zafrC zHY+HIbR3ZeIjMVn2genWDW;XA#@Y`!5VKD+yjtx!CEOO1v%0V{hEkd)a)tpRc3qvpb3<-v5I~lSF%>sq``$ z=A3du6}Sv6o_8NjA7!cnRX+kDUtpjOY%Xd(KE7B#342x)00W8vLDqyK{Fim7$$kb- z^kc}zDJLNWX;<^2^6vM!eks(NH3ak6+1tNc0NCR}k^w9k0iY1`47>HmX$ z_c!S57;rcNTV(1h3YY9&Eo=v{djbFu#^9>ov;e7Cd8~Y#!dT^-Z}xnJXd;7?vGUaK zk<%@poG+44dvGch@FN@KLQZ2Gl-IZD;qtF=FBGPD$ z67@&s=Z+^^Avszth=O}G2yTFbc@!bGU-b(X+oookj7ZHRE&1Q1=e24f7*iL$aa#1{ zmw1Rc=YV=ez|;fN9Id)0h1I)ZS|GnR3G*KUP%D+jeKdsu%`9Agn>7*Biu)S)x$Hhd*8Msu7Z!BoJRAQA9^-FC!Q^woF7Iq0 zVPy_lwiZVxr0=KeJ2SBw|I{$x!3nEnVLmH}B0-IdI1H&CY9b?F=IT3w6=~ z_5ip4fqfsH1{t6G(fss+|11jndm@u^(ir3)kmFV z=Ho#ak_9b@y;Vh#ys z??KiiLFGEfEA5MLj(TY-H=^KuK3BPm5&YYSTOO=nq#;|gOnIx{C4qk99Dq-ECM$0A6~sP zDNQH{`dcE#=+!DfyGDHd8-RHT(MZrUJag43wbdio47qYX=xM~alv9$@{-tiMfLa&& z0 z*|IIt)@^%CufhO~rk3Rp_`ssEW7{R02iw{0$M3$DckAicFgBIOgO(WHd#I=cWdc@H z7?P^a`~me(LkIT6fw8fRVN3tlQ!oR#!H9PlxiTzVtq=er%PB;hh6^fEI>a~JNrL}d z2XZ43B@Unj_lOSg?>a~tG*fw9?-oCHUB4f^^Y>Kj!Pt9f%>^5~R;7F7st+RI89*r$ zr-E~OdfI01$&CW)T;=%D^;8KR=8OFMR(^H-$l%ygzG`z;C-+*ux z^qo>xW9T+3Bb?|>iIFib80Ye}3!x=*9||>M`@0{1h#kG!Q}=_f_yJm+X)#S}^slfb zdS|b%TRw)@wuU~YFX7b4Fup5UOkRCpwTHP`69EcmBh>LET5FI0EcC4e5XG7Rz3PGg zO`b;rsbzJsPtGITvf2R=#(xqx#Z4%y{rPb6RRP%V2qja+(qb^@ex05_hqyj#zE$(<^i~V)js^{} z@o`2op%mU5;Gfwwh0_j1C70K$Jo|fR&_NX*_x(jvRhbs7qkv!{4mezVT+h^bTaa4R z_{WjzE{=FG$}`|Agx29*!`M0!Td9vfOU0w%Xc)yL7-ty!CO^3yL_U?TLDc2*L~TNR zt21#L8DsA$&jLw4i0ErnSDe_5*=g?v$*J$o*#q;-t^zld@v8m}fZIzE)vfejdT09A zHIBZ^?JOyC6WcYjCxbVJ@!D<}0z`8D9kD2YeQXT1N3y}Do_;p!a=e`_w;P`t)@9>O zsnx@u>KNx|&DHmPi8a2nMrl5*4fn5Qh(hzoy>flOB~7(2*b8ilHld6RQ1pr$(urhJ zd16mBB0a<3->;~CdSjTMy@`0kjGf=$>d5AKxHHN_vCx2;f5zd1=$SZ(X97+XF4E`87 z`tj{*EKe8PxwyDmYY&CuG{`Mgx3R)OHs_;oiNA%{tnWB849a@#K30+y-#p`p?CtA? zJPk?>@8xsDE=iB;pfyJ;?fbFcP&Oe2^#I&#csbeXZ5QBT|7#x{V^1dVQ5HQ(bfUk8L8RkV-4IA| z12E8Fbn-&2oW8HiCN>+aoPyo4>18i+GF=3_U126tUB}Iq!&zWr+KS*47VEiIBo=u; zkof|1Ee2?UAQ;9jG9p2PR84pra@`~S`42+u|8Z7Wy8KLTQ|MT8eSLHSCSO8}YpnxHhPiMtRB(@C?i0-&0`$R|o_xvBcng^Lt>2IDNyd7BqO#dB>=T^oJPcxwL@dSX7E?Nt9g%mP zr#I7`j)u$}52=`tW5)WLtq{b604=$Z_{`byre&~%f!kwkiTf~n>TL6I1Uo zwHThAWv&-smxGk(j8!#H3WR6~$}8X|pGQZ3aT>W|@@lvod(*x3-CxMNrTMHYmNz%1u^y+ZQns$s7fQrX#4FA={4o z*DJbZut(mSJQd*}rSouaXh1wF37>74ol79%?9(mxO`{kVa=!{eCt?I7Q? zIci!WIdpVDE7#xB$Wj?`O3Nmn&oBSwJm4beGX{kKoZPgY0x657Y zsnK>T`i27LPYkn9v6X(^QoUCRP9>iJAlR8RO7=wBO7mQ>e4k0p&otqnZF?n#uFG7( zp8;s2m5Y%t5RiKy<6A8f%M+1P~ zELJ!4;0O9i6n{pJ4{cwKxVZf&^=-OZr%js#dSO;S9@P2s5;+t-T_z`)Cr=hHu@`@j zYa!!3w=I4>SaTawtmxuhCo5=t`Si?Fzuzi7%$54lvEuXFvBqLI-aeM zyhSW&*NB->(*VwmlmX!g16WJ_EUhB+>sIC6BBBxlJrgpp-mIFHg=7M;sh+-KW zmkX)J+by*rY=Ug8mj{0?k)&7I`!{ZyU2fbtiy?x&|}0AFE$;%@^68 zMG5Mb=0_X<&g1Xom9Q@-_1Uhxq)EA|uyWI8pc$cxvoN+$xhC&q`w$``;`S@Se$YhW zjA8xuG;{B(P1d82aOik%N)Gh)Fg7+;n6m22r>PPYKEqQ{7_mM7`TN%sGrU?G@KIOd zr2MxkKtxCkycWPFnkk&(!UQxZGUp-7AlpFeRtm|RqKcdT?y1O^2bP{0`HlijPM^QN zqx%>-TEwrBRq<7-7h{{CCHF3zSL2~Z)=|>`3JK=tavP=Ymg_Q4MMV$3o6Z!SM55|% z@nQg-uy9o26Ng>jTKPo^!2u6pC$j!fpYl=hKP?-L7y27@6gRrkdNKH~buJ~65I`4k z=*m`W-^FVPV33+M_dPF^Mx&aW7NI16FG ziFw<6XWCZ@o@}W3_yEVg9Vb=!x8?R^;mpuvh1$!5?*!p&O^^Um^h$FT zdjWy5O$)JSYs@q$?Ut9=xf|r}^dyl8HND;@P&i{FX}}{i$Hc+hwrc&IdW+f4HJf*| z%t0FQmFHZaZ8h=jj}zlBTYVvP^JK}hxG)FRftQhTL5dzqk`@A}5KRGuXrY|jIy{vf1aar0l-*>Ke|5ezvQJRqFLBc+6 zn6|Ot%b-j%9dh$xJrq5-kVRO z5gx@D#AXVNEHHdOV&1>qlQmwtdcCUTEFAMM?z93nHFNaPWfqDa?Tl+(fVqHtedAeO=w zXn|yuH#*0t;5g5)mj~{Ju$k7n?_L1$2^H3_kN$6A9qNe6M;4=t?b?1-qkDyL$rI3u z%IO}@8v+uA!=C~JF`PEDh$8haBo!lq&pjyS)4$ahW2UbWG1#>ltFOp4a-@N7_obYH z^rvxs?Bg--Fdaf&+MRUy}euc<-3%T=!%MEGKdqMRQUd8;NPZIvNq5`G7Tg% zdwV$+YLJbu!TZ)rz?n3R+eba3Mq`!r?WLLl1G6(Jd7{sL_dp2H7;x~eBhMJ^1*D?L zGuAVZ%0eZfUu4vNLtRGVSol(S`trpgel~vRHz_~L25f@=*ggcpjNW|#D(oN-?Q6!$ z9%z3XV9JGfXziYgLG>wEi%k&rL)fqW-FrorzMF78!*rtrpkO7hclEw5ldzFner5<%=yteDF!#H<+n9XRS@(1i zE+S6=1iELELWgu@GM**;p9GkS<6XW2LNJ2S*jMZ@BHhw}e#F*o;V8n=?X`Z~HA9d- z`_~3ZpxY<3z*H>jV;3cKwemkKyTrxoGj%aau2XOFK0XIx?H_9tMP%PiyA@I^f=$)T zj9`ScXyUx1Tq{!X`C9+)ltM$q@4Ud?(T`XM9zw4U@ox)k82-tB2PYQbIlu+NSOU=m zPUC+$i?;*ka{LIvBa73?Lbr5;1#T;M%>fZ@PYQ$~9FI)VL5%McpWms!zG$sAf@81?jbJDTGfz^M%lK%IlC{acppo3f_h zc@gm@*1r0yZ?9A9EolR|$HniKT0Q@~{N`+P4*Fq)2aBo*M#|(Iq8hol0MZKF)0%yV zg~ss|=u{E=vj3-;_1+#eb0x%0G`xU~(-c)pP6CW91|p7KEUrr{k;pOHW2|i$#1J(q z)&j`@5rj|oY8mt#d}+i6Wy-q|g+Di78WL+c0%^QMqoZDvp_nV8dK~O;h^qB7p!{-B zs^|>`H&t-NS-a2W_u|}(A@e^Ga1|m*t@SivKwZnf9D%Vh)p7T`CiOsn|JKFfqR5+> zLM?_?$dt4brb-zJu{MI6Mw(0@*&JC)1E~j5 zU59f6U(doTvp+;1d#egeoE;Q^PTu2DT6f}iZwb&zZXRV><>NVrSgkduyMA;{TH*U1 zE%nu*DK!>mlnAh)6_V(v+OB0}Np zs3;l^rvwf=B~*7eI(febY1{se3lP(3EPcR;GFV7E*;5<2+%C_5%28{CZN(Wd21Rkq!ja)rGSJl-|M<*9y*1YIHB-E~I+N1oM+084X56oEA zfTQR4V1R8=J*ON0q_5bRm5nid@WhZjncAxB=KA}0mh&nXUjnD^Qcw<5)p11WLsjlC zo?u?~sh)$0##hNGMOsEbq@oD`Mk(<>ifhuA>SL870WO8Y$(he1xVthSDvtB>^T`zM z<>|o{l7LYLz^KnOmO9X;iaXwXt+jx~YlC}qNUfvm+$0vrZ5EVIfDziC6Xmhcin@jr zEwmIY5p7`fcJYai!)Zd(@Mq0pmpou(6JT$^z{kv?cuv%g-M^7hQ9a^EB;lO0L1e1=JNMT2tUDr0?DGMW@xNlPDM^e@0bIQmBv4pC%hsIc`4 zaI$*JAJlc2KobHOaEP90XT&5KqbCk{LLcuT*!{PbSx>t3x7Fb_D`#@}oE*~`<4sv0 ztbEv&vBEuJTbCLVOn*^-v)$+qLsPq z?R579{sbUNSr@ryokpG|^FaZ-U6wH%$F%j?-CMW01~iG>A)T+PhsV z1*Qj=3D2@1{K5WyGNJRj@x5A-@m3Yw7I0p{57dN2gSbEn#>UWil48wlX~ zShB4-)TU?a;YULXDFLxR=5%bmHcHaQ!NECQ>kis_9W91R9L^!ZM6|O(pL;ggOIdD2 zhNZb98&di!R)`!npw*{!t#(7z2qs!*qD~NgS(-jqfP$knEl{^!Hj&X zm+QXuw7_i_-pBh*wh?%Gqmn>(5D#4^KIWLJafL^5ELGYw+wGrJ(!+=j_qF&E;DF=LGpeKn-1WXk+}3Y_ko)a=zuXli}Ux| zkCqHt=*b^AyV+hLva^(!(e)u~LDIkwQ-xu_7Z(uub>sJinmor8exPB5+ffMkiq*#bwg*&y+GHPp6@)Oe(VsLg2a0y(Ss%YNbphN`B>noN_jC2&xGlC$!+$s)?~(k=Cf2`9!CiM8e5#rR&L9c}(CF=skLpL+ji-ORTqxA-?FeO#ZX z`pS^gL>T7h0Sg zLM!~0^VQUhjfZPm5DA}SE|%FC^`~8mYjUOFU>u%3{rP1qBv4PUko9qmiHR9HTx`5# zE`;9io!N60e>8LVs%#(}tra`5DH1{(rAyDf!pB(|(`H#;3zhT3uG8-xR^oyBXAhjq z;zC;g-25|QQC18!@HvE4Oen@{XB#p}8)#X)dBb2ZU^b?V&SnYMr6ICL zNB_EVHyVH?)N=gJ?NBFrTXz*04m^C*Fq_H3ZX_ck^P)J27}Hrxa{)2Y_`Xl8y)}4O zod_a%VY~kYnE8{jkKGQ3GlH*gZa!32##IC-OqkIFM?@)|7uwb0>m{-B`~Lh-83}ut zD|cdTinxZhQq3m|Dn|L@ofqGzLsrnh_lV>u&~^N!i7dlz6f@3|+;~>154Qf(;}c`6 zY68Zg8HC>24`i;k*op8K#dHC~nX#?G_My`7R-6|*tn4nMtDN991qe<#CIM|-8ID~V zU}ae_HA$1@re>J&8$O@Km&INV5(e!TuR5tk7M2@K8HY|4g5Vz7G2l2U=tIbNjCV*Q z9B(`vbV%)|4c5=sh)1$fr~M!A(kB{AJp?7X$e(w}lmB3H)^cP{&jEvfx+e8%5nBem zfkc4}u#T5ocL;S&M*zAD{maV)z+|lXPu(?HHaXJ3KtBM|ibocSp{uVPYr=)aE+zu> z5HDbamS{yj85nbEB|QhI;h?LJkxJv_{L~+XnX|jl|MCqxeA>8ZHbV>s$$>z6LjNd% z@Ur}x>leC@)biT#;YtoT=)c4$XlYfl6}|MkUKRjI)f);_Sia^(7r$pD(xxC9EQ^gz zWap~vwa(H{zO-#JF%%IUF@4Y zI=ZKOhw!Nvn>{@K?t!&xPkA+gAEXOL-iamOIDEb@z6m77a&+iE5cWv3Ml0eZ83Qy7 zLTzXj0x|nRPdW7&4p#ZaQn6hMWJ~wm-N6rhFJKUPKNG6hn?lP^#s-m}6thWg>WK{u z2@!c5$V2VKAvS0?9;Tj;cvZbGgMWy&j;TA+F~!}~y$Rb7m@!55 z{jZtjGPzsNyEOX?33Y&3HQ-Jy;5M9)-QOxk$_8$JPFj(+XCgmD>Cv4T-~ixB=^9TF zc73Cr_yiE|d|Jd5bJ!g{`a>yzkvwNUKQyK}Ih5B{Rlkq_kuHqx$XyOue_pzP<)q>C zIxz8tuJ%rut=0!ECY9TTg(Al{=fpo_gUW14=a<5bRNLJtLWO?g& zWje>ELFxzs!~oC?xKIkE3lO+fD#nd_EeuAKP$&c3X z%hRm*Rr}_e%m>z#VTW6l(BLemfzeeWbxGlG*QWqt}`r=?72_CCpT&z zHHnK8-aVn7HwNG!5XkOHqg6*-)?|0FUkPJ{oxF~GeF|T zQ1>nx=0qYYq?atHa+o$5u)O1>c3jt?mErLKmonE_uMDePCW0+Gs1^JAGxO#qDreG6 z`fcOq-XBA^uPBc0#MI_-Y&0V7Qb;EhiyEHN2VW5CFy6Pzj}lzn&)rYm$=xR=)OI2b z-qtFUR8P>FcqNG4&>GI!^jH{SSQ->dnr60K|FOKa!GO|qx4sloX_;i0`&+5Tz5CU< zZ?zbVkQ`m-^|qI6cdf!IE4y->lKi>$KbDKfnAXjp{qxwoOaes|cgFw8HUI zgz2Ales*sj4*2riDV)O%Kc?b_4v|&BreC75Qk=i`(h^pMiN@Yyw`}m*R0pr{jlPGD zfwQcH*#AS8jR5mqoky} zrKD3r`Z@gkKllCWe&bs_XV>+OPo1xeQ2?;7qL&g=gC|J)bIuo>?=*HT1Sg6Mx+8FL zC)NenF^ye5HQo-7q&Saoi+Fr3G|za;*$K z8D5Y+{%>)2V1P5BeRukVYCXyw_!#@6OpCcybQ^(L)XZF!hP`(mUc1`%DZW8!&Cmyn zgELJ6)O(-#H$CWp4%p*r@CXyhoNS5F>;FMc{rbwqyduGm$CiL*7`<}Ie@(ur^ZhZH zJQNuTcsuzVs;N)%$Y6M<&Y8Z!&Bm0`+2# zH53t3ZXMmjG}j_4JzWW;vj*Rst|El@`28^EXzfZzQO8QjotCBo1~FZoZif@SyHL_~VR>oD_1MG}V)E(Xpqeb+p}rzL(J^ zrsh8oIcqIq9tS+HSIw?h03FdwHVXr1S!R^)2GQE8<>kD?=i0d?2K1Aq%|W^Eb$%~M z1f0n}fvNEMKi>J0XW((dp*fDED``5po=~@`oWAp(QxR+l`N%;paFz01K!t$2;kFA4 zgI!k zbafJLL2+FzWojy;1NJdWdQEcSGFzUz?YmdEZB5^*222XVqlJ z4|#54MG8&UfNFh@e-@j#HT>|0q%Ikm#n|^Qj{6LQc!0=9wM|S;XUMNg5*!zJr^xO2 zJ{|gp5%4mB|Cay9Sd3Iq=JkVW`cHU8opNLOiiq(a|Vqxb<5sUD`h1{zrNE< zOINlutX5&0@)+m`T~B~b+9-WEzddoc^)DQWtleRIxOqpOi{#Po)0xGm#VA>ixj{wETruSE-;3hVbsX;i4c@5m|}e z&QDnYtkZ|=GozdSe%E5INv3#2NoDr6J<--@TfX{8yKZ5Fuc}is7P?M^%Q>TEC7E~ktYvKwS&7IXn~qF_FkAceRIXPsxwmU!Mp zR$Jrs8vz;J#5I(XgUx)k9t#9fLyTkPLZjWfC27;_n(2A8Q;29^xXkJ0RcZ9 z0o^Yp_*;W6nlTD-mcyy!RzH`MDtr4ZCUontWV}Qa78Ey0PlpYCIBap;g;FnIrJ@?* zOm`M0Fs8ylMu%^)`QNaa5%VZcWogzRb2E7;j<(VO(HtxT&~5I$&E z-1%E?bp|gkx?y^DHlfh)YL~e_2j+@(jCI@=Imi-&DU)Q=@>r^o75n%4_ZIvbPaoqBC-$5@VE|C*i`Wr9 z3aNm;ISZJci|<|<00d_3H!$M_R@UXz!Eau5AizhR8P3Cg~& zT@71iwY#xg25aUy)>F}1&5|MWIZFz|Yx!cKRgBZ8&O&A6&_^IZ)x%$V5x_rVyVKn{ z$9F0*JQ|wp*Tl)w+yITvFNmzlc7*5;?nr%fo%r6ZVUffSeGhGE0Ngz0H{Zq6laV%~ zemiH8nTc^MEuyDu(~&}2UVrpdtvz`vB`yGYW$b-P#ECq*RP6yyATw&6`_aAiB7dAf znLDV!$tiM?Sw6@ux?~N(VM5CjPD<1yJ|zU<^IxswzdDJebo?QypFO>sO~`htW6Qk0 zAty;}PCchX4$H`pWs@dFvi2}ob1eThby>SyYzv>QE#G7+Duzn$$#;2;-t&#;9x-vJ`r9vQqY~uHJ z-210w<+)MWpe{7pM2a6G1|(ttvmhn8`JVbMSe7*gu*GF_m1N^Z23|K-1%9Y1$`4g? z;3bKyuV1B)?$gtiJ^F7>J-&S|U{0;g)uJBVf=v(qZzs~!vdj8|#`rU9Ca6tvkB6=% z+Ex>Tl-`Tic`6Y)jLj9NAU~q3s@Qsay<~q+j8}QnLZO0W1sY1$i)HQlJYjZ{r8J3WmgFw+ zce6M0*Ds@{Wr@#6@m*< zm-wM{zWAXWt_t(PP?YE4-38DRIUFbA3{U?J5S87M$GvXxyE z8cJ)q!26$k0GSX+tZNP2pusP8@YWjz0l=bAYFjh25gWrVke5>g3^5kBkM)w==JV?T z{+a=Hn=GI`)*@a!`jHUol}X}6M7qRMGU!@c!Zg?Bimx&^VN^ip)3bvvlK<*2T#cKk zs6it>&yZ|===H}O1n9r4YIshN4$g(wzn*lWP{oYH;(y^vURwd5E9d@X)F`49c(nBv z38x5>d3d^J7D7#@X%c~AwWN3p^i4M=e=^fn<@iQrc)XtV@IW;gn%EXeO#k5Scz!<_ zC+feN+9Ubp#)=<=t^+ynKjVE{ZBc{&B~9pQb&`%MWMb#Za{&KhyhDPo4RdDxc@~LT zBn79SH#_N1ahP2xizU5T3ABM^Q&nJ$)>r(S#7 zaEsK!CKl`y7pKfqv@*j!9TEaiur{Qyeis=Pp1iW18^n?SmkEOf9XI(Bpg6x1uh8NC zgg!c-w~_UpD=y@b-&Nlb${S1cK;?+yetzyL$wf5A=t_2t{?8uNe!@~6eoCw`)A;6VZ}i2^~^y! zQ{f8m?4J#eWZ{(mEiEHnTpyl9aC~RJAHm_~E>$agA}DX{;=CQ@qPe3M;%9r;v%*Kd z(&^S?J)oJ|G<+S zfo~s?bYaNp3$CAuRjtD&g*_l-A$S#EaLqa4phnEyTP~~drCMT~nbXkmsavMgJf4KE z3#-FPSy=-xd+$ileUiWE`%ZNj`FSB*-b;if+=c`ZgY!hxUCrm=UQ)f=UNC3(HZY>E zU?C(x_;lXq&)N8yEe;<1kcCq}VeO916E60oorns^{ShAiZG-xFFJx%5M=w_U0xl?( zHuwO9zhkMy$rVntgy*0mSKqX8ea~t;7f0!NV+6x2Ed_<3vF#gT828Xww6_fI0f$>h z!Io0Cn}&>+_5l93iFE0h9qn%~0*-RV62F+-d?i36x-H@D`ZphU>ytpQtKTxHH-L7q z#gP@D%;(}n&}L{N_RR(AOZIqej)WIOE?;s+)|du&UPeIwV_+8wq@th2{kP5QgEvWF z2A9LuGhEUQ8E=-3{|tmRT-W~KLR;e&nZ`jW7p|X`v%U&V7h@i7>fBVMXn$KAVvWmL z19@G^AU$>3RKIQOvDTm(*3D=h!BIoH`6ok}{3)gmX=R0|u5Dag{P81cb@WmcyadhA zRy!S0-HY>GIO{Lt6v)~$8RCB$k+v@tn08bs=brJIwWqho(cYXjeg3n}LRlP7C;&mr zF0m7w)@Ihj&!!5UeT}yaI$MCaz(a|h>vJfUhj#%h9g5J#n=Z}otaFq_q0QK=BKp?P zGTmk6B0CLmX=nCv3_Fh-iCz|MGY$?7(F1~UzUR-|7Sgv>1?A+yQn$3x3*&37`RlPC zxJCNRzpkYfyI!$Y_%}#h=!1}`vBdfjE(SFG?1jr!Y5i)dQ#Dx~; z&3u$CbCn7yg6u~S*1fiz+t{L(U1)jYkxo_X(q?a7-6~mSd6r5RGK)a*VC{erWvv4& zg0vo%7%k;TE(!@WP=%dB80GAA*SBw|(zK;uN0Y#O??;jzGrmE6*h(V?XFZauRgJ4< zyDaB+v(r&ZA35A69aic6U`USeinT@5uSexkcV=+_mWldRQBic_GGI8RdjfL#|M8O< z)2EA@{d&7VgQ%&GjCQ#&$_pBj{PIEs69hp8;#?%~zl)UjYW$(`Ob5Scb+u0(<+?8Q z5Tq2Z9g;AgVsOV}3@NkW;EY{E;NKB7RC%v*6vPBWSy26|8pfVYCwtv_IA1?VVTzr| zsuW8kF8*1?XLS48^N)NMpMJ8SD@)?Zr(R&mi`*y<1$!K)HKVT09?xnP+vfDz40--B z#rF;5x=35K=AriNo-#zwKeBMqAfnGDMH~TTPYS$g_}y-I@&m)5^6i!QH@GNSJxEh< z|8uM_Fwvo-&@o1e^99}E%SgF0Olk=@8RhNAmX&OO)kHyJpR z^X5vtd)4bI--$K$ca`(8mxWM8)@8c*e040r$;QpFWNkI}IeJBdRy|S-A8aW#d z5R*S)2X;jrKyDI#@aFIKK=Nt_?ZWUKi*MRIh%v%LOZiyy)uyGW<478!bI{>^xoYx< z!;(fVujOdJ*Cb+F%x8u1vfW5>LEgq*>{->~(^ zpYW|`oo_aXJ6@7Rb2Yd{Vz znijf|gp*oHt$O>(*Y-f%TEtqD7QhAFCx=W{jK=~;*aF--0Yd#~h#|J!(00UvWFz+rO2M$vUu=mUmLB#eqv zOK7)bDC^K}xZ8XO|Hf-iNX9sl>ZSf2HgO1af9Z_QxlaXB+LL!*SDT_Qp4EifCQI7U zzVN_0mE>vp{s*8VH+R^&C-bM&d2K;TAB>$U=P%MLSpm=g4Ti_bBAR~icK{4_BUi~Z|hyzWL6c+xMQuHGI^0!$M z8B0AaGoB(6U5DoGxaethes#VVX~LtO)Cb&<_@jHpC~enzG(AI%_ALi0C{;sxyFSI( z-4=_FYa^KoH&I%}DZl@R9PltS_&AZmiWy4k5=@3$%!IL+k_hbyw$vu3Hx;euH;(G$ zG!kcqdor2}Nt~z8J;zF0K?>k4mM3k2d){VR%v&SFXhiwBV!_cZ)DLYV4HQ)Ax zdh0=tB%me}wMO!8NXElh1b+~&-Y*UOd#ils&9fOY@r{Z+w!>ONQPgD6K2~N1_lOi6 z3!$~CDIy>B*Qy#T@mL8dwjQ^6b11&c6i}1uo$rj|D@y_Wm%()y?nqIA%Y?F4vwZUf zptJx4pih@zOsK|=j_In`EpjHyvtI~Ug=ch%Q8x01r6iWK{=(<42I5$c1Fb3-XD#T^ zt=f7f-K~|2xTXM7n1_R*ba!`$<>s-WKac2qY-0hynV_3B1L|VKB4yEzn*&woit0_# z2{WN`jbK7=rALfy&zhX&RE&|YiONCb=o)oe-~S!WzC2>>UJupgtuIQjo{mn>(D-wz)q@{{Z0IkY_-y|FKzd!VHF&_{JrXEkapu^-u4Q}KRl_%4#u zjh9$PcrFR!k465XMC_25IWD@115k|m(;_OXG!qN9qL5Esa9ts7v(JEBCsh? zGZs*MBd)m{!Gd4=wN_fBL z-13iF-oq*`bj26)iVEX2jACJuraCSs;1am5dn5;d-!O1i2v!8VjwDz%>MTq`0D@*f za~tT#R5!=k^x^C|r-pL9OHYPe9Q%!CF!vTL){t@HFK5RL%)481{h8QqrfFQa^3`#A%jCW7D};O;RSMs6&Gbw0lo z@dO=)_q{|N0W$3;C=3ff-|KXoIu74|U*6zt#HW56Bp*yWl6}ZAM)Q@W=)4}d@dKe3 z0kG*=;VoQ87{^I!v7od3#ssG=Qlq*YEbO~WA3t#;uaIOD@|a%aHmCH7qrg|8F9E{s zBLk?GLeJkqQJ+%5(i&LItOgp*@A?Lp>+Bb^nN->{G@)k$e662~;Y+ z1tBPYn_t#NeoI<>84xtsBZH~Q;;uR>#B#`1GA`6zuH(Bh^a$*j$93_PgkgqF6vK}S z=+T%L1v1njUrFCTc~Q}GB`d36aA3EFv>2hnma?45v3f`RHtS;rW6tlQ7hHkv?Ls*x zg)~owIt$OM%gWfIe+#ZGehpv7JA>6SN{v#VWxkxGM>lM$YwJ%UAbO!9!0bRZ^kb6| zVe(^dCBMtg&+(%Oe(IuvuJzYle?u3P{~dXDM56nlB0}3os{5|@w+Y&Lme8K3VHjWm zycvBCVDE@^984v(47nce*AHEBGIYf_Fk+Yjznm(=`deJieC?S z&O{Gi_roU?QnFYrvJlC7!rdCO!ltE$tR}uwv9VG{uw5aN#kO9IIuDoA+$x)SU-_j! zX4+CK!#b0ZpryMy!$T_;hC^2cPsCEU)!Q)*HSOtuH z=eO@EpQSjW`W(`pwp=c50B|(3MLa7LBwg{lyN84xLEg)j$uD<6Yfx^KyZeSk2CH2L zb7%$?|kNs9MluVMd_Bh_Zt&aP|wW!2n(D-FzW3@o1NkfQ2}08e^KQBrfrBV#NA~V?DL*j zsh7%@9 z*VxVB|4fEES)5!dO4J@?_kK7b={+qh^l>u!n;)Bog$>i+PeYqyi>^~)9)Q_iv zJL;{lJ1jKg)fp+Gp zN@XW*6F_%rn@K&~T3*g!HA?>gNm@m^k4!sc$Q|~yXkE=)zCEK<;*Nph;L@Xk&c#oC zc`HIImi#}!t(CSh2Y?P$Pysy4vjI$=Zyi(SxlE=;F&%+~zQ)70(x#>>k~+P^u6HIv z`4wr}WY)kKhsS_9ER?oTJbn;l|M-Xy95AsRBy1Om0S$lz#cT$@aiQVg0!{ZztaQH7 zs4NK&f_i5rK5lg?iu!7Wby-oowj1ATsOF4_$Xay0r#lP53zuMLAI6uXmiU-B+MFMl zjLMsLxMe`kA>W`)XK4L{ROeq7cr0bTO5vXmv$)@7`fIo`}j1n=oz@rp&BNH4W4wCKgGLM>18|r(++GpKPfJcLgTzJa?v>d6`rt$>fGgC zrg$RKRYQuryne~lZd?uJbtlP(&Lku z7yFC3K`oi3QNrEjHTq*jJjT-4x{rN}8Lhkmg>eY*AcB&a-S+jjUhKX3p6l)VEh+5b z^Hu6i?W7VF>z<9b^?kIaG$&&RB~Cw0BtAC)8|Za6h&xI zO`nt&7=$=I9lNl07N^iTpvOdLsH3*Dex6>HH`7jzbr@WKRbv8>f2f=o50F2LUqlf` zVa9WtX1?|N!#}UeBXC^ZlzhrFULN3Fy5hh{VG7e@KWxo+x{oiN7)t!OQ!v9TWV7GK zE6$qp>Q!krW1eF7ewqBOcTNn0L7Z8Kfp{Tu{Kg)>2j3L7TV&xoF&c%Rxzb8(h86Ta z78QoQn+Vm>klIKK?>n>vHcv|dL}ihygm=SxE6KcrumH@k%Ney-Cbv?-)7kVV9)<4+ z|HA%Cwo@DJS`g}kIHF2Nbsh=~2ZxPH`Q*9_(z_aGv6npI>G8Y%;5vY}u6s4_HnHl4 z+7tUad%W>1W%`)0(pp}ixh(hZ>&=lX)kETyvCY3cEW>((fjYn`<0bFkEgfa7ixJ#@ zKC0(8++Tcj9(;}P_(1+Qsb|#V&Dokj22Ug=#aE!srktCgz zkk?#j%|!gg)|}4(Ec&8s_ZqXU9emwR4EQ8uOI0nrH)OZwN6nx00W|XoYhnMG4)o_~ zfyxDoI#9I^^wobRbe0scmDu>a#eH_v@qYZF9mAyZS;H~Ek;_=o9M;gDXLfV*!c?KR zz+Hxvx41=~ADr{H*6#aWD5B;(dV5kS=r?30wyk9WZ3Ol%J=PcLch>f3Iwz+wHQ_vT z-TB#?L2Ov`rA=l1(s+GO@l$?{o=t_iz!xhWfQbs?D4H2=?pK4-> zgYX%4U#ZGWn(#_>R^n$%^RngQq5@OxrCg$PvW3Un3#>XpN;ZsyIe1dP(LX?su?dRa zjQPP#fw+=<%!*O4z*dlk$xzuPx)H2dJUL|S+wcG(!1puBe5F28oE14I*@+zya+j>03Jc_$;mDv?u#s z<@rl_umcvz%EZJ+uGu>;X6@TMV&3HsbGO&nl`ThZOJ+lJUw!^YIgfD?wVdivl<&4u zY&Tm^t`2ZYv$jFnwD_H759@|shvZ)G)l++9%{q+rQpTlnxI`;+pbH- z@_w?Tl3%YUe?o#Vo`-5$!9Ke0^RBHWe~+aMKPi(3I`}QPU{wqtjgoj3)u-H1mM&Ns zz?MwF%^J%GwU0Lvo)+j=LT5J=6eW*J(X<15?0i{Wbnai)2V@wEmzHWk z`Qa*l3AH88m(74;BAfD{Hw9uZSYR>{LvWx2}HzD}9b}lb4 z@GS&mQ_~;xWsXGm@6!E~3X`&o$-oh!8=ISGh7#vw0H+m^G|gy^W#mktb4N*6m(^{) z71qUp*xJcXs-@$0F@txO%oxxT@`ypl!vZImr3Sl3=Wve-yaj~(Fyn%j2U+2xcW&Y_ zg^0Gz96j#99eaujP~c~8;!s81>{i!0{2U*i0xWz^h#C+}E|0VWYV?qv5kmGapG*$kukhTQX*p|pV#F*^fml%#8m%aF~`m=EtP5t<8u zHPNzg>2lmm9^yH!xBdp^_Jf=V(Ra(F+Jm#^{-sASHz2oZfC^6x!I6bmTHU2E)V1MS zx>9^l_PxHI6PUWpCM0M2D+4gC5zk#8kFJoNr@jU$MO0gX@RtYIel@+2{0%V-pAFxX z%I5-PZO^LBzYA2ff{^dH>|41V33vBm%)SU%6*aoqDD3+96}!^0)raTcYubet`(6V! zG(pC0WjC4W%zq2(Sc~Q!xA{yh)6VwMKQy?`RSaI!3HJ=PLe6-e#h}E)*KeQrckxKV zfRf{eu*$a-wi1>O3GLplDx{wq4JINp9bj((FcJlfv zX{Un9rZZxVlL_Jgt>9tE9kHg5U5c%Qb!XCrxRdO{Q+w5=uJgE z-4dK5_-j-^JsoFF1r|9DXL?(iGO1D%IH|Dy&T|w_c3B;p(kZ)Q`QXN%vK#C$K}@9}Mxzx!5=ed~1ey9$YR%63|% z_EJZE)z-6cYe9WRDm+$H5sw2t$l%P2pwQ=2b{mp$^}v0$GIll#PTCOc8SQVrOx`*y zxi+_gO3tAsrg!Xaw&O0h7x;8sZCahDNE<}8#^5`_4D;Th&tt9U4_QcvOxo^?w<^W! z<(Fs-?4y0me1R&xBuA&vY;X`A#ZQ8`1d_FoxK1TOrU#C=y+}oqcN-yrj3tA`&zP6y z^V(M0%fMcjF|mL~eFV_dONUzv^IaPaRd9P$^%k}~m-{BV_;HIG z*ZJE(NHQ>a(QSgC4q!m5c2f&}wEjN@Le=T~b7Qmj@sP=NaR#e_E9wH*GrM1gmXs?R z6UBbq9hDyM92u6-TtXEx4Vt1m>*?LEnyIhMHPXJ@9?yuX6OPRW;S;U4?w#9_eAUC| zSNL5#E0bX8^w4czcbDmNPwF9g2JKviQImM{`Kg!SQ=HOsFx8=#0-s(8>d%6ona2Ei zoz@J2N8@SzsrE!CBXHrmW$&ysUK0eMMQ+!iDGA`@xttxg(u^EgV<3C1`j;tPe&>f0 z#=RVKX^g6gt6AT%g1JdoCk3-~2NP!CYgPBjUEfNvvMO<=SI1)f zd77xhF;as(NJ%g`jB_NS`kiFP&G*Fr0p1?Ty&HR|t_&8P$T39a;z|WE%$dU4y=O*U zQnMH}3zvFu3Rv}b^Q$sCCE+f|4^3b;Z_4T#*pNy(;*=b{8f$en_x@PC#6yr7vt^P` zND_pE89%?$^uiTL5F|Exb6Hh+>~?*XdUmm&;ko_oO!iG+K)dvt?dpx`*+}Oz0#YcF3pms zopanF=J^Elb-qLUb`ylXBsA-Yl^S&~S@INxZZioACf2Hi%c_LXI{&*UiC9fnZJt49! zPpVq|-}dqpz~qVW3`zjVh=eil;-nXfkBjO>`Qvdw=_Ub$D#*em4Sq!!EYbQk)_T}h7+iAXd0lyYBg=Yq4@6I@(1TaQnK zHnF=`A$o7p75&E&dWeP<;x%@CYnH2oc;v8^5*>?Bqp!6@BuQaWsH7eVkQFxN+P8Au z1d4-e`!<4-Wdyb+hvgy-7KHnDJd=-Ob*@LfQZgS)7G$Eg1q zy7grha%gFV{m$}6VPUq{f__LPjNiUb!4T3jmxR?&Gipf z?eFd1g?_KyTFxIa^UFO%BELmcU>inKr|)|u1?r^}vbALk8bsS7`1fTLqHg-Gvlgp3 z`&8Vs-|AWoE0OAlF0|X}>{SUpW8n0+sD95G<+sX#ZNj=@N=x4NT|h}6r|5-pOxPt~ z2hbos^(72E+)EzN$z!{{tPCB>9$Ou+4rFATuE#%?PmRpZjweq}O}WULYdl=cDG@ZW zwe2N2I*%;=K>1rh!KZz1YJcC}h%-Dskl;cJJRB?m=&6nz6RIQyk)7h(>uSd1j67D)* z#iP1WDjJd@3~O}jgv0n`Ns0Kly0ptI=wG&F+vl68i;xc_xSU5@?f8`<8uWw+a+uCb z_ZwPlKnA&0Id*8kFh=G4=Bbz-*6Z!v~M=hzcEnKCJOi_3od!ZzuXk%#D(aM#WW zT1m~Z{_2;V_vwXy-AeQJ$7r`pSNl-9vi4m?t2L$rW$+{R`i+yKW;w5)OTDTo$`T)6x3E;)rM; zYFy3}A@!yDyozT8I|QYsH#}!N+OZ#BqL>%IDvLP4XJqJhZ~|G-f4|y&alCxgGA5Ol z_k&(wrXV!QfmV>mi6^JSGze2z!-@Xb4sd-#C#})1x`b+kT#<9+^7O|oP5qFU7uK}wb{PF;iWKY37JpW_$C8n3*(Ml+43;JCL> zXFkrjkm(d{sz-0(%9zh9monBu$vaIRr-q&R-U)L@Vn0 z>PH(TQF}*+tQHJrkJorzYwH0>i;DAnkAi;qj#>jzb>H=mO{OP6N*YUY`@hWW_f9h! zi*2uTcO%_8N6RseYh!D+_?&`>%GyQ_`gXuYteHG*Q|eWtD-F*^EuEl(>gIVni-=)= zPC59Fi#vEBOx$+rw=aifcO1Q|_8y5`noV%_wdW^e*g3{vCM*M)a2CY=QxfCvN#Otn zYE4RMM&O^$nI5r`w5&w)axQW3ulb9#=4acVKy+mY$blseNER*w)@=TUP#5J>q3;Db z`G?SPmPqK<8XSrvT`xQiI;s3Dg0aXsOH&_9=pG*@J;}iqhUNZ}gMU8sT(yaZnbOdJt0`I>RFTEkzWG`$vBZ1X{Tt;mvQLI}dt3(`SqRsTt)z!wQ zb_2JI+KUZS~ox3-WD%twrs0AwNcU?=Tx>c`Z$8AJDA6#?6CC;(c#qn+kYloh>4 zY%T!G#x3eirdZjrD|%6HP>@ec!~)a*TxELoKNo?O`;%fi^kDauPai#6s=-TSb7$*FR2&}nap2x6w6uJ}T3nrHdyxGYVEkiP8*G^j?$T~K|>+xBZUx!=% z2TwZp>8kvoGujTi_8Cd)c&15RSNK1YUJFirL*>I~&$<%u%y}RcnpNb?+Xl!tUCmnx z14S%n3_EoDr0Fcip?#DVuaMjoUVn18ww%g^mkLfd@-hWb3!+mbE*1>!gOcw61mXGW z0f$x3R`EbdQP`+u0_4xQMIq7E!S6r%j6~7`x3}V-P1>nfg_{Z@Lxpu+)ADQCd>A|I zu*_z&JB7qy5C4qBsxVJqmjs9Nh*ewL|hIJC!N3S~=Y4HCYjxXl)t z`A`Pc0y>wz1&O&dzf6lW9MInw`?c z^Ddo>K3Lzq*Q>-uwbA8#^*ON)3xH$|2%uumkKEml(aNY8sKsP(hd#KLYD; z^Hg7m?rV}CaxZ`GRy+k{zqDNkeKW;VA9<^-cc!Xwi!f^T*;8K@WX|u2qhEZ>m%Arc z6Nvk__-<5e0RxoV`Z=xwL4{p(eHncQ zr&S~@CM5JwG-0c9@NChF#zAO|^VNp~64+Ms7-1l-EznX1oBatjpG)tJn6MoON@@oJ z-v@g9Obaesdh2I+Ih*!bq;Ong?X-yvfW-Q?wHY>lOl$z@iZTrilOzC`M>qY&bVAbX zaBNwW9dYb$b!t=-P+}Jk!;-ZoD=qC7Xu;Z%^B$FC&HszGU4PT^@Ot2gQ+1Jda`hpj z{gJukb-lq`yxj*PINs;twbf4ZJ)}h&62^0lUe$?xWn2uufc^}THvNBJB*`Xuu;v#x zySolSAsKy2S2N9&Z%XdPFA-p4EB4?a&u08i^LOe>KhTEK@Vs3;>XwFE6t=6tYcF;w z_WC~vyOF|jkFsilaX3HeL_Sj-1dq2Gb(r5B#{(gCYI|MSt801ho{rt6jiA>CVA+eiB zWSIG{EiLKmLU{b?B#22QN#hi>W1mdvd@kbT;E$h6Reb;DlZt90m#P5!L=y8Jsu3?y zrkuIAKuc~VDY2+x`5Q|DpGLQ5Ifs{E+$#spr=QuQlPl6Iml91G6~8Hj@zLYP-0^qU zy+dKQeRJH=^6E4z^VD@gZ0;(PVW?yzZ{Y0B!milD+09;NdPU$(!*o15C<0cT-WuIC zVEHts$D*0S6e!?zL}VT0ra6f{SvHZtIpjz)vT)3JfgYBI8;;W$?JB6et%C>{xf~yu znNH~q#-xQ6qb}XRI7J*#)L(J>)^uNni`-Thd#bkAI7Ldy>_!nZGjW)3VY(2iDdysO zWv2SFa{{Wxf%pi*j}n^gGxsDI^u3BnkWG9)+=iDPA!=Vf1AY29g~N+jE%)2EmzK$; z^RLRI*(AB=l{Ql1|9Ys8X@$mRll8ZZTxs7Fs272eYLw7akWw0d4%lG00lSv)rVDo< zKsC|r`kpyf@U)}3&~b0ztKE*-RxfoYW;kvPWPje|GtgYG>wBctb9c(mid)B?sQTte z&{rdeRPs%?4&&pBjRt-ckoO>E{~!@o-HSVZ!!k1aa3{!myO z+PXwXiyuvq)czJ}#(%dgTtkp9duPZ?NFIdHpkw=(MyOd_^_2zfKT6;s>Aq9LGhM@1 z6~2Am_-;ZQRZ04gqd!w03~TUlTM)aTVET1kJdRhhRrxVQ#m!Byo@5iV4;(MR;zkTJ z8%XN-ocEPFCM_`WGDeQo0Rr=lpTMrpbPPX=b<-Ux-**CLR*bZg9#fpZn!IBV=2%jv&JWQ`s%Wd7@4A zrqehn`1cMMwG&C2)b~f?^1?TpaqD~Cd!iF-@`G2G5%`kfyexJJ#?T}a-cK999zX*- zX58F-pMZAjt?0qJxP|~WQe*}t-1`82gfJ(DgL>~7Sa^(e-Rq0)4d`4gZle_)-*~F? z&f^jSBkvv=)o4()4aP`qY{{@pF)Oua5LOOtAJLGA+A)^Bp{9Hx4PW&9V^#fLuaJlX@c_!C-q@ZG`1#oASyA~AH+l}e>(M6jv10}xm5Kb~2}G zB75(vq0p*!5z=b~-l{rFRGtbWI$ig0QP};0#}%J*B;nBc2JrjYY3t1~C@pljb(x=E0knHRlI>uZijuMnl(LQD+A{<{ zx=VWdr30ysa^8S3Yx6OYJ;+iM>9w9_x^1ZDZGcH#eduU5b5Y{9dK@li1raVe>@5U_ zPl_}Ot3YX*LkyGSUc>c#O%#-y8Z9RhWVYKrd7sLE7!uJya#WVSxwUMu%1(>>`Gq-` z44dfXEU`}zslWeu*U?IrecJq{>u%jo9$a2)WD;D*#^YdjSie;GujDiS>dqc9p%D|V zyx)br8?}W|DV0tas+yIk_YX#08g6*QM!Hrawco(DfIq-+Ow&|Q7-?d`YM5h^wiSf` zg$Yr3u6T``jozFy7utFF_$38~L-$(jHBlnC;(2TeW;#-g6juLi@l~-Ta4L2jqI58G zD9yg8o9&(zpHFufAv7QYQW(o;uV8GsVkXfBy7h@q*K#oMcs3PYPBV|^R)ju`+2kXJ zeV3Uc;QGW9pVLwhr|xw;1p>>4-aBEl0O0Hdd@k`BXbJuCl!}P_a`q47%LwzH~5plR{5~- zJsQ=`5Q#@?H7XMxyN7t@htol;u&)^&0w14$Bfm>-SG}R_SnGZ=H8qJfYh!7;VF-K{ z8)u!?3Aht?%OU0|7)7Ut6cFfNcUoH7r^ywmzZ?cpBAzm#A!0KPSei(jBHPr;zW4(5 zdBbrE!$wJa+0UtCm}xp<7ZD1XF%WWajz#!Bel{trS1B#0%$nzrnjbM1`uiP4EI;3D z-F%(`?O$*u#<8qU-2tF&X`?jS{cbLE9;HR>VjHIJCWgzVY|)hvMmrA%w(Md@Gx+4V00=7{vO|--}fK>gV!E*KlgR6bDeXpR}KoB68o>4J${bZ zwQ<1Al#j`LX%^p=zUqk9fDd<_w)?Pkyy$8;AzJD~(D1u@VNj%a@_rz!T27}l{FrZ8+m6g^0Jbb&HJ1m^sJd1ZCR%VW& z{7JyFu3DDWs1FZtRC^e}bex#+C*lI*xvqbT)))wOUBmI`0DkGqW*YzOPLVm&WxbpI zo3DDUK}-;sd;eL(A(NV!srkBM46*pbbV>jm!0W$REjXD$nQw{4!lcPy8G96;QK$-%lUlcLw&v} z830@<(CI8X@URa>R~x$BQnc2DTr_jCH@5Yi%Uj93c>PZN8Olno3fp{RVU$6%Z*E$k zp1bM7Cs2(c-K0V`2-iw9{e=leSa#ZKg`T7E8RrzNwrGB4*R^?bx9zNOw*KIX>TyYn z^8S*8H3-uTV5R4LM$|dm>q;+EwzV%%)wvhA04Jy?hLL5o*)g6ZBo0BXS0lAmcNLTYqy#s%~kCAqz zge^-p;r=%4$=mxQ8~5u4?Be$fs=D40+ z=oGAlNxpw&+_!*AFtUe(;Ga^yIBov16X_mm2o|wSyr}%M*EWaPW(GVri{i6=uU=hF z4qT7PzVt)O%hnLd3re@f>N6y-E9Fgf2WQu5k+)XEv%2EoStTHJ7*&j$p4ho-Tn-dn zOFW(Ww&|rf_muD=XjBiK%nU1B=0l~j5MK*Kio;oeAHO0;X+NBhKd3txd?=q!R~)5s z9m`4O=}c9D7c<#-ocYUu?7OcdxDQF`)&6GXVNtB$Re)X`C!+=7M==i!mTz^CKp1pO zcBBGdR|);GW9qf8=)*R1i(&}XO)@b!WY<0+62A|qDU}Pdci3fiH&x(>Sr87T?+IJc z=DC8Ed%){xv#&-VVo@W@;?`$Bh1Kc3pR$aS)>#y&`=ounug^K<+)gQuh;nTslkoHH zlbu~r9*ZD|ob1)~uKUPdK0Aw@HyNN8b)~*n^=tB~2j6>R)Os<`ej#L@F+zi9Tu?9E zsa^Z}qH%u5Rs)36&ro<)Rc#+!D;C>>Tx1^GmalYobzE^j%1{Am4UivJ9eh+l_Qo_g=Y2riKt`HpNA0QtX+n3{OZ*q&uz66$kOD9kLnyRqfWB zao2!bwi%L{Zwhb&9!rwGC}FK(E#i}p%)8Y8&>cS%`Nx~B>#0}Ml}OXI1>eQwbFB^T z5dTuv$ELm-If5GDflX-yXsGivYYR;bIyRPYqSOmdHH<8V8pj;ON8FzlNks}xf;}T6 zWQNA}@FqDJaK)-B3XRN7#|<$q-H?AyO820KWoH{zq4G13U}`+P$M_&ECSo&*lbU2L z#jPt|Jj8?N!>eJxPG`d=RRrikuVPtMhs2IH>#wUC6TDgwWLR+As$ zn`H57OP25MjpI)Z&znB!Tl_m3FK8PUOaDBK>Ol&g12R<2{SEWZQs4Zr!K0*idP8Qz(W=21+UnoBjMH7)+ga7;LTaflJ_H z14r5~#U=Rpz(Jzpx%Ybl{_Y_uGRv5*n4i>%*>s4>iUf4@R^+|I=fI*_c}4_BEUI3v zf3&8ND)zezOHEKvka8;XjtBFq!s2q=J0Cf4y2=T-BH(VIvw>sAgZ2#d_IU@mi36|} zv954NM=%o7Pc_Y#Zd?Qf)a$r3@3>Q-Zs8V6_gkxTCDm+uep-w9mzq_fzDOOlIM+-N zL>R{8%%++70UO7SeQLsfDiEpTgllpdH82*>RV&La3y2Ws)DUhNw`Jc;e8Ev?C}wXF+bHDRk1z?=mSa+t=lZhrpg7bLpLi3QDLUf5s&{kjk$P~> zsl0vu?D_adf?_fRBZ!!Jf-~wUkg(Mx9@*C$Xn4ayhvI0TsZE5M!IdPqg9UcU&mS03Xt}dvO0$FP;8| z@rO#^tyCf2@b!!X4~o3k@SdHzibc|S1)gOf%Tz;^A$9a)G!-9TlF7c&TwpHrYX@+Y z%`AsW5_fNrTll8$sil^6@`&GlVwJxUP8$d#WeWyEq9eCg%J*VaD~4_ zJ15xw$d{TQwzQD#{CfnEz=o+gMvAvzM5jy}N3qJa{nuVjPTU6Hqq%p-97I6QiY%As za`Y=f7p;%IE-d^M1)AeJ`VuxuSI9P1U5v_)tlp2|4&P0VSjrjKUBXQ&G>hT9{Ei}bwwy3#|Mu?2NDyT9Y9hV|6qp7s@cU{ULOXC% zV*T+@f&vzr9LH&01fFBP3fbRB-M;x`WlarigX&(o$5H0bk}K1Ev&{5RCw;(Vur4b0 z*=6=d^`2q3*gmN%LlU+2Hz@)TpNr)b_c3rmzGW^%=Ec?>SV*uZ;eoyFqoC18&Q9;1 z(-*rcqxuToh@Vayfa0HiUedE|`V4ZlD|%SP*Gwbkm@h@Y51(WN`V+X zb}mpWT+2zVLF}5dTg|1+)xmHK@7wuqSrgwT6I2d`Y#HcjKr!+bE9!z`l7}cWOCw8O zS8&YgCx7)9fB&SuZXU-FzCrI;^|sX)6;+LI5Z%>s4vZ>M@j!Icv1!a)X3`_lpamCK z#8M^qV^@5UHpl6DPGZY%jtcLiF0k&Yz0^qPx9Vn`r57A-v#{xdtB!YMLn5FoKoDki zf4bbu#s<+JF)Dz)6n?dKT(GJaNt_-9x_{*q``4z-gH2R^qX9svKKI^`=|fvc*m_S~ ziYoUlR>-EUXO=d~oM#<6 zkm=Mpyd6@_!44q-WwBz4x2R%J#;;TJg37h-C1v_hY9L{_Z1ru@s7)17Xa*O8Dj6@m zI+%(Wp~4uMw3$!}C5Kgx#;zVfA+WaDv_(8=5H`p`=|i3c8C6}TD>O<4?x1t&5+)WT zZ#-PwMrLcB%wO-5p^#-F=nLZ85sav_^md-kpB4j+@`Tf%)jVa3ok}%?DZ1`y!q)@w z+_`2s{``42YMaRR-I3=!@nG&r>On*gPBI&r^O1b|q1XPd zTSaSSLAjrw0|ccyL9;Xm5Kg_U>;Y$5uGNH>^g28p{8+5O!Jl^Ac@T4U z7vme6H#_e44CElNc@5+5y(x~cUw9SmmR8#~1L9o`C{ln3s|%CoB;Xg`WU1YlK2;C@ z{UU9W?S4T)_%{2qYZ5viO;-PNB`KOh;sO`nlD`XuoEV~+Pr5FynE^X4+vZ7cVW1JNIs3=_V3ECVqi6V}!>)9yPlAnr@m* zbM?ECBce#XwJ$QsIiI+KjoT$^?Jt9quI1sKl8ugpsm#yLdbC4BN86%XQ`@A1vZg~I z*T8CzhVOOgpQFe<-_Y1EZ zZNbwC@|A@A6hnN=vKn#nZ1~{mw5Q!S3Wi%U%X=L|{417EyYc=})hq`qzU=p3iOFh^ z%llvE*OI|-$zL2oSua_5G{EUOPuriFXAI+>GtbQps1AP=8mqVyeFMN3 zhWER{&Cog@5ISNx-($sZ#k6d?*hHApiAdRMOEYlF{4~J3n@Q!OL$;B(I5qPkn2shU&Ybli z^KG_gyI2PIS6^3Nvrxdq#lGar7`i5Wb=A1K^~6O^8;B%8c{xLm#@~)El~LUc&cngl z3M`HPw2Sia-eS>%cSrxD3`0uKT3uy22>7>W8iFCPYMLXj7x51SADI4PZF@!8oPulk zW~K-DNZ$4~>8G~e{4~+l6&BVs@uJv7@Lb6#l%*Y#a~`vT|0?9Zzvua7Q+zh}Rko#w ziV{cCES30X0v5I5yBn=4*1PxO>1EXUx+fAheX&b;eyhH?TKkI3W2=gpw)L^`3Zv0< z%kFB7H7|ch<>>M!PUkO#52d?3?$3CkXFZZy9A}21AXmV&T|T6#ODCcYHv$ZQ(#f?u zB!C3j6E^9{^VO7vnTaPBr;b;R_sb@^Pv0X#vN`2@b~_33)T`%K+;9=C5&fYxXF5Xu zZ(+lE!^0YW9A|AjzaFtqLO~T!jD5etGbT0-5!Up=7RG@OB@vC-+rozqssB--Y>*K@ zSew-h-o3cC? zv(hduE;8a9UqeILy?%O4AI7&^Rds|iCl58>*f#qP>s;Mhm3TJ3{+l7XvDjD{C3K)s zTv4$LKAdUXJy~q5>Q~{3uF$)c;Z^HHH6gTbpN`8~5D zm-or>)*eKvrS$cc`KvT|DnufD6Loa6(CvQu(#DaP!U^ z4!_Z7J`q&I5Ag?yoxREKqud}~ zm1C*npAwdvd%xJ!cZ%GqCvr#3?)tG~+Tgw)Kd3u5XLM75W5$2H7 zp?F(Pz@NI}hJaRPJTi>N$f~i-80_(yqQXmdgQ^sU0 z#d&O45romleU{j3X2a$0Sv{4j`lYa-tJdz6+`;{?X=hEi6@Rx2NW6|NbX^M{T!m6l zxC*eRd}r&*kB*9oEKN{}IHUjR0M=Gz5eKI?bcmcI)}e~78)G;iV#R$+62-d7BIl)t zrY;@0RRACCT22m=iFSICfWzsq;H*nQ4Rei$ehUpz`kZY1&ayI8KAMJ1uUnOl0G+S6 zFVt0U@!Yq>whwqcRI&49V?Nt=T6YfqwCrLrsz4fO1qV!tS1_XS?yPtUA%AD}Zj-gU z6eq@T#s%vUA%E{JeSV6_T^N4S+=^2hG6$`y+iFbgmvMpDaustS+1x})9_3k63R@@@#biEySr7X z!M`Cn*r&P#Y+SUD?57!zF3HGgFUlUE`BW_Ofap`nKmM4-0&JiFUspiT+CiTc$pN%P z-)O0_XpeAjvz846R@KmEummTAElj0TG=ZsgzWvySvGaI3feV4>5Urx;Kaf}Nw&Qo}l!$|v# zJ7fqrR6x_L&6}HbV0VkUDN^u+B%J{`c5_tZZ|~RvEl& zDe#}AK{%B8JIv!({kmDOZ2lS&8apGZrxRcQ^8;bGBX<4r)ni)wIBWzxB5IiWUea{x zqSJ{w9^;XViF1@)0 z?>FcHxl#B_D!J-y7y|TpnojM1jkY%Y_kOCdCEmHK2%?0YeE)*_KAj{nBXwXDUmzLm z0i{ov?XACg3)<5Ui!O;dft`@v8H;4C_(=_`NIF1 z^8solYG++DMT~+S_{QTKzP5b9<-lwJF!;5jJ~=E~ED6TqHKHPtU{%KL666wvOQ^iO zg!;&}H}K6D&C0VRp%=z6Thg7Aw5u&~J`=mAXh~ zJ*_CjeT*xRhp+dZ>KnIy4mqYy14%--Ah!0kL=At45B$Li3Mx2^r+rWMz1#p_M}oh` zY-(=SCHL{&QS6?!M7jGA#X_l?}N+ zT~+Vgkixg!&(66xuxuybuWKVe)4mfJ)eklfsmUtTNdeN>;_l8DW&WwUxT8-MtR~HW z;t~|psXHo+1sltSwBJju(||v|0SOnJ{%G_)Uf>bs=gZm6O26?~3~_cYGLfEn?t>rV z>c3*B-Wk?T&k5|#ZXq~`6nTi?0DRHxkb8)JG8nQWJUD`ftv-}>FyA*nPZm9N@;pE9 zHYL9xw!#!NDu&{tvP_eTIy6gglb7O6L9akqytcM3Cn760X?w`}?JnFC6YY zB1`$1Q&I@CGDUs)Xv^wQLkaiXj>0Np%<8fK~~h45wHv0m?Fr=Wl--YN2wlN$u5 zckr-Tl@5%w(PkDi5RPyopQ|0e;YG}9XKBdMctkP|_)UMTBpc@6%ssQ(x*7zwPZ9tp z+{QS7*N&Cm5a}A$;S2ALg2q-Cskw;O*eol1JGRR+hvjfwzuS3Y#9Bt+n+cscc!N`U zkDORA64%AtIa7IJ2mCdapBz>ctqF=ykcoN-aVZ(iw|bod%zDSirFJZL7VMVTFhP>a z9-WSYH9zb?S}IBe6a@Uv>uv^y)@ABerd*hlv)k~}&m~$^`uQ3e*(B6e^t^9>`rYI> z-=-f()c`&EZ-_F-C?OaS?vxHh5ie>hrYpo^_H`$!2!xz1rli5tA)X(jUeq@yu$2nZ zn@kv+5L8D#5Ur{B3n@3N^=xcl8;(CY_ ztvbCzj5=f~4({BwZF;Z}nbkMl11N;3B0E4o@Y|^edYOLq0;9)se@@^>z>q*00uD4; ze0?<^iAAX1d*~=Ot7DI`>h(DD0c(iXXG8ZgtqeX}o8H?T{?p=+ zSpW5k8Y?>xN`-NZj36orbnt+mvi-DhIhlguu)3)n|8v(pb$%xsn?L^yIM$g_y3Id40DbFJXr#7bmCL zO9f^VFE&iEanU!F8RY?MlHyju}Hxx&^rP1r8?r2S=O z!1*i@zDdj-J3)~Zf(LqlV5<-R{MWA*VHHD(m1gBe-|oLJnplXalJ|MG`(K*AAJ~Fe>k7h)zR?-bJ!j+_3za4y%d z#$iKBxN_2dGlJ{6Hri@;x1Wq)cq5K8<{?=kl$}Hm?GdMfe;7Hl0+yvSB zt!U^^ghRQA`BTXvdx$nf9zFXC5lXB9S2%v_xa#42fg{0XKNcm-9XQ+cNNWlY69=(S2kk$roh2nZyIc5m|rfq8tBbv!Hz}c>4z0buPh9a#q-+r5`^mp$KPuz`fU!x9xkO1>Z0Fx?=sH zdc0}Jp?pcd?Ox@4GPX@3Zh37;gdfXiv2;di(VdLPk%;Lq80Oo14noBxTGJ>}EC<8) z-`X3bu8CUL`VSnpbyse4VLc%rl$g4Qx0vt@;FYN1j~#BVFA^>4J_V#(Arl`(u1DHk zwE^ERCsKw1fw{d|(^UvR(s`nL5D|!Pid2_k!-?wSE3P-B{QJZ8F!t}S2s8UWupy9D zK+qo-mJCjR`-os;q?mLE7F;<%lL4mI4znRbm-SP?oXBsQ*)f=IeHsl2jPEqt)??Kw z>4`I#y02D=cvK)O-+#-nTbKY{QQ=Ge)q(&}UCw>62k{99Hd;`>pq)vf>4nUI_;%M4 zt^Q(~vU*%dG`K)mNR<6y^VEUsfy;3&nYVnl-(Edd5=`^szFTw{+Rd;l{rNzuqb4rw3_c{nR2dd5 zooq}2Nb%D76NrlE2P>Fx-bz{pIV(N6y`JACJ)&msA$Y_FXFzZW)QoJ2q?jbGP~YG@ zj%YX~pBBt2!>s6n4$X|eO9&97-9f0AE!;$B-UFP-tv@qhM5C&xHWl5IM`W;oSiMPY zCqoVYvZI$dx2qR9kiDQ#Nzf>?ldp5tyWJE-yg8dy_FU;5P$Liy$tF26wx~`e#qAcu z^XfeSF&U}gPIZ49-%ZoT^w2RdH1Ovh--@%g#gM8uN;rSY%d0XZxs(Y)S>F)0xOma$Bn!&-euFqeCCZaL;ulm=;GAA{^IaJIW{OK{TUCg2}-nWI?pGBOj*}lEWA`-%L$q zljijB3Za)&pKB8%sFV*~IywZcvfd7sl+gZrBD=EZY*QRb-9j%zkCj)aN$u)gg#MS-B+R!=c>l5tQ*e2*@IicIbi1RjG zy~nZ*!Uo4BhdwD5G}bkJhdS`Gx@-=W_MEwv)aC!R_%@6Nq)G;xT)PwNfDA*^ggMIy z;x7Pl$i)>cP@RT0&_?}#(fKm<9wEB?c?3O~pnrW&UG^C1{}p1pL*1`&!Gl79`SZA& zMyX`k+VKXIsU6ej)joeP`zmnv$xBzYJ2G#J+aOo1_(ff7dsl-VdCuVUr9&vtYM>D} zwD8!~DU$dPS-DogD_xJbm;n8j=%1>s5#lj)6Bzt5Zq+KZ-7B?6oLA$ zb?-Q4oZsYr^pTutJ$-j@pwyqM<8JnixxIh4nkVF`4u-UOZOZ`ZAP5U^j`DJfE<6kE zUvi1tbd!XC6=)OJh;I@)87OKxccGM!3?oeq|IZxr``R^TL_gCehPf!#8bm z6?gUJF7tW7b3;Qh`ueX|Lb;|@R65m=T_m-3a)gIvfMh4W=RFr6TAxUjEoH5TUgY(3 z#?>MAg%C5>_e`#H<`c;vSgANf&#f8?;`XJ0$8ty&MkznFXi^zpHmV~$-nhYM9$ zfX8cVD~7fL*ir@B_sgJPk?l{-hXU3Eu2uKHgUy_|`08ZviOvNhAFZ+=8a2Ul!8M1} z4XW&9yVzs~ViC}>d1?>Z|z zQl7}8p9bBTROsjXB)Exx{D~16Ch`Z1T;TTS3WSF<<+N3ZSC;;^FUoDK7t? zdOiU5_* zfxB$}`-a}{bx>LvxwSOdB;v}drqj4Kv@B^ld2X_FTR&*MXOI?Q%nsp0aIll;>gt-g zy+qMZ%)eB-lWeHUt+_T9?Q%f4OPfPkZT9BC_%gf8Lk({9k#x>Q&|0}sX55uJP=$$z z1(W0hLd^y&tg0Xp1#N1gLFCSMaS4E&tIFqq3djOzMyW56Vx`+aq%L%`x9 zy?=0>F8ncJ%k!@ZCf!^dJ5e{4UGwK(?;kH&=hoL{XmUIh6YH;&k_zY;BXDDf02JOk zhsZrEAi}FOa_>ibArlS+hR>tPY$3j903?JqaCGl0E~qm9U6GvLYy2_$GXuCy8f*1m zU(L{u+D7mvA06LAtPs}0T^vr77R%28e0>tB;UD~E zRDT)@<*N??*`x9}e{5)7q5}YY-f!&!TA6=bg0eHl^3_kzp9A%4F8ls5dlCEs|7f+g zu;4^~<$4d?ol8k!nRdahGiCQWh@Ji0G*i-1q3{nvS_J)y@Zl^gh>56Z@3KMN%ww-+ zqjBitRu>=2mxW4%CXD_e5f;|uu+|HSDJ9z$Kt;<^GZ))2O+kPjnO4<0t3GqJljcT5 zz4VZ4!jI2sh~^);@c7ZcxJ9M!MJPddvg;cs_DlCGUQEvPhPf9zW`nIJOw|Hxj2hx= zm`dmwiHm8^Q6E95;Ka_oCk`=Nwr0i@?)dzJ;X(NkK87=8bQX4!|p?QDD?uI0$=RU5rWal$ie z1$^R=w|}G6mF&arEVi|<^$!54P-~p&q_d8V4zw&aR3#&OobSP5%0rx}TQdP>FlscaUplwCIas$(RzoGJ& zbNNEfrL4>dBsE;a{;#m?aoNj_>Fo304{ODqJaKC!udZniR+`BhHh(MMM&`r=@FYZq z`!HP{of7)5lnuJ$q0%bBnt-C!^V{-4ZzS)W$Na$PX!gcm8ELK`)$%}$Eu*14S?yq$RRbwC4gD2%duttkmm02y#wNlo$5y_!`D~dzH>-f z9Rt{!-O|Ekt5_@dqUU_K*BTt&`!r|QQ-u7q;&Xbm&O=4r*f&mWr6#pRo{hJ~&Y2@W zCnC7Yw*B4B_NPsle~*3WO8@PtpAKHWDcTS!V?;!W+R!HW*K5p8-J12cK0s_kfd4}j zGpj68hdefcWN|ZtAJ=D#Si@647cb9J_G2ja=cmppGx+)By%G@ZyM>lNtep0T4g_tQs>30+;|?diQga}9aG|$w%w*#;kS_2 z{X`}bc|NB_q?5t4tvC)PQvPRQd2Mc|U+? zZ3otA54?yuPcTgDr^2m0G{W^wImln1lYB|-Oj#~}OV;QYuRPllj{7cR0g1WFIq-J2 zBdJKQ4altxYyVqaOYvfU;tl=!9tKR0h&(Zr=cV25~ZBsF@~ElKyvkWwq}gJ>@VwUbNz1)09N<=DkBLEJYQ`T zfB4Go;W;%d6wu1}eAR|xbY*57uzqg-o+`)YE)H1=1n3P!c)-nbF>}3ln|4JdIWCTX zO#Vu@?wAEomiz-v$GFe*v1Id7UASG>H+2CQ=Ecs#JO<#xS7mBu#}HzZywUyQm&2fg z+g{)4?rE*ChXh!go$@0;YO|b| zqLW=uYDN@rR^G{p@_qV231@hDiqlP?d|vDNzrJ_n_Of!0bP8`t(U0D6bY4KR;C0l` zC}`~h2=xZ22;%%RjoM_eVk3JBN#&@IX4aM~l=H(cybzpvamA*<+#7HK_?g@`92_aZ zJJ0G)+Xbpx%J=&=mz(qQ03sNdqtJJ!7NUO~%k8Holp#w)h7iWm`6x*3Yw3NCb|B?#E^KgfHDue_ZDC^0mTpT@81WVD*d&-OQYO%f8GBFd&{j zm5)V=3jz$TNlkUk4i@W--JM+e&hf3d6$CC~%fDL{yyVPPh1_v@~QW*cGp)sjl`E&IBtXO!$K8>4iSLfZ8QLnxyAPeK!p+dIJ4(lqely2>2$gRf`5EObX$^HFq$hN&!rtmq}A(hXiu=ZLz#NHWn7Xm0baE`WL%@ zJu!Xm6-S9v)*Cn(|6bjy;6CraN5(L3QWGOZkOU4`>ENeNZZ0$v zf|8O;j3#LTmDIOJArKgbyUi!i)D1GharZ961MZlD8>5%#mNn`1hz+a41Ku^gHOSo( zv!_`=V%hY-iD>uu+WLXN!6UVLU3hI+@b}APW*q2=MaH*9`GM_v3Z5Glj}=;cnE z`@yxc!t!rc@+%3JC}6GdzhDR6dku#%jab01L4xTx$=>kWnyixD9YPT+TO>RtZj-(J z_%&UH?kxVf*=dvl9G9c!WGgGZw}KpYQpi$w#LPqd@0LRUPbBb1&JLPuBaqcYL_CZ) zdJL2dk}KNQ@BI93X4OFXN%oa&9j1u|XJ~L?>Z-f%f>4UaA*8u(E27pHD%2S^9TO>U zvw6SemR)uyEL18lmgf_ z#?IN=o{q1sJ~>+w$mso(+u_9ABe9=vPX=qq<>C{Tto7ro|Csk^z-Q|-UnSnj?vLBT zmgN4>6}J0qLMbNl1-=zuNv)Dh%o&6G9jCJ4Z{Wdv!+iOGEeq3uqzihq`csLmEE@w<@auOUXk!58tm3dYhCb8JMl;DW;Ol|(vW>IvFpi&4 zD^;Jaef(QC78tWwmOOmj?zX9bq*f0y<(1y=#)uwbnY+F3P5brf`(ir}AVVjK^$mZ@u9Rd@xxEVEr-#6h5kMWp>feD4;%OXSKb#Zq2)>rq z7g!m(D6e)lYen`TC+g4?L!sAYWH)@BZWphn$=3IQQwmIFS4cBEG}i=P{$x~K_Aitr zw^=l+FynvRcz=B)nMj#vSm9AqtyR9=tV6VkBpp;Fe^e1G$d|)aATi@7()fu&g+m83qCvK#!88 z{G*6LshoW6&0B^}lanQc-VEM?%Jj2Cp0u7eZF^j{Z;l)aLrjMrStKc+>~I`smv~|o znC(|S!Zu`o|8EfdSPL)Gi&0Q1ra|v4==@>V>xUI#Gpg8MdFN|+G>#_$MOP*#uUaFS z=01PE*G{e}ACMIUe$R=428us^JS_Kta#he2NG@`ZnWHd%pS=RnyPcS?+DK%ojvFC4 zOX=BL-MyM(pT+#NvD6d7PdE8HpmwdibD!>WOH5-#$5r3y%MG<3+Y(qEjdQ;uurc`% zpU($P_|7JkI(ju^UmNbewhlm(%wCl~d<@U<{z{4jNQ>mkaL;Ik&$qks#^+VT%R$9o z|5Wh@L4IhbbN>s05Tl2|u}0*Co~D<==`U*kq|{iyGcp%?>jy1(izaSCfsMP^pPL$Y zpPkr}w+UWINff; z!|lW6?Sb)JfoqAc(H@}bI|+>VLqj^`7RWuieA*dA=LqFX@pkN*pm$&gpEaaYa%!*x zKk#4P$H0Px`=`Z5xafU9jpW|^6#Sr ziQZ#c8hWW=cO0b$bl}7Ok2#C9H3ANHHgDAcZQ}v#&vV;Dxxdvsv-e7v+&5(xRMYE4 zcG^t5<|nwL_BK6J z)6aM`vK%X~{!WxK&GoCVrT@C<3?3NrQ|2wxbvPLz%$hqSRfM}!$J^F_F^?w+-**REmgb#a+ot?h zUPRPrFF7$_Q1baM6}-3r8dX$|X#qy`+s~i8IKuIozdzVN&2_6r{J26U#=$H54oD#m z+$YAP(YBJ`Wwjaq%0waKc%kXw-uS2p0=GF(nKgBoSSd@WN()wQ#QkV2f@{o+P?vAc zG;7lrD@XmpUup0+>;dS&ujFG|l0(Q|(t3!qVm>RNR-$F8)h2(X^Q z#{NV3B@{!-yK6?LU3d72rdnk44coV${*5Y&g7h-0o5dRGCUrMJ+1$|NsB!!;KX9Fx zs$Bg;oI~%Wg$QDcK<5j7@h|L^l!}13@ckyzI4;k?=}J=wXjJbRG!_?$%0?R}ndx|M z?X>+8u;^@K`zE`c3cN{zY;LM*l{gB3IgA*MhUNf*rF<5i5<0}zkMJzqw*Z}+vjlmU zBQnVGsH#QU`MjjDGpPLtJ;M&+JhrTAMo}%<>{{=f55Rz&L4dgrjcKMu7_vZOdO%)L z%me?X=I2V1RGqdk_BxiQUkMNcn`t(ZE`62XRp1<19f~HvLSr$^Q33Hkb;yg;U3#bI zfKehhVd|x<>ykg0*6W%*^I_3ykVF`UW_LsotP$ zrCX)1SS>SqD*f7TyO`KSYD{W>_>lK_?&wf_ACNx^xxC(jIo!8(3)K<|S>qzw0Q|oV z+h##tcLhKF!J#z~eI3d9QJsqb)r`XhenkPiNskpWZ*NQk6tK+w9-UI+ zjk@9c#I>Oeil-wrOW&d=KDUZTzZ-}Q1IVuvmwG^e*B3L(VVZ7|RyRcJ^!P4_SUJrl zu(7GhS%pOz+PAL62wdZr`_DsVWJ?@qbruX!yA*f1`eS=3q`Si(5ukJ8+tCZj7F}m8 zLnkgNZ==V%&AfOzgVd>n4iDXFBpLb5@c%zXe=?z`g}1WBd}T7(o2te9{Qt55ki(-$ zogZ3Q@-@-5-%Gz?-TKpURjbwf+DE(Y#?AiVWoNFKU+DJ3%7vCHHCCXBAU*VRw!ClS zulrX1Jp?e850hF@M`=BqzxLDuVz5^@dI=dhYd$2c-zbp1V8cwyTj3BxU=UXmff|xM zA%Y|mm}WCicMHdqfC96VbYmJJf3SU`KNHP6rqG6iZ@X20Ghm(H@qMq67{nS5GKXn? z>97hJ(C+^YH?2oX_$fr`Oj>b-4#5$%SM})&b574l8y;z{bXi^|HH~1v+B0$`D~UJq z)MB$$l~M`GLAn`AO6iae>7ikWp}vjx-j82A4-e<; zv-jHX>UXhUTb7Jfw<#$@l^CnYV||0E;;`wjAdlsd*?KC~(EW{x)s^-Mm%T8~m%Uuo zbjo87#38**a50~D9UtwfANh|<8^{VN;!PfS=&0(On$7bnak+^;fx<{gk3mVRYjE4| z3lPK1O2o9r7_N9YFLu(kpxAC|R$3B}sBAha_@#vqCF!;n{^fT)t(*HM%5qO9T)sCa zt}%2kxrsBLy&4$!LG$8&gPh&eOkY?P8Ez$CQq1mg&(m$Py-@}{ER{Dy^9uN>SUc5rA{L?8OpcmnnG z_3=b4ogH8axi$$kYnRIgmnf(h1h2zS9@96>yu$3kJcUt&Ii&ZX>J>)_V985Spqm(M zd`4ZhAA6}=H1pbcCh3FQ=rfT*5QD-BkKv1}M=fNayYpB;2%#>DRmxf4Eqs)6xVIbF zv?MSPs~_ur(R^(89-y}yD7Em>oM3D_ONb6+zV^RUD^+dA!(lrBx(jT>V*tr}r&@nx z{)vSRG!fb?vB6Al);Pzq>#$q@lYd5V5LBl{GWbD9Bq2)Y<@&i4Oqf^r;ecuG&_2ut%`g)c4G5kam_D!@uCV*zoKmCM3kus^mqX_l20} z!@&BnQy_7=YAu^O!*J&{}_?Ozen&*tqA+~?hgtIy^O2EhPBP0wUL3r&(V{#wo56r#Pk*+KV&L%) z)~reT5cZ-N1b)7^*VD--TffHimh}2Wx*HP66BPD|ro8Ou2s-FKwbwjSTINq0Ce;h# z&Eh@`;=}5DNH2Z3pFH|;&I`-fn&o$MB=A}9A3OKrmxf=uIg@I26*|ttnS6TdX zd?B3DZZ&TF9s9;8t89g&NrrQ`+3e@^Sc4p!(jN);2&i|d&k-Y`#b=t~Gk|EnPK?8I4<2Dyul{&jc!E|FlTcT!Rv3p|7 zaV$`fSJpKOLbSeXY|7Y*4PCovn ze>7$!j(utv57im!`ZqdPz&PnAlvI8<5Yc`0v544_c9+7r)ZSTVNhpzm%!nPhE!e_X zku~MmIw-ccQ-Bnt%!wWvMe%a~HLd(i#wTyJ^OwgLsw%TM&gKiQ_DYeI>&Gs36%~m* zDjO)Drr=?i$9f48WOVp!4o@a&>gqx z%#GS&UwM|N+u(8~fSoeBDXfphgC^6Dw-BhnqqJV+Jx(sBTVi>mX4<&hs8?;kt=;*YOF-b} zwGuT)7TO47Wr9>(C)EQ{ZQ-;>FUqnAkpr%_)yk&J;;)%f`lDEyzRpbE>G&=J1%zio z$5J@f<&VOTS+OzSAQDJ%R8zxL@tq9&e~`QiZ?IX4mc@lzMn@lgY9`;2!B`p{-(Dx9 zr(Jio=M{jbHoOk&S_|Q7qbF_N>vnfO=J^wYf_fzx=-sj}?0(CeORih?nE_sRwDkC; zqZA67%tB)^wUrFqzoB#nwL)9#c-si#qx{6XdVoAS{Ri)mFDP~{oexGb0Fg@oJqr?g zd1aoiC?W*^YD=QlcLmkH*2XSU+^P0o0(fCih^>7{K#2eLSq=D*jc^ZX>f+zmm>nn+ zbI4Z}9udKFL7?@8gcVbynj6HH{aUJU>gE=2 zIgN8gM}~rmM4D37Yo#9~vpr_uIAhM=Du1Z`h3jr;gV^bhZu#oU_#WU@r`Ibl&Q8@E zsRMNn^L#5^qqj-kD;?0Rtu74VvL?mZ3QPg@a5A`rMcb10lu;d&x`OSC6^Mi(OlJj} z%b_mj5>1>OBm)U>W0Lrm<;R`01fJ|`|H8r7`!6jg_>qDgdf4i%jHd#2$)aBIV<8%J5hvHO_MjEfEB6s zovt9tVlLayYvXgt&l`y{bN;)!+AB9#9}Px>q+ zi$IT!9J7L{V!Pxb(rNGRcEb`8Wm|H5@l@9tai2N^j6Nn7S1*#jD{z*#p4oeefz~5cch0k!c({k(0oh`W=T( zm~-v z;&mQ-$K=dM78}>JL51X6YJln2RgzjFe{a}hZ36B$4F&HXJNWs*nzFa!sP4KijY1x) zi9giepQ#Wa{~KJG3M|jd>l|u+RrwaN*Y{^}ur0Rk=;{TGe#)8l{oQ}eRST_lBi2$t zKv*Qp;#B*TQaI7^WgEUyhpCN?(RoCG^fjH+c3u4bY7GOvH z+^GV!l!WO&Vq4Jo`AMXafNSzqURb`5B<f$}3F@fog4Bl`L+3g^X`@yAq5 zLk)pTfAL`MGwAQiBDKRUsw&1VF zUTxj{m8uo0u*ihdC1P*tIQnaMExw@ZY>-(SX1rX{UZPB$@>$ZC15U%R`1MkDO90U(mtYYS{wWAol@krHArLP{$4lE zAH5NT>LxaR`tDWzq)-u{E=ypcY@Z@cB3Ysk@SXRb7iJxVsN7C-x3Nuwj?K?!2@dP? zrlc3#-td>+!Ih_#5Dw@&s(WfW3d*w}7&4yv?6o)0Q{1h#ffbcEj?mSS6CxwQ`%0Y_lwv)-+BopRww6&3iq2E)0&@HX)l#xXu z6%SB#fI9d8w_XPKd>zYmF{~K@qd#&5v0{=?bq+0>s&fL4e#OjkK!>G4f6mfHzxt{=>QVMCC4(gvil=>=pZdTe9`lG&9S>jiyj-CY`S|&+he%#nZa@Y-0}EgVs&hO{j*B{ zweSM9SRi>SMHRMyB@H2VFj67n7N`#4M}{$2WqGUK zo8FHEyswAQ_&lNqNp|??DU^B8;oxk8LiUPK?aP#iW5HM%u<`>R>;1&~R zJX=Mz*}Y69q|ZMQjJh^zq5x=Fn!{PL)j*Mf=y~KF?wfUEsoh)wOQW|l zGRdVEk3*4-7HC=U0VC4Y581`87OdmlB{MIZ8gkrNc}h#UZ%uL&0yffGS_xh1I3E-j zxvnv;pnHQhG!Lq%KZ86`5M?@&ZbjIGKT;z6qHiR zm2sNr7neL!dw{M*_j`8;0k34bz_&x?0+si$+0xk9n3yV-$pH|RAf^B9QuqROp=+{W z!B+Z2F`)upmg~Y&T$}sSwps&hxXqL2<5|S+=%{ttV0G!fsRf3((U&9x!`RbidXjtF z`XY$jn)fV#H_{D@t&WYIeIjXqh-UUSHCTAZ4ZqiXKbMl4n?klnRWj#xK78orQjdJw zKMy7s2A2eivv;w#Vr{FwQ@nIl9>2aD^*d__1nD z;+U2qT5y)vwu>?xTFFx3&zb}1K+7m(r# zKfywdzDX)&RI~I_8fhL9{{m){4z+(wO&uTx#uEv_^~OVd9`bFxydRuwrXY#@&n2iaYcO=`4n47@x2h?k;FmV{v& zfH(nv9pCC##V4z%eT8&mT0^DB%ea-|Rg z#OYCx7M@X#gLxd!@TlF)aN;4rN?6U!AYWbSuU%0&kc|;ZU70O*{6s%4t9`62DZT}z z{6f)Uq*2*$omZ9-{+h{6ejL|TpXs{(`eB?U!&evRDPL6tdYn)Um{FghV^ilAd(vdcGCdFP_U!%>W-p<$eX$fUCLM6U55Kv zzgaHmpoXhg+v#V@`ztkcjh)+NVUc7m1F^^~z^g074L-rj*33SP1=K%4y-;KIg^Rx* zcn~~JOOfB=8lmpy3qs9z-y>To$r$cwmXwrCR*`u=7`9l}6pjCgy$rMt2D^20;8fJ4 z82ef(rFnhCAuJ03)ND_lX9~ieJU#oawLGb2Y>NlkaFO+}joJS&knqF$wy0WNQXF$9kT8H_5Pk9pdqSt&-FI~ip&+9$aT`$2-lNPehII%q35C3GOXf) zpx@;7oM%n}0n7J4mir{TEDZ;nP%Lrd`s-g+X+b`Z0v1Il}N=U!U>eduNeHe0-5LEzcu zV)z{&pV9l!UqxzEz)X$9jtcAMb7!r16meV$0Vt#&^jZ!cq<46oVk$rS*8$uAnKE`0 z)SfU;_L1TYyWkYv43M{*_Dr!2!N28PDie>B{%jJ|`3}_tuTX%*ZB$MI4AHLIPTRUA z{k1EEfS{W;4$w9@E52{TS!-<#jtoYiuU+qW9Qt~6YK?B~+Trm0#oItGfFGl6SpSts zRc)3ivPl}$tj0fA;Z<_4Zq;@Me!_;+a=JzHCmsfaU3OJ8Ow7=Um4=S43K0Fj>xd$K zB?z8TNwpVh*dL3*_wlvax}dYormLJjg{t61bXCB~+eTJ3fy%{aU*!<7NK*&@r>>WW zpGvgBSpZ$T3CN@YRmfa?0<+Zc_;`mlQ)xn)a>&+~-@_}vLq&?=8u{O>G#ZQCC(u26 z$@5rJq+Q+uBDA@)gG_kmonLeE#>1-rJd$CpZ5{iQ0NDnuH;aoDz%&@{wH|IBn!0%x zLZYXs@Nf*?4T1vlz@(0X@_CT#el-dHDM3Qo3V(IhnfZa@g^PgA>ibvFRwvr`7}p-vx|1XKW?gNSbt*Lg5CfF81S^rQvmG`kZ24+PDpPrnzMKk7S*Up zuDe$uEgs^kWKd5+;hpvm2xNE9H|rYTR9c2W=cnX2q)Oo{8zhm7+!AXyP?-EEKESgIK9bR|7me2 ziBxZ;Rk3*2m#yNq$@g4g3t}8o2}iQ26^NnkLgWFp`P{7g1J5j~M%6{e6wu9=kK4bc zV4Ch_Bj(;nb(cu|=|KQrwM)ifoQEjir~i}x&iuL+|Iy_jCr$TDm(x?zoLrR`j<`>F zXSDZBF7*Z1aM-eEKUt+bkWPQE17fUO;7871rIao?`X*fQ9dLv-nbS)5)o-Si0##%4 zf+Se)klQx(WVF$I(7jsxo?fS^U*-A1alOtYz(Q^Y0E7bk^HR8s9=gV|4YXpqr9B^c z;8Xfw@&p>+Z&ThB80=waKM%>WT#PwRM&{jopPH=73+TBcq z75T94gmLp+)DW%AdC9uIz3LL?wg%lUL6vn)m5+=WnHCIoO7y1^$H&_TzoxtC=5(X+ z3Co#FpMGzO22RmO3^Qb5-Bh~pN16H0{mG%9jMd2>vu{7w_4Y^Ej*CLf7QJ~zDXbt| zo+dd)h#8{zZ?1w{B^_sX04kl(mAb++8kUvRSv)bALcxArJ7r<3tL?ErBp8=(;>jRV zkPLbzZkKJtLHddAkV0GaPs_Zx1fUq?y6VIbe?h^s?Gg|i2CJz4<)3fOt>YR*xSu51ZsE zuZx14xCMq`)G6Jnr@{d*$6&^N?YIKL7+15wUy~^=xM=S_eYT(HCf37O-R` zmWMSr<&3|(;~|YLciEYQyosVfAky95TVq^S?+(*N8c;G=-!Gfad3ynqFNrH3rOV=v zPh#90AXUmg)TEqwR-#xEX((icFNvCvpB3eJ%_M{jEQOC=g+6fAAi}~Ke$HqJ5Gtb zs}v9L-IgOmM(NJ}jcvJXN!1YfpMTJMAXIHoGl7zqdc_U#FMLT{x16PArtUhd6-mybMjW^&h>@4 z5sk;)*1L?QYQA4E`Mt;|2|+Cp$_d|URxP4E)gDg}d#<~+LoX!JaF?R;JM zMc9vbCsb>W{R&C3#>O^qZf!g;)R=RqBJ=e}lI#}x zbS!CCs?#-b@quAYRbFo&34>XpZ7<7^JKGp4Up##DOqMw|OqpA^as!9(7YQ_R7ld>< zD)8i)pk85?9_;psk!NSKdHzjKy|30F{JPfQEk?jUFEg#ZWxIIr~YE!m0WZXOSaeeVLa@73pur()n`E z#JU*2Fu9ATb^eCz6~SbtvVG$RJz@t#^bmhnxaWXo#}FLJfHXd>KTb#heI(bp3tP9T zlJwiG(GsbZ*<>b8F7gF>o}=}mbakIO9PV&$#(`{>*nJsNJZmqk$82diT_HdP*ly7B z=&SPoLgOdlBfkzI{q{#rv=*n&Yb)FzRCC>c{!>=`S@MD5M1uREpmD(B2Ng2&@G^#)`306DdBihdwqe5F}K z`pSFuexGA5mcCbs$qZMF$l9FS?mxyks~=jjxPec#e(d48v3hW9ovb z`!tvV!K*4*QPNlP=4w5vW0J`D1yoKx5VaB<(v61IKL}Z2i{y4^oqk8SV+{g+xJ5ts z==(m1<>xs1keYh?`%P{6)?)@LXRUXl>>0AQwfaY6C+uHjW-bZ-jrkt0O8vg?>T6C806-gS$MMo%(-$eeUTI!j`F?y+CUC|rJBsZ(cdK73I&Yvb=m+u7I$>*iakW=0$>A4ScrUBTPW#ABk1 zi@j|b-OjG`(BjVFhEgNh$?%dwuc4~Tcv8m8{aMU$tMA)MToO@|x}rz-JQm!mnjSVe zZbkB~uSE7dnl^S&yl2-e2kB+gH(8)%Rz-hWe@f}-ctcXES`(_9m=|qGo$r5sdfc

{A|;9X?og_I#&s{0AG#LpTz?SH{u4TL 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 z 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 z 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

V;xvu$oB_v65p$nS2@5H4~5+su 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 literal 0 HcmV?d00001 diff --git a/seminar06-planning/simulator/images/examples/dodging_a_speeder.png b/seminar06-planning/simulator/images/examples/dodging_a_speeder.png new file mode 100644 index 0000000000000000000000000000000000000000..5967327ee6adc3f734876aa0e3f58ce7e433ac8a GIT binary patch literal 156330 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

aL<{!Yb%OE;;`AQ)Ry+K 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 OKYC=tJq5cCg#Qml#kIHq literal 0 HcmV?d00001 diff --git a/seminar06-planning/simulator/images/examples/merging.png b/seminar06-planning/simulator/images/examples/merging.png new file mode 100644 index 0000000000000000000000000000000000000000..d8c3d17dba342b0de595e6cd9e525f365cd979eb GIT binary patch literal 217803 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∨sLW@;;&P%5< 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

Qy8L+CKtF(Ige?|tw^J!x$%=bfZ& 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�iUpt4#P2gUAeKCG(M0U6Iy8d;}jYT+7AeB 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

gh@kc*A`!cnQhnIAW`;x0WqWLjF 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%0Du0p#mw`J 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 literal 0 HcmV?d00001 diff --git a/seminar06-planning/simulator/images/examples/peloton.png b/seminar06-planning/simulator/images/examples/peloton.png new file mode 100644 index 0000000000000000000000000000000000000000..1b25ca3b829b3c5c8249b320cd6546a70ed6230f GIT binary patch literal 181740 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%0A}Ec1uJBU3IDmHc>Zn+NpDlR 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 literal 0 HcmV?d00001 diff --git a/seminar06-planning/simulator/images/examples/rough_road.png b/seminar06-planning/simulator/images/examples/rough_road.png new file mode 100644 index 0000000000000000000000000000000000000000..c43cc81d574cb1614cc0313627ada6f57c77674f GIT binary patch literal 216392 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%0AJR0slPfcBDKj}Zb{&}>by<< zLypYN?0@W714Q$$$BHKFSGOZhDletA$fH)|qqc=O`~vfz=sOgjs750SZ5TBRGk7P3 zG7UXSuRmt~a#!O{EUwX&!&kM_`dO}g?jROoFrSmwrZH++rUvPlcxVP1`;AE6XA$!Z zljSO=^uWv4#A|lwi>>f-@XmannR2}lBnCCTR$=()`RQ#4f@!nBLSE(M>Ks0M$2xO# z=|d{;vBrSl&0UU#?0w7v9hd_}FlD-|vXAQelLu`s{vpyO;Md_}3M0pfnTBd+^5{Py zDRK+A-CSWi-=WyZmVWSwOdh?p6QY-P5Em!Fq>^eT`)neFyJ6WwAKGv3@IkGrURMqA zZ*CYOG|22;!|IA}Bqr;qQ*d)@wV0~bj+zBgk^2!8PhF$zvqio{Clq@^_skwraamjP zpNV-zNkoFsnuE$HlfynNXM?HhOHDM{MJZ*n?5|+(siIX;B^L!bSp)4 zw3SV&`i*A)QlYhkp;JpjIR8iCHYBUOZ4kEY+VvP~Kb)*Vztmp5P*8`!t1SR_7Wz_U z*3c05A@7Z;)cg11EW5&hY@}r|tBXHqut#sx8xSHbcY5*oW9)Zd(dHYAnVIv`{t0b{ zc~7INEPS@{HNaBsrC=qI<%S*iV%W|znQ#8Z@2Oz91Uh>or_&y6BI2}bF@p9HWuntX zVq>IJ#B)vIk|Sf96x|E~xyp)6v%h%b{*EUOMRkeGaiEpbjJ_&SAtOfOk8Ux_=pT`n zB#7;;=`A;`zU_>@d}Xxe|8VmnlmV&Q4H`kn@tsFrlJ{)M#!qH$iOu@@!P(b3AEyC_ z6o`+b)b$UkzQAdLmW0{!SwYw77p$W4(9H}gg%n=e`n)%+u5Vslyqhd1+Z?dJ8pO0J z?P&DbC(^nU3^?3ac;8y6huoQu=niMOvza>+Xy*;h?!UQfQr9^0VXjuCa@AyW+LD_l z5x}_T;WkuT098IoLl%-~k zH$z|J`cG{|`cn{>Lo#d~xnNcqXMnJaW|aPROO+g#U*-(QtCTIVopI8cJJW&ieqZidY#Z}E|F;K+6!P76Cg)C_$i^d?#Dj)Ii{nLu5$xb0&bheU48 zp4=<*%zaMGWd|haq!VUwE%BJLlyF}9gG`iit4SHJl23Gguqn%Jkul~W>Gthi$xB=R zz3X^(ar3t8&!A`;N?RbUXQY?x|k?Pu2fFMfhJ@#QCc9#(`b%N^irE={R{?D(R z-^fpBDSIpSb)*=DiKuCAJXr;jsG@W6U+L`2<}Li-GbEKpcS12dWVeT+#5tBpxiQ>G zC65o~nf{OR&O8C$!9jB4p;qBXcL))eop9||#cJ!XP50Now2Yi!b7^7v5iwDCEPP2I z6FS*D{Y{mlJs(n*dUeNb$N74@UNUvZK$;Cb=DCP|481W&`r|Gl*#6N4;a*V3_(>D= z)UW^6NczxKW;FvZ)xQfQ`gI^B%@c!_V4g4UP|2FNdNsy+WrIWYsP{Pe?e0G6PpWy? zt`AqYvDJFwQ^tgB=Zi_8{UySB35s6CG)DXO$HsDed}wSc(+nVW;U<)N!i@5rE2 zb`6^2O|CCJ2PEJ7K6s4i#lIi7ps%s2cWmMK3a<+FzfWw_ODcJkQ6aG2qTu2ykg+m! z{@rF@Iiq5IK7DS@c1wN)Q2mR`KBmZBXKU=NZ}Y2v>^iqBy=}{=2zwE$C4x8>$_k`J9dwE1vKzu^4$cwn~zUgm7 z|1|Fq2jdD}eP`O|+N$D5?6R%H()y0Yf>ds{t9LA?02e(AUV}dIZw1JHnqJk!Q z;j~%@WiS4jn&<%3?Tv4&O&9i3uq%*pGs&>cgIP;~JvlN_ZP8v``C|7UzVkAjGCowFOffeJiAcwsT~=?a z3oVbQ>(iR7o`*a>Gw-v=Zo99pn5D@2Hem9fN8iYA21<23d`lfwr$Az^P#%%y9kHLx zx=V5_;5cLQFB)7CiQzBNBIX&HWGsVMGUz>fd-uw*P!AGht}U^D(f6;u88fesfYB+v z!bIvmzXwcGmU%;3{ws0j{9ipEhWRfmdUui$wnF!fx{4Fl5#A&9O`NWLqGfw(oS*gU z;2*&FBvZqbEfY#v!@3bA$ciFd5Wc2dJ6eN^wB=ngCLd0Vw-^5Dvq7p#a-4=yl=Cvk zmgdbP_U*Upa&Dr^$&J={giBmhsZI?%_N#7VolaD(yFwH4c{HDGtw%h|n7*OROsv=2 z?@+B^ zo&lw7(ZgbQ5tq0VblUu~H`isFdP9g)gVUGgFD)b`qmh*bGp!>5af{7G_E93s4@-kL zZ+;b@V#xeSRJRBoDY&IvuV8z9;4}5cBLAqt5V7_zyP<5;R#{}w3Gd(!P?6ym{)3G> zN+&pY{cKe!OZfVIic%O0gEPh?{#S8dGN}4F7u(CkCO%Qp2dP}CaWHDvUD#fbGbG|< z#8hyMy36(f{$jqmy3Va*@`1z$cd~E9x9zR!mB1lEWaGbd>d$I{4J*D)MUt&|P3H=CLmD*v zICJSKoAr58ZPeyXg`IJ;6s0wOS2*zvvY;B&V9fv8xZ<}{5+mEYzJ}z0rn!%eZiagX zb4$e!pYXa2*%R(Px&A5tT*Y8jnzvmE{k$fqqgU65RgM<@(>Z+7HaOc3Z;mH(=6o@| z;AULtw+{IFel<+82FB zE%tur^Nc39H3Yyn!Cz&Kz%{xVSc{ITovF_^>=zg^9xbS6OSKHNv6wu#m{GC(hGg1b zh3(;P^A3kll^ELa&;Xa{>LE=1%4S)^BaABRd1p~1;O$rhkJIm!|IQ!b-7X884wvvV zc8|VUgQX{*cDKg|?>qWO;Dq!;b<^TFW*&UD9vl27n3<_vUff`%{*7@Vyrzq>ICZXt z!jL4#XtLSp?xXw4%@Jpg9)3&4$0D%PJ(*9}y;-a`Om|mtf*KzTddZlU9i{2x# zsmZQxX-dFu9FcQ^cBMc6+neyVkl*qOBm3(DpbdR%vSy?7?Rzb;jmAc|C$Cw`q4|7o zjsYy^+*ImQ?&aZKCm{XY$^*tHBKB}xr}h@(A+M45jgy4k+940Jmpyll_7Px>d#6yv z2S>9D%uAcpr%*Q}5lIu=P1&nY%@%6oO!u6H)ADa#O)tM{21R+Fzgkz`6E_0vXwkx6 zvHkSD(cc=tzG6Z9DKZ>BX?XQ;)d>PyS_lu%Q=LZ?o=?b1{*X61d%`7T;10lmeJ)f3 z>1-C}lBS9&IPYaV>Z(JF43dxISZT#*8C)tC4Gt^t-v?Pn`4bE?wB#=QXnFS9T#8so zK~N?`cLQfKU*hkg#$Adu0k+Rm2%tA(G3{ust7k}^KT+VoATs6F}Z*+GcaGbH=buB z9Lo!t{ndYss&Y?R|BFhcYhSLJ+M~Hnm|`(oAZD}6@BvWSi~&k~y8_fcav`nuUAY_! zba#*VJTkactx+1$YSJ>Sh^nCBDJ|gIK-#}3$%kt#`w!P38?XZaM%~=6Zx#8z-3)Zc zGKSW*Tk+mTLtd;?$+s3i*}Rnl01j@|Da~bZ{OCNxJN(S>_-HCl6C(Xps-096c2k|( zsO)JgSn5d)@od{)XW#hVSIkI>%|25Gt)Z#P<8vG)k1L4dihg52Uq##9>b4bceq9Hp zc46KiKxZ!SI8=6nwXZCCBgkD|BIJNbD2qTvJooWtVOfn(DaQMqmXoGb?`-Yt-2Q7J z(JqvsEZwLFBIh$0{b!2@25cXZn>s|^j(K0F+iXvC0?d|r!4pQ9kdk8c3Z>9b;Ilc@252bDWG!1d3~7yMmcnUx9Oc zyRhTdN0w@abBvt;ys-EZnpF{GNXefV{$g4lM9J?>Y3N(PM&RUBU* zF*I#)s;_U1gXj@282M*jnEEKWLs9iXGKCzx9D6&=ACr1DJK2Wpvyv|6RYqZ2Y2Ax? zp{PDj#%hQ{{Hba6f!JKbhYN9l$*aI9DjR<>GDE+f_;br)@LY?$R;$G%XHo29^I9|+ zrd5GG!}m11r^YfXa48f-t_XwAwCLdGEpl2f^2m69R}5M(>4*j;4Mb^WmIK|zMlR{q zCUNDNwR^CJxxTA0_QUFszB-DoeH)UDA8ec5|C-C%H@Ush57*63gA$y}@mX^F8Y_u7 zVq?0l)WN9WN}TyMjcKoh$bvhdoOeca1;Tr^biVHO_xhPyoza;x?8F~f5&p-6vUH9P zXW}iwy^MB_Cxfn?{MS6?wVs<~wWGaCL=Po~&H!4Yd;XF5`79&8|9BhW#f7k}TO264 zl+p}rT#YZ^2{FB{{0^VIVNMTI6jb*km74HB0<|sH#T&@~R*YIPrEnLq2$+|P!+~C~ zC!Lz&7|0CPHs5=1+h_O~Q|Kdu;alMgh&L%x!2LkLf0%+S+%Up7QD7Tt{FI3gM|3p~zbQFU25bu7_Pgcv_ORQ?b%vHrRO6mte;7RnN41}Kj(eUQb=TS@hSK0m7xj4+i!Kf$Pg(3t zc6l3}n8NbDbQk-xzlwWMjS%_#Cv_V{>TQz@IZfMo6B=qv`NW{{IzeeQOY-|QV zR|9BtfY^@lj^4cIV&xvuMPUm;yl7Mx?x8vRFi$?r>~hfHmV>KNIZ5Gu5T5bX9SOWy7jvbo%UW%@<17b z0j#cZhp(}oe^5AGDwy{x^3td_Gdf^h^A%z9H3%l1l1S(eIN_3Xt8?l^F6xuYj`K*c z8kY_RSWeQD856%G0y;fwJ}!GWVnOOdk(YiLS{R9l!o=DZ4dE+Kw zhYp9xoGzwNi1sh;h>1wIyd^G1-?SVM52qP>e?1oPl6 z+kdc-FlCza9E449Pnc@ClSrJ=Z2595^O>v>cTjRs*J)Jg7#=_%ZqMc6(iwI|u4%ot z#g5O?l%wdVhc)Hv!`>Cj9VPM>M8|09Iw#W-wqpoe4$wk9tjpCoL>o zUDL^Gt5G+B1^Qm660hq3OJVg|;l*qp4Fsk71};F2UODylUW6)jJUTZ~*35u1jzCH7 z_%wg26ux((4I`}-?cj6Vzy9iK#mlWuY_{r5R>12YUczr>mn4E@Yv}Wheoiu|&vnv$ z17K;T+@XTc5x}7fMY($dclsMm^kOX3%hF{DFMjTLs#Tm9vi4{9A8?y$$45 z^v{0bnPy;FftSiNP`{CV4OP$m@Dpcf! zd+sl{c7(I#@mOXt)94ff&aH@pZAr)@?A4d8y_b7+Tro`!t~vGfp`m=8nGk}#TOnSc zRaf%M2D-=Z2x{9xlKxz>LG5>!GAKo2%3#9b;-^tD@-ELY%E(CA#P>TT=2|#9ZMVtM zw*IU{PRMd?pB=SVX7zJ*VA^$S~NVg}2ah zN3jGkm6Xc|fvJAkZ>}G9f0aQz5j9K7#!YRY98gWb6A9GVcvm6nbrjhg2yiE@MH5ZY zy&^}#6-~GhXF>fmS4)R?#Q7(4YtkyvGJJ&Y`N97Uwnhh1%B3i>1$x;HHDAmPEbBjt zd0%m7)p7@tEPX)J#gZZHOa3*_g^~ByVC>`!tw!$K9T&zrwl`a@7!~y4*%8YEZ1FVk zu0xcv&q{AXk8OiR>bp+Zv)Q#j)G(!Cw>HssHc`mb!Vz;nPzogSRB!b26VM-r{>p<# zf$SNuadwn7&ezf486dno#R<%pC6Fo4j*XXneNJw5pRqPL`bseQm*r$@SBQ=eYw6Zp zLetME8O;TRn^WVt&xAzZyC0eA+sjMdS8eQA=^ z8>&Rxz-y-#cYKHXanVP=m3wr&|D#_F9}Qe8HY^ipeKgqLRROExfCv1n-$0EDURJVE zKbnTlT))3nNKax2YzC3){Xa$Zx!eewX0Z#B!}a?O-}eVixNLfh6DD(;`yY}bcUjOp z&>;{>kyzRfW4nozP>}2A#e=OU2Lrbe<#gef&nM(7HNg12AErXdRewmp5c`A+tCorj zG8#v~yz1Jov+cN{{GXhr0!z3T2gIs29~R`^1l$1?WYKJ2u&`#c}T&j+&ze zhIM+M@hIv!@afaEwh`>_c>&Dy)sXD;Yxc9I5(lJeGHZqouGU~42mb>%9*3J zWsj04{S$PoZ7RF~{xmbs3=kf+Vc6CLAbi&KR3e?OK9iT&)&_S>^LIf>qZg)$*fp*y z5IFfiVKm)_MKN66hQJne9M9&I8ebZ`x*hPcg@Q?(^?c0 z5i2#u6{bR65-cZnLVikrn0ZNWp_KS&Ey#hTv_NXw3tw+rf|Q zuyXU-6_A#$v4Gs)Ya=P6YmTFiw;P|R(SYik2%#z+W6`b}#TX~zbBfFL`BHeS5wOYD zJYg#$`c4APfm*|*$9le(W8z{nYB!U!w?Sn{tkphfoYK^s+gw5LcTw+#I@+w24QmFj z{LE8uG)S;FkmE}DsMyT>=2bMa{5fPboLR)G=p-qP8!uEv23&HYgSD{Gv&hsEEx6k0 z{0xcSzC_RyM)OFXc)L|15rn4WX%?dEmN-z#FqWkyqKPCg{9ROVcCWek&$$W_QfPcs zEtx;~0-t$kLHn_XYho}oRdu5wOWU6Ecq9Gpp?|*!LU(WM-UO89yuPi9izUl4({vxB)CBARTUPGUgFOB61pOBHMmi>&1w?wJkc}{YmT6;EvlE zQHSS}u#B#+(w>u^vyY&UVsuyDU5yL>CsE^4+4&8TIFeXKe?aMWAhGt!Xa?uv7yjj; zpcr-Bingr1x|9m#m*4R9v+n&FomQbLm82$5=*OW|D7r}zE#d!g;Q~mrtf;pf|5cj& zE3&Hd)XS8Jr#8z-A+8fyfd(RwP%795n)>35x3VP$6s4uL_#m37&q3Ck~h4%lo^xj|$khmid!FbV$nrV=)5ncu8S(=@2dscp0J3dpNHoQRe-aSs%T=>deS zrg93Ztlfw!HZ}K_Vzl4lCvwMOcDfbzg=9sv15@D2W1=BfdRJXMw!^P30$0XwYVGP2dXT4{<}a5%GfX4HV}_+}OFAi0Q)q zN}tmu4Ub?#vM|K?#Q5av>^l1h$q)7`hdKG2z(*s1@uDO(B-aNuaj6SkbgKYGl*(+i44B)ba?P^XD$`#w(*N6 z0ifIO*}v(&%_LjNG||c(T=vjsTYR;+L{=2%sJ1B)itR#CI7P5fg4w}I&gLE-@_tv~ zT;?dcL?$*kPpwoiT}0fwp*Uyh4{B1{(d?Pb@`u8?!xizts?_rm8vlco)!ko02hY5Z zcUm@GMMfhjN=1VJy6XVfa2rHQ@l7hPC*;U0Ir6e(1M*VrwRSl+-u8RE)}qDd(4yf; znte5ygpd9}LDF~^Pp}3#$oGIiUPSholg)(|?Jz0tMATuTBz9lzk}nej{OLE{P_h0F ziUxyXKy5@W5mX)M!EK10OeXzgGw=OBWYny7!4ePOHX(@oY08nZ5&$xh9i5ZTASr4y zPF7xS2=KbWnwxC6{L?Ij)G!g3P24>xv>8Hs_p1!u;}7rmbjzQ-_Nw+RB}bS!YAcCi zAMrg{R~u|)W|MP%PzApzYm#Dw%`8e%*05rLg?uRohBieoTW&IFq^CnSru7QA#85Q6 z!?BYl&9!I>k_iL7ma`YNK}}9guf2CCd$1`%j%-z>5d19CvZgB)e+oAo@ndoJF<*Lj za?ys1Lr90kQDwI{9z2-kYngBD3b0%VoPC1Y^oojn&g%Rom*4d)_ao1f(>ufqJx*UlmU*(7}Z}6F_p6{u?2O@($F@~$M5KV?VMmA9`;O!LmODW>zmOy(@ryXM3 zek0}mw7-SN3*zvd>>f54#FoXaStH0V6{{{FUnKMEBXlP`*HVc#n)yuu58-62?e?9O ze2>;6_k~7k85HHIzvU8GN8C9B!fCGHyOxaam}l1cq|`lQHi>x1nG({s<0taCithJ4cq*39ARrLWCEU$6CM zo1%o5T)NCz7SQZyJw=(0HyZ_gDeihJSo*&9l^}ihW20Kf-2Y(wvE3ZUXv>d~i51D@ za`jI43=;5idrcNE_gOCvE4z&(5e(cuH@VwBM~w zAbDltS(VC~p4!v2wtCa+OX5Xgjg7eE;YS7qJTi&)1c;!)4oNPI`VhQV_P5QL<5x_B z#O`u{kuC>TI&bU*&`IM%7veZ$&)q$1@NlS#kQmK6>Zusb@u6#?1*(LemvXgkY;17; z&l&0bxYv(FOU>J^4m)OR+ef_L!Ws;h)dbNU= z@A1N}&4hFnj}OtVhgA>yKbpS6Ay45~oWu9X#s+xexevw>%l%&0V^*5F3oa z(Y0k9Bg22__A1z&_c0J+g7K*yDd>FyPfzB6Uk#Rji-|amLQjY1VTBB|&@1_`rEtjQ z{eAI>Ace28-2~kwr>Jme~EfveSr}V;Ci|e zLwqQtnk9b&`YoTFG7CPnb2FD6Q*aGFkPl4o-au8;8{9Lz`1v(kH^U@ECDWBoM3!_M zw%={QpXl(?=R;grfcTQ~4V^dO*b7xuLK{`wpdb#&9-D6KalWfWF&Rg5kUvcdE4vDE z0UZ1GzM@pUHT`vCA4bl%NAt`L-Xj`>Bds5%jtR?eA&d=4+bHh;=p(B?DXhq)<=L^M zx+}f9Kizk%o?edU6p$jiE0t2D456goXN4$@C(4ks)OkhbVLrlasjzXVW-s8XFyn}< z&Cs^`_GdN!1^=&ANPn-6-?oxt?d=n{Qs_`Mo4)y;D8sQhVwcBLgRMRB~@IccOpK_PPA8H0C2Mw(Ejqclb>d zxztGT^}oM)CzT-m$qp~l=ZQXphg;_;jdWhCJ~cqD{cDHCAi9 zB$TlH4pP}GOlx?I0>I7UB$yBI87j$0f{zmEN;2e=-%ti{%`>8EqOHlzORc+y4lVMU zMq>*@T2uYReXn%y{u%joOZ-p*lBo0e5$vn4;aMjoZFOL}fBggZT}&SR)CF3Wx8u1T z0Y{PUJ@!9iI(qN+-~o>BzdRiDHD2&?-K^7oZv=}~>wL+(vLL(woh zxO}B#a%JH{syU5<%?b7Dp;kxep=IixOllvkvJU9?^e*L_GQxAOw?xc>YZKc)t#wC~ zw0W|tss31!w{~Y2U)kek@+GwaY$Wx0YmDEgIf>7QF6@8J6fyMXTXB+J7AHuqtfE&7 z-(W3CPptHch2@iK!4yv-nGe;!B_-o5`4`gu)8OY?P1k{wWRq^6tUl#4g?ag&Z3cZ? z{kv#Xpb9sAB&|uYlYheXT^@uIa}TT#RFbMLhXZlo-I3N66rxE?QD`D7L&xbVX%TvGG&ztJhe z%1Kz&6Na?yoMVz}&ETRibxHk&1-$Rzz4!YGARdQ_qQ>>BK0hvXWCG@|-Y&GJe{4j9 z_A_!y5yB71K~406Z=|29_k+ZmS?>~H{w%5~35?(QJ4U-TN#FfC4qY6Nuz%$C+acq+16lYAa_;^dwcvX_-mYSUIa*+>qQ8-ACI!D(<^KS-0S|L?W#PEh(A z#X_dO&)u`y+3P5~kIX2j4It8nNP@2#gOaG6GaeO9A3WWSIzmUGen4@Hc1`Im`JIt9 zY$t-qLJ9kV?yI`GB!SnU#RC+uOHENA7XCF{j==a?9TzDJ1Gnw|52KItUvoQKyH{IZ zaNF{O&fW3&`1okqQB_%08CXO^ODB`d%(ip5V)*&7BVEz4BHs-#*keuo^7WB`gF^LY z#1eiqE~Et7sogVt#QHK8S604s;Y%`B3@=>H^#0q+mvj~uu|=B{!Z>3>1ks;Y($l=_ zh;I=cmE6Xc4xvjVRMmJQIMs3CI5LZ-E|9hwpSSJu3jR@c<+1Bq7@A<#TJEf8+AjMX zhF*41pF(YuXj>YCEH15l4b`Z=5pVWQjrGz4>ycgB(sD!QcD0nI-886x6$=GuoBmU^ zvDSd{f8BkN0FOtlI`6vzAUnyVjQ91=Om+TTXEA%?!ennF?u!M=T9Q;=m7w3&kDTFd z-|=k9KWb5Sc3G(yI|`%uguW5m$;S@02eV$a^PmS0-EKURP8EEGMBRSB5z_tTzjg* zJC*{Cu6NY*G+~#tCODkjNcC0iRs3D;3TK7RUH>Hep%sS|Op?GrVDKy{ZjV_1c)nFDvVHq>4~Z(LFd}>I zqF5?3_eYRQb^dZY(}>eU0JMzP<(jwU`Ov}w1O8!s6$=Z03Et91(&Ym2nlKkxlF zvMFcjr>x6d)lS$pBjq5xvY=}x5;r}v`}^RKm&>QZWAELk14hWd@Ngh!lk*#x=SVR< zQ4TBGz=>nGK8<9}ZkN8^)xF7C(rK}4c>~wyZ9t7PI{W??0gob}xkb+-K@0OMn@y~1 z!@sHo%&9+;qzb-;NJDD;;G1){w}VkYYHH{?R3JDy?A(27aT@$ll&jO^kwNBw$hhn( zy0I&ONb4VE%EqxgdQRgZx*}b=EIurZSa3!s}t415V#k z%co)#OOrMq)xYFx3+w>_ey#qhBmpbe3Swg^-$FDywFbNN{{8=10Jb}AM@Ki*vDBO| zD8$fv~wUZuWZ=>2e8dB}C#uDnyT z7&Dd%;Z)gt3mnC9<ttKL6PdNLwcuQWM>C7S=u?%L+--RV7s)al<}HUmKyANoe|C zc3A$ddBRxK!e00UPZ@2~uyq~IX_E&NhrweK8a|2w9a*OPXau*}xRr>{hgRTS&wzi7 z(!m&3X;pKbA6_u*L?_n|M7i)S0c<R;N+_d9-h zm3{WQA&RI4mm&x=0S=Z9sv3hDG~dDsX6kJcg@htkVbeEx9umq|VDFN;c3aDBOYg-W z)C@ww!_?GEZ#fm|VeL`DmULbO#h)L?9BKfCi3#YuFI{` z46N76hIMmL=q$AsAoj4v0lcQAU~QILNEG-%6mI1D#G~0DxQnao`-J6MhEz;Wf z>7$;KHGmj#hveBl;K4r6S?ZsRgYgZjCbDR#8R`?yL*RmL|NBCd@@86N zcJi_ZLiF+7`_?%a2;%L0>IDAVaV_Ys2vR0w1{+kwOh@zoPQmbCf8-=KjCG?8Ese#3 z6ha}|tYhDR5Q7wPmI?ut)-;Thjli|;Y$JKDWYktsYO=Ozola)n9JBRRg6uoN+v}9B z+{`nRAd?mEmls_kA0hA<&>pVPnt*3SJt~QVar7d-VEZ(nJ0f&88eK5QPixnF-I~3o zDocy0K(x=R-S(^l+5-aiDopZyiU-){~PRs-?=b^Hra=tS?fje%HK7#%^v(M{zPdSttI

AP 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 UICGs04gB{|N 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%0A=5Ox~sao0R-oD=f7 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�(FHs34u#jkJZ6X$-N6BrO~Rc~AgCJF6Oq*i~|EG(?50G1K(hkHA9<>clu+}V4tVy+_Wb#Km<86{)|BCR-CKD zL|L_Ce^cyVDHr^<_|@zClPxa}b&`Ur;hHn&w-f6+DWR;$H0vDhywsN2^+jayA~rrZ z)FJ#}Q-xHO*$mrd*h~;44%hH%q*Q(q;(-|B zFwW)9EIvem!diEEt>L0NR>Y!c^6B(0rqmDBAJH`8+Rt(?N`@&Xh=Xez0B2w8SV{{n zi3ReK9Cfq;Lng}#TRwRaFj|9<44)CZrBU+zu!B;-{%7qT_BQ>Tj$PtC@Hss)W< zdPP28Zff0x(VyK<`HcuNw`{F1yXXM8)UjlsN z4Gp(yV$sx?ginhfft&t}pBjc}(!+_c*z#Z}!R%(*WGdVu3A9!}5@EN3X-6GRWpBzsM!&CvRI}7zD~_5dgimulA7X?6*U(1OkoI^+P%~pYynX_UF)JwGJM7XaSa(-V+$4w5 z4Kz?E$WUZ!-B`{8$KJbORAdd)8(zvFL_))Hg#ejCU-whQ(sa6UI`=FIA8CnXrhFC- zx!1$zOW{5^lKWnl!8^}^jdnYH=@W4ZWhyxTRl(BYGl=eAoOA8;@Wnmlof+7)LL zclDpn-8=p3Z-d(lT#_+SJ+S41liamv41ZnC_f%C3Pc4_KD52cd9h#^zbIQF8lkJFJ zd5rJueB^Z{cLS=4o64;zi1yuw3hj!WZ9PKMMXT)l9KQ;N6eO4(2;I3746Zg9BZy}t z7XX9ku2+L1y@OJ3e(O87F}qZX3)ZM=1}lN92FAuY@$r=24kKgtm#87SS9GsF0k9iJ z2d)w z>Qy9R{9g5KhyCl=PftcmLp8TsgvX)NK;g`H-avW-M&YSeBi>^TPyq4f_E)<1;C|X3 z3+elRnky@g)53&9BWYq0Ynk)$J3a z_lc&9ZKV822BP&j-K9BE&M|>37tzp`C&**SMW`K$;bVHfXJ?o{RLX}Ao#nzDs%1VGAjo7p zcQR3l^-;c&!4utXLPMRuqGjb*uYh80FxLqoS74%Fm5P&ZzX9KrM+NP~Eq1BBwDDFK z&5wy6(sY#@Zvh4kgzhvR2$b9UttJ8TTBWFfQ^n`#6LR%@Apai7G!Mq}_3@-$uk{aJH38i~2fr+SR1xQs1U2ZqqL2iB>%JkK zf|yr5u-cWSwpSTEv}GXDC(=u+46XQmg$(rY*7R=&lIo)z>YQ(C6u511Uwn{VdiGc3FYXDl&OuKlfeq z{-g&Cvp{T<;wkFbQlP*|zNqK09jPd2NeA5S+7fefJapxSk2~5FCN-Z7hl~F;`%-*B zKNIn?L|IV4)r{9@tWNX_@IyVL0$gKZ*#0I?_L~n#H;AQ3?v`? zT{O8xC&^EP+}Q`Hoy9;qY8fJSTq*tTW}SuEx1z?MDWrvLZwCHhRO^58(qU(46=@rH zCgEVfWEpeNQDzTC2dT*It%Lo}(11^U5YGYjt?py)M&}RPhJC@Z`%7E*5mqtp=#-!1 zAv)Sj^`Du{C%bxK|1FIB`Y=23sb)hZ5K>%7brJ$F=Bt48Iv;~#ANf{hkcs4^*C4)3 z*U6o#k5GS6ct-lb5Szs)bTw1~d~DzMuZXzK6AcR~EKg?A`I!L zq^XOv^qcqWjXJ3MTeTkr)>&c~NC4!$`6L(5YgKvIcw5}=uP@rbpPkI@f>2jd5b1$* zC9^>Q1DHBG`kXVY|=EU?z#eL5}ZbYIXZZ>uXnSOKIq zAzq;iudvF;$oMP3CMl~MXR&>p>g2o6lZ5hJJ?QOpA^RAKLW!5;WR zu)xiui67S=8a+E!#ZS9T=VE`$Z+n@BlBt6nX`>$TU-YTL0dJO|6EM4r-}G(qb`6=fns%pVqdhJvM$I(& zVu(~i;H}&=se~c8{&63U<8yoKL`|#T-I&q$OHF?#MX#opm zDrx9}W9flT`t{$eF#BH6PEEW3dniaFSsf}XYpr3Dv*4s7BNidEMMzAnC6FBQ zMaNLL_B@!?%V&`myaDtu=v;BY6eoES?G2wuVtZ{#D1}C-v0rYmYdzAF#ZnVY zfeWb+3#7U>#Xd>k&5X$cOQ)%fXB_LzZd*>vx9rC-=D2$JUbWW_?=-1I6b0Wc3%#kb zoE`{?mYHP8xnWt%Y<72c#WjZbOw>-FD)e48gi7$IM1=^x&CM?XWM(Xp6#jn&2@Kwv zIv_WdJp{bkivc0JHoJ%wCM|jKIZ7iYSwDH;|6%Jb!=enku3;I51{qo@0Yy4gKvHR> zn<0l1QM#oYDJi9q5TzTW8yS%jL6DRfx;q8^&H?ZHdEWPX|Kf2tGuL&VYwx|*+Iv?y z5<_fnw@t$zUrbP{&hP(h2POCOaUCl3CTKqsi3n~CsC_NM3zQm$u{2_k)^`I#1eQ~D z5YoE}|G=e)Eh>{Hl%yRaM}nhVMs4K%Z&0ye{7G#G@P4vzu1ww=Rhc>KYh3eVuGl8x7UyN=_y` zCg+Bmuv}c^K_Horo}RLBAyy;Lrb){`&>5&`SOGD)L2Yljv%_7+Mw(Bt z+X)>MnY^EOOBf9KJrg>97;|kGv0~f9i+-PoNgLPYDT<-+A#uz*LjyXiQN(6(>5o;t zQKfkB%!hO1w^m1)5%4wevZl0E~c+rMcc=u!9_Zy z`VL(H-Pf!ED<^y_UN-a}X<&=7-uB%WjdSxdT|7_dK1d?{fdhdeHY6|w{D?nbk;ra@ zDlP5f$6Kx4?b%PrPL8&?C!GIcs}drFYGwcaQf*k&X}1w*=t}nrq#Be3!0R)Y`A6$D z{luVNGpT|E0|bzzBvH0BAL3d_x{5Bo?M)t>Z@p ztOu&l%S!1&JPW{LRixfo-(SzS42Gws%t7W-C7VI$98L!YNn{GJ9>x=OW}0=iJ)MYBh?+-Eo#UH@}(f9^Wu<3fUGH>-^U?M2^Z zsS=W_8W$ST@QX9NgO+kHue8O?jfe>IDtrj~P)g~s-G_i5s^5g3qh}&!!f|TQUm9I3 zZZvEjeGYm=^2hc@Cr3K&)`j^0M0t<<%U=tuT^3xvX&UfFa0lp5!_`6BGK~)wI6zC) z(Q~rv&Tco~=Bx4P8!6)TwWDq2b(JAZxcEOl#6M}qd-W}_iti2G=`ZeE83*h_4VnAa zAXMyl?5?WY&gF$)Dd3`(K}QP_18~#73BK2hE8EE!16-5d#?}COXmM@A*$KSIQE6dEMfk<8d$t>b*#}B1f2mld&a32Rlh2DpjqMg%JKXD*$G>=7go?wh7+`28z|Ya6m7T#u z9GsUYScRBR@=0%iKSHXsc*%k1fezZ#NzFScbVVulkGo@ow;(=MRKp|jlt_HXZCMc% zr9vFTggjSKn%-c7dmbYd9hpCpL66utYtT?sni%eWIZ zR)2^N#(i^Hn*$k!A4e_4_~kx?k)i)r9uRoR4=w|*(7jud+1^M0R1FNaI zs^>)Ftk=oG-vjiyZx8?`mK}mHBTTlPC&TF)h)Jv3C4|_rpmUeod8LDKKLm*iHwkX4 zVS;JfryUY)PT%nPKP%79#tiYbl5PnJr~d+Fkc<5QcisqIrW_g(uAvdZUnVddJlYcG z@2tCPJ0YL>lG3e9c5e_t3t=lOD_L6XGF_Pro(^7?38_aiSJc!dM-~+PbN-?aQkev7 zv1fo5yHeIg3V@QGVLICr^Gi+C;FFm!PZyV8B2}a6Vp)_AH@aacr=0< z)jvxkT9|Q>Xu7Z2?ks{=?ojPGFMGOwLZ^7ZLd+tX@)>niU^1a%-63JJ;7V^H0==;D z`TjW6Hp=D`K^Sj4xC+VP_`V|=FK$xpiuC74-!!emXj(2GbeF?c2^t5_D(W_PR`6Osq_()y{z{Xr!`TF%a=&Uy$VAHDJ3N(YZ{kb z;}w3lKHTQ8p|cq$edU=oBJx=El+r2-7Jo&$yM{RmP=!jZ0~swcNVQ*CqG_)Q|G6#?2FS|oIsT}3 zP#j+jU)($E{goz0yf4zVw0fvF&_4)+eg%A59;^&d+JTAa!QkIv3-54cMfmEr(~Zb5!*QE(t zI^q8<@boA~`{pl;lZt0zTGzn9b68U|CF8o&RTjntx#ajn!BW$anCrJjZdp&y?^`KL z=fhxV$f;E0B?FLC0cbG(L>5nLB4ETk`~90OL803=(5)k(a_OJMGW?;4BN7fUqw}W( zd{}KfLi}HitbJ!6TyRPviMC41pf@YvHEGxXw8P?z29pwfn<{TF_=~rp;dv~u-4MX@ z86KZxQwL7K*(ipXAj_;y9V+A2O{TNC42Loy>@<#kkXl_s-w?%Y!S3>L1t6JpQ&(q8}{@Brxy*C3Km` zzzpHEkH?Eq+#tduB%gzDEgDlp~s?L-Wj&N!PFi@00^rnJ706vYv}*w3nVLVu?2T zFfP+c<5*{yuM>ix`Ii)D`f0N9SxRJjK&W!YUGWz=I| zQ0$B<``6+*sktpWE^61ANsawp%QK!tjptrr42gB;193ji+hB~ig`lX|KZ1S^$8lF0D91MMO4gHD*%GCc!2d8mCK9$-cpbVtQ>DS^MuyTg1V2(%Hu|E=+0<{7)@{Cv1n_Cwh^61uuPn8`$$ zN9D)DqWt>xI06U;5UV&C2(TW2r#VFeEZEUhRu41%xeZH-i@%=e9J(8>Qa=7Ce2Ddq zTwIbWkWB0qw$-iJl)29E{o=_R(=aLC1OmrY^hc} zVoowjQQ6n%pNn-&$~2$8Si5>U{`n^z6BQJK9)loGiT?}`euB5#{=WD7M^JyG9vjAw za7QvxL~3%%#?{3{T6^zr4!e$;3p{X6N;hJ~H>`j2J)!jsW08L_GI%UUnwQOg(TUuk zVZkmo_NM>=oc5hqTEBox4RAnMA9Edy#h&D@Gw%Luzq&`~Zj+dg_$nB|$rCU!dwaZim!$T2sT>Wv#?ADHJGrs_np9kstWKLk`TQPKPN!8O!-|I8g!7Z8^D zi4txor^x-U#OMHEiZJRUf-<3viJ+vRrlT#f{t3u#-H+^3e;AP4H{a{N)QC{UW0ZD1 zn6xh|uqMT@FZS|Tr8oAaYH*obJ3Cyz|3&+QSm{Ad31G&r1f~;*vlHk`a##F7T}4K(X`rCvXz+Sa#Fv4nABJw+N;i0u!qC^H0;|hKf}t1+v}hV8 zG^tw0__u;4d*s46J7d6Gpm=Ojn8#?PCxgSoKB0!MW+<&_q=Q1L?BN!LJ)QTgSEQ}c zV?ufr$m(W{+E$I6ElcR^X3cYUd7UujL0P(Y{7Bv?b6hI@rFUiGDyuyc24$W5Z?meVI`kywIx86~ z0Ih&U8(LrA{cT_>@FnaT21vIbfcU zz1BWiG`OpCbVW?`8km2A1i)bblBSc#y>@KP-juKWE#$~fCD544%7G;UFqIJEjhY1> zmXFf;#4Da7ahM;4_!ngT55F?;R1iTmn~aN$+Iy1vW?aEU9Tdx z>#3YG#XJ(CTSH22Aix4OTlD2ji<_hdYc5EoF3L%g1*;S+ml;jQOThSm^?xYmX2f(0 z>W!9Vx07(O1H}(;$_SlXf1Lt)CRcr>BV{;o}|{nbYxb)E^^FFwZs#v z1cWX+uXXHAk(BGyl4CS5NOe=0JN4M372kV|mqODVfTW@`&+AuG;|NEJf{@FXlT$}c zZh8p@L3CznSz^M58~o-P&f`4kz?Chza2a;W{Dv)0&Uk0!$82SPtdfHny1cQO^Arvk zuza9Hb72(Xrem24b)7wSKwsi-R_Enq+s0@{_eQQXD=b>f^|zRg)GH*93vSqMk^F@- z1&9aZ0#s^sFQ}Qal9Q|!*0BJ>fWF0TVkkrc97={nJlQ~T2fVL8PVM|+!!R=<#Yxh1VA_29(SpAc-q)_L5lY6QD{$gm( z(DKLYHvvN`sDKQJE#)z$7?MlJAowfNj4Dr+&^XdV*KfIs z&FnhQg96d{*L5QCHe&ExPE9FHFmZ!l`;(Rke)k9k8GqVCHBOQwNo`+#snbP1ilLhd zcI(9BefQ{K4yxkedQ(Fi>4%%Yj6N;@A=(n*supxwqoxx|-=Crx<+Hc4PbJ zoHDw%=Of*wvSCK{SV(QE1-GJCj)2lh(^n`nhw9rb6>oK-2cYMum9GCR)X{l#Wy9&+ z+qnk$pDWR}3>{l%_uGDJfuiuzMGB*|zAmx(IVU(Natzm-w=F*i@L-tbf%uFcuRb;w zQ}}DMNqAAU;UV{>!abxUC|d2k1|9UByRmD_F*S3kaj`i$-yvvQXmY2y%~DkI8rFE; z;M87D07lUMwVH5Art#>Em9nLfds1E-S`PEfJf)`#&58%{Rgc0L7<_ z$Z#3KPLOEhK_4dzW)mD-=xhIxM2TuKH4h`xUXwOTiY4q+f6^+1$DCj8I1*LxG#~@^ z`j|gp>I+>wy>HJ?S#Y9df&#Hg%gGwuaXUAy7*+&a_#K}meET;4w^DzF(PV@vc&{8C zS86Db-r`x^&|$nFx|ly4YYqEvoj&QltQ0K74SCpt!YdRI|vF%)Pe znPh78@L#w6#CJ2e6>Nsg^eN2i6n5D~YQr?KeOeNEd8nbfU-d-}R-Y?TR@ty&0I3jI zvc@#hc){YeRR8psR46z8)K9K{mwE}s`u&B{|HP&Bo7cCGzHPYbl7S9nWAx**7BeBb zqFlT4{KP9tOX8;{u;AvIjhDbAv=h$~f{yjZsUEw$8Cq6V-x5(3E{G6j zm`z3ps7qxCbs%vE7KV?(Vg^3E-iszfD9&w^A-fugcP?|cMQy>TUxc?3IIgg-Gk z`0fs{`t}Ma*liozYmk---ma~)0b3=@{6#=ctOLtueqM5Z;mA%qGm5XtD+~Q!ETCJB z(St5F$BS%RA$)O$9w>v`2;!osS4eng-exl*U*eyNVNE)}`~{Sf%a^%aBgnX|j`2-E zn!<)*bMs)eqm2{BN}|@G&B!8JNjf4{X-DtrZ$tSoGK^lljSa(S10|5A zDGlJRZOMwm{DxTL)%{+0XBOeo+#W5FTIbclA0$O}eGn+S>uw-d-9%Hlzc~DNCE7xv z2V6mPX1!SzM)La&D4v0_`zxQ3LGp2ovBv#shICmb8P&pd1qUyWa(CJy@KibP!19yO zk5suBA19Px-Nhi7#I==w--ZQ% z{Urv_1_2Pg3p3i>+w#2hWjX%{Rn6SD$@2hGn*1$uV4s5)>yUN1Gt6p2ta?pGKmTU+ zur9+L%iz?vIy=9%+mlCd<4%>X;k{`*Rha)0qGyifWY!k5_%5np8@_2Vnfz$oe;$!b(BVFB9# zQ?PY?b+N{-L2U1u)LW=|@ABhVhPsa|h2XF3yqYxwN9l3qH#JmZssFdW_u~qNm9S0P zBNMF$y3|4_*~7BsUERCWy?zT@pG&6cwj{C=k15C`cifs-K<3ymhU6=*x&L!-!}E&% z(fL~+P=@9QbhKir(CtAT4VB4MxPo^~YAs@sMN>ogu3I-^#Uz@XaLGpqA&F*@tQIls z*G1_)=OW}+GF#Wl%Q-#PE@&1aAJ)^X-v5HTUIJL0+UD^r(u@SePy~MvKbTsm{Px2fn!KVrp9BNvsHOufWC%H4g>cj0Sy+Vgd30m zN?1Outdq*-&zpCx_3TIv0mk|gWBow?O)lM77%}4v$DAz^2hurmq}6!JuAZyX-c|ZL zajB?2Uqb9#cZoalGsS%w;)jpk#|AauzMiNLHEf1~N|tUKj>ylxoX9b(YGN~aBkCZk zZtXeu1G)L-uK)X0aNW)7YK(~7G@!$zd8)(&zDc^lN9n)VJv@0i+E|Rj4lR3~Ruu&| zxWVquPlLg!Q~ge=483eAA@scpix(5xyUHyi@A$Y?HV>E(-7Sjdj$YN;WC&fAf)5!g zSwD~3bv@%W>|635wgZ$!H{V3!f*~(spMWRX;3?xPjDRlyrbh%5SMWgABTiLD+RUb4 zv&KeN7T=X{K4h@h8R$+CmUEaM*WjRG`YxePQ@z{t6^{B>(}6?ns?-mP1{|FnMURT~ z3Zl9sQ4^DYaVVmHZGl~IP&AX*a=hDgd7`UI_ zg4gIa)HTNN-3*wIDd;EU(i=1Guptidb`|bWY!{kamrYG$?G_>l$YSRBu;cuT2g*76^?Mr*8r@AuOdz zy32rL(d(z9c|B!6^9nYWy8WaoZe6I#j@DrWSfQ&`YPxs;SN`I^@!ToO0R=U5Fy!)^ z_Hh>T8OT$ zTV#;;0|00b$=ZR@5-4(!Z4Oq+*SADhCRo8-{7&3?nW-_0MUu1EG!_Uqd^hWP5b>Hu`~7)O-fEm+ z^LK?XwlY0$4Y%GR_nGm=A|>)d<`Z4lHNLVhhEE@Af8nWm%VBV6nE=mG<**Zs`@R|| z+lcr_#}Z()PudPI^Y;V~<4vKMs`>o6&@4Y1y~ zW7qF>th0aEks!lkp*LmBm}W4OYMH92XHiBxvh?xn(+&7H?f5R;e9i7co+8mw`@y_5 zSp-*)z4!7khki086@DmX9z=deyiPO2V*8l5Mj8B_Nvw3txyQB=_QJ}oy~h28 zQ5jV?S0W1;ZEiL$1&4b{50&ary9$t~oEslEUM!6ye+-h~yI0ULZFLcLU%S|~;!&2x zvw|_L+#2s`(Uur9KR@qg;;8`f@c%PQLW`~eM`X!$)`6fgp_I_W^3>MT_o%!`AfNDm zWe-{Hz`V8g=ktSj1ARu0UG_xS%%L+1G~@?$?^s%$+SFt_Fl1oz0h=Z z{HuUn1O*_Loj;CJL_Refxbw-O{=?HBDz(2#Z?U*;O!RpFI4}IU*zu;sX-b9hPUH>a zM1-BEoEf3djowxLXIAOSJtIv?f4~01L6pc%y^05R#+>bQS_;ol8_ThO?FRp1m3Wpb z^g7{Yo|l(fJ-q`^#7Awv0|p(;me3JdHMfC1=f!x4(srA}rqFo+?$azkuKvq#;GK>khPgyM26vHvofVV; z|H_7m=a=_iA`P7d?n6x6Vb96I{lDMUgt854Sf=PKl2s?Rd(0_YaZQsXznPD@O4q_S zaYPA1(TLm4so4VboSLEa2&^Ri>`2=DFSqE=W>3kTn6erL1FBwhceaa0Giy3CBZuSd zMJy&Eg8|AnRqpV$BX5u3PiK%D;Jh^>V7zMM@qdg9uFoPJpXXqW7D%wovoTOx`L(wqKOTog?rq%d||-OgdOnu$wN-r#l*w{^L^~eo6hBa zrCk|bA@9Nlo=&53BOf$;&)zz8vW>E+v=AWMWt1QmkuVuBVi^fO%x4M zty+^JN};gr%ln?}X-@)2OU-COU5j|8i`eNuxQljP!-*JZwod{BjohE2{+Umm#s2*7 z1lI_i;6{pm!3w~JIow9feQL+PM(j@YY_~_lo2@^tm$Ug(d{zfgQ+9P5*e1F2@k5?7 zAvq}W(J4J?G4!k!re+FI^_dscwKB1uE3+ znDy0`I3FQialA(nEcTO&WYBprql6|czdot+C!E4G+TY;(G5U-8G$Ycz`rCP&RR<>H zS-P*pw{+UFlaj`rZdq)dH*I#BD^|sO9$QR0k%PyFeuAO@iG7|s1@&yetmSlBBK*%2 z6vkaaX*+qfPN9&-`5x;@LMC3O773N3It~*ibWK6iTH##XCC%%arthWksB?c$MY&iw zyfo4!Io?z6Edu+b^F=8~;pR?=+ZrE!lL?Fn=fw8z_r74<%i(y|W=6?O8o#2P;N^6$ z$|{tI{Sk#&1Yw$x{xgGTI;&FWjqL&;)1)|ASp*jZNarifWXWK5xj65CdfZB*(h=`+ zyL;bWrBr~%DRztNs$-aq6Zai`JA8l>Zv>zPjO!YGaFMQzagG}cuR(vCL`0muKS7EomKwG z<~75E->9%JnM=o*0aHYLaZP#@1~~g>1n-R$yxmh9xSQ?Zuf5SR`dWYh*$$IQzs1t? z^K?bDmW$QMpc4vNiS87)=Nx4m-4WHU3Fi;$5|$J8zCAE_!G>VtSI~YI z7qYE*`f4^iL-A0n+>Na*zNZIDF=BkXRJ$|9vvFAykF3^Z-0d@jk|jD|k-q{?X}|uO z*#@B4epRtX59d>METvyRr9%bd?l-oSfdS+yEc(ZwgQDRXBKKs%>{FXb4LT;n7$CsQ z|J}stdo>bmX0{6gSr0cl>ye?K5A-Jh;dw-ek3o!6*JU;tzA-phUqXyZAjmK+>)DpI zdyyh6V9%RtWkc~)U0zcR^t{B&A~EH66%P8R;R-85T_|B9#R*#KpLvnd)Ql#(4ho%S zj_P1VOHVs3SCK=mMF6z~xqfn!Ea8&jHi|<cpRDcqORd*v!pwE6L2%=U+|nOn7X{!`yczuHbotj^`xEMMwCYT(6P zgS0U5*4VxV%^il5E-M|3sd_1nm*7H&hUXyRFHj5|XisMmo!Mm8lXGNBEs;~;azdy7 zV?Kxuf?p%xJ{~m)9#QeSF+O)1dBfoiy2!;nJv_a$WE2A1#3rxdpoZU)qw1#cJojmIm+m;>x-G@7}Odk@D zwfCAwSx*OfnA#z4FQ-E@knOOWC?irouI8*VsM6KQg`sP0E`eNXT8KiES)@qK(M>Z< zui)~N?}L-fr8%byArHSEYRegX36#2)*uczygUF zzg@5=6QcE}EzLr>HmiVDO@ICU(MqmFv*hZ?eR3*{X`0mlxcV44!lE}D(%7dlz_ zObE6)1Acf#?eGI*`#+(#$$zIk{!!&{%L#2_$eZ@Qw?NJ-hQ7wQIRA~$DgPV8|NEE& z*rD<6%*}U#mFgOzEurZW$y95yl45L0#v zNPb*_J+b!-cB&P#5}B*pX}FwrQ7DJw}mJgOL($6Kc`ro2|=toX$n1*jFaz42w^aOgWo?&TED zIY!=h)VV<-#0?qW|Bo>8KMzeh>w9CmaAry(N_*M%BHo}|tx56Slb>_kSycrFqOaav zizKJm#*Ms{`u(%(-l|ePOQt+SL6`?~j|GLM*suK_r;TU(KbJ-}-XHu)F_r*>OA_0Y zacg{gP2SiUS{3^v1E%WjyTVhF>jWvv+zE}^dbs$?7j_;REQMH*zKAC(soSGeR%!4@ z4y65k>)Y@r<{_)|?awhp@*|LX10oY(8{EeF>xH`GN_eEvB=SPb=+6g@kj1+~Ni^9I6cj8@yS}st{52ttRv(qGHOPBCu zz8Y0#Qg>T>x0V{D%u;(;R8JcbckSBMEC4w}DOs>Sub$aK9D2@;C!&K&NXy!c?&M%* zDzN6LuQBf%I@g6o9J?ggGA?A-?ZmH54XUmxDh^2%kqCbDXRcwP?!F^Ped_%oJe++d z>NvsbgO}+q(SvJ9O4$CB3cPjK!*2tczP&y*Kcsft4ER{lfg8gZja0yXpI5)}u51~5 zUfds)EFE5e?F7qBwf9zU!I*2*mfhxL-ahHc>K(6_@rbH`ORp+=N!XZbgk$nJ7Ye4A zOVNs0s_4z#*Hqwqwv%L#;)L{`*V872U-T9yMj6~9*&+Y*i!(UPG6gxRkwRLrpe3Z* z?1!rEj=ZJax`@!VB`-_H>S{-EHJ_#xkw%S^MG_mD4Av*^aMFyPNMY+(npVobnYOP}#nc zMfM%ZF%6+y=M0B;{0Ks_|B>u7P8O=rec!^nZp=s1Esm!b@@5ukmZX$xsT~u1?b(#| zE56=Gwqajq3bRln;yV-ZShhTPTCy~|#ht7MyAd1&b74q!W<<43W0vXjLF|hPx?>8_ z5R#_rcmDV;j8+c)j;KXBqFP(mwu|~4PI0{8PPD~V-3m>pv)0;!E*G5sq2KkB7W?BH zwk~Fey(0~8EY4;OaCP||v05Z$-4PbSIEh9PK!&BGUO@L9`ER2+u75_Xmdsm(P=I#s zIO17IP_ip{ul^?AZj4%RW1Le*8pnF1k@}q`V^-A#dki)e4WJVvDR&+QNqp-JKn2^ z?=lM`uTU63c9{JNbQm_@Rk&+QILG;<-Zf8rmw}zx5K7PEy1J4bwVv-w#=bivb>yy9 zku8|t*Z^;G+GpB|$36HKUQ6?3ff2MJZ#LPHdLizH_#1KQ;pt}f|K-2n33*)d{K&T^ z?T_cF^FcbzOg^jTO;1|R&NdCL4zH3+a(K?j>+;T>|Ca>FSoz;Z`A-behLqL1E>G1XWsF+NYDRe5|8m=`#eE+8V~VOQ*m-o}u&L-GC+8UX zVelJoM1E>47YW&7kY4RUoBo6qK zwKr;8<>_i4KiN|(1g(ArT!E&PW$(C!rMay&`f_X(v+|dOpEtrDe9TZM<&Sq@E)%sW zFtoazV;l6Yq^l8Ssgj~dFw7j7v|kV`i}F?Oh)`cT%pJV&sFt#aqb$R8vz08mttNsF z;z^xjw_Rmz9+I0;M(T#V$xA%QCBwPrV5W+!1N-YM>fO#c9xRuA1aH!@tGDvjJaO9L zNpq2L*_ci~w0NU~vxM&K(;${zha6Bpv{9db47;u#?kLkfxST^D21Dmcm!`PxFtrZ8 zAhfw97EWA)^U9xQSHW{49#a3AtiUNeJ;Kn`j3ub13a&yS5sD-+H=r^95lnvibs$Gn zs!8Kex~1@&W2tWPo83~IFTI9(Z!!#Mi%RB9WYOD2kUQ6{g!o5BFn|h;=RK{H@_drOUKJWIdh-)h@!ngc z1@X`3^}wvx>UWz;KEf8WZ1rMwRIy!_4nT6clH;WT$p!lpp!2LL#H2>{V+EE%Xv|?MI12=H_()ZD@#lrVox-W2uOlG#aXav&|HX1 zMWKnlY8V8Ne_FMS{AMu_v#jBgM6l-%Fw6-UBXwyW+Qlz%a&p4FEEs{T;?5H5wX+UT z5LVWNX{)JdG-gJoUqKhw6>k8k4fCI7zQ;1iC>?`}{_09f`<9I{o-o1Xp7d0&T+3e6 zkpzfun`p{-cd!{o%Mz~He6Qwp)@Ehx(5<_U9b<_6 zwH33lx}+HIMVig=y3vOI$n4s1qOT7R|arViLh`eRQ+T1!@UXDAHW2=3E$U% z`>42im#igDtWM%QDDqG^x)Tuz&xv|;XXfu=zj59&rE%=|8hHoJ%&AdCrr$3^iUACk za?j;uw${Z*lX{&Y%i6U&ZIYJ<5?yivbw^Bj;c9%*{G}DV2zLx$x91vVpT=6-W_-6u7p>?~4vW;!r;X!%})>eKMM5s~bSsFxOA>L>B1 zoDSsa%?lqkRNXz91@i@2-d@Y@WH;DVDB@A2{S@h?z0tgsX``B}UQup{%gawxln0Tk zq+)sHG~|#%Z$-$k#FY18K)#iSzig+YGT)rOz~(o@B-_t6kX5g#+TM=eexJP3|JVcg zH>kAll`?|u1ivHlz{+k$-RDXe=pu#>P3m+jzU6D?D>)1{fbHB0NQETc2c$z&vl{Yi zM|ViX^-=}~6j_33*$IKqvf3bx3?3j`{$4!3vcrCy-D9*=X_{;!LzhVoe!;Qtl z==N&y=dk9kmHYEu^OOcA`cu7gLDI6|rS@sKAspGt9zFX|WCS7=g64hZov1Cp?WMose|?TyIk4@w*YD_4 zPU6^}mHiy?J8Exz{}L7Rq{3%$J4SQvq{V7Pol+cfbIv1ygkIN;t%gsr;H7a5hwLLX z{|o48Jf$gqiJ)$Y(L~UMGdO%6e`!uBxihQVrXjm3NlBoq(5JBohF*~4ExZ(yH){N= zWw(jaoHt`CcS~`v)(eA6a>jZPJj`c+7^gMcXMZJf=58VTqN73i=spJu0*7B8xqPyC zm;Rbz2_@a+G?ZYf6s{_{qWyPLa`!-@epVDlvmP+x=eoFlpnuf6HbH;?^X__0m zqeX}vpx-_@=R@(@H8=rHJibs2ooF6#%p>q5s^bdmcsPG})4WJ~+ah?wuW12~S+7vmf|$LkN4rl- zMW$cQsEE%|lP}gi^N;DKW5p}12tPv`{`BT0`6kpoq1fL=<6`l~o{>&GzTHtb^J%U@ z>Z3$h#m?hPa{lj}v;EG0b577q$bX;jIc7iul+%L8%Yx{#VO_fIB^K7`6WDj48%-jU z76xaN%qx2bN`+t&=X-zaSMy%<$g{r(dEmqy{%jN&fw9~GVsA6(pF(CmK6 zPBT9D!%d{tybKKY(bw_c$g`wFAT00DfH@7iRvMg70iCSEttIV1^dLZT+ih*)r9O0p zGJCiNL2@AUA`D&(bJ^ZV+KtrB$~s`TC@mFl!rv#DGqrmK9}({^QaETg=yY1$`}Wi@ z_nXGMJ8$!|p&Y%|9uGCj!E6ZcWOP@nl2NZ52og;cLxq*3#&vxku9=UNfT3kpfW-@KuG!Wj6|_^ zG|Y?nKFy{_&KJ|N+>He0wFx#e(--@*tvH@pF51S3YEO&P5>FV*^~CYq{p#|7o9oUG z3d20&7aNn|DG!qeO&67$f>s`L`=#3Tma0`YKFvo8_C^Y+)93YBW#}Y2k#C2o|E+m* zt&T0}(rzPhr-2p}baiArZkmAAg=aCd{f~=a{l5*|gTutSV?iQA@g% z1ebXPd?Tf<4>kpY*^GGag_FDrO^mFA1D1c%wIW2UEOpM+;#qwCCviu|2xG}{o6@Yu zX-h>^{PWYCA1f?rCav!HaJ}wBMJ=$~^-8mA%l*5$+8$9wVWs;2|Y=Z*d2oK7ng5V4p6J2fl^iCu;(fMInP~QzWnjC#9;9@xW`%!MEC(y zLB@GoagSpSFc$^bNTwC+(ozkwx8D2qP(@@AD||ii_b87QsLI?MO&-i6^wi(BPbp90maKJ)8l6;>439y0P!t9x%qHEUKG)BD z%=>f87OoElOtn%V%<-6Z=?jkKh=5LIPxX|Cld?px!XIgX=b`vssGs}kN`O6ga@8)a z1Ee~zmgTA?jcK+j_!J#lu0h0Q+Jc=o5a&^k(mVxhP)*MXSDda*M?m-od!6CbCN~>) z2>!W(SE!s#ajsGVvj6C-8J-ze%`+Jj*(AUnCO!$}B*g9g}@N zE&P>*m%5uX_a>H1oSIl-xR&fQYa|E#QQ7owuCsn+s)9UKcav3A0;@s8o4CY7J7rQF z$K~10=FBni?h*bJ``V}-%}`&NTin_hj0W>DS^t$DtnCcl5v~Npz$JSbMjXflg}sM= zK*1b==T^QwV5|ZJScjiC`sdumV+11tM(ojS+@lN3>`uzHvG{EFGC@b)+cg2?wkb?7YVRQAHO_qfbBJuCxOk*mLXxrWVp4ap5>`k4?aR zJ2H(hqXLW)WEZ@^63i)l48<`HWgWL7>)WqCt(u!J`J8o!w#qbT-u$@mw^r*Jxjo%e zVveJ}A*|wnn3rVXenq-dYYoh%(3hj3pqKjx?vW2LS7p!viO(y_^wQiY$ULjvmU^Xr ztAt93!JZ3Y%z)6i)DVlz(Cy(+Oqj=ql-$Y66#ObN36!s#8*P(NvNUN13zc(=#Cd8w zd(M`Q{lYLTzf!W;?a&~wZO$;mj9Fs1X+#BIOY-$l+1bU}bIB$R$1>>)op+-7F(q43 zCR)CSYaN z#P;{m#Y|PJ45m~%lGIk|s1$fiFqlDNM8=m)>mtT@Wz~tqJ5gyHS}w~p4D;U>zByHkwlIc-9^GWQ z?lyfl@KdC_q(+kl%V#{PkAjR%6$?ilbh$k1CA{S3CmG^DP>2K<93vM~$B-G#qXrP? z_3ftuGpJM8I5Au^KzkZSIGv!w>Q<=4SR+roE5^eYtS#}de5o2M)vxpOU5T4MQ zbL)KV_^Fzk^Lf!}B+@o;1X?`Ze!W+G3s%l)g2Pv&v*YG&jOAi#DuBLSz#6UH=J}72 z2_+c>W)P{iQAnaB;EKU`kCHn;?r;-pQoZicD~1`bH`wwtv4ytE9cj=4kbbAhY7qr} zUVPtP%%WDWoMc7Y~9y&a~=C3lwMCQe&P@R zt@tP!;P8UmfV`y#F7XI-h5M7X75}F*Vh^}&(cR+2_@HnSXK?u+f_K#LS@f5In8r(k zB0K2#DkmqbZg!ae5(SOnl))N(2K%l`yFs^=H)7$4$_it?UCXdrdgsV4zcGW0arE4jM9S7?1G%~@g&7I^+%; z8=Vqla39fb?E%=ag(O81o>xwHkDV)j_5NA@r0qzTvC)Kb=I;esX5^8@1CeMyqybg} z4k&HJYTeXD-#&me5Ql9B>)_ohFV2VZ*#AE|c&^O6lCu9S&hDur(<#jv6Yno!F$>Cx zB@Jps@`ncq`NjsYgliUR-s~F<=fm36JG()E- z_cWpozQ*8xe}F?>nX34}i(@yUmay`eBF_zK%M)#Q%7Wuuw$r9DLd^*&up1e{otS>U z8-eq@d{Y~X)AaA()0oU`KjF@`kM6t$)=M{Z&znr^l2&>u31>6pslsYuP6}?;j_sWf zpq$~%{~udl85U*RMLR=FcS=b!bV`Rxm(Y+H0>p><d>JWUSp_zqy=aoNDqJX%aW#VMOkQa);VN*lemGqN?Xl^x;IN6imYthF z3AolX%24@k=rq$`h;{;4`q5ED>jO=t9$~Y;){b%y){cC_Pqzvb(R4D(vR-}wFjeaa z*(P`)0h(wO?T!2GVcmIWQnTt|^Gwd0@$zcN+vjz9Q7^F($ieweFz3lmo5U?i(8Irf z6brlQP~pw>rs`&cU)XPFzLTEsHQ9qlsXdZ#cFxsf9h&_XZAG`2ARb*H!TU@Lu)3XE zuYfa7^_fEn%DgJ~Mb-$E3Npi>ul;m7RGyPON;J5Y0Q!UEh->a()C{~wfu^OwQk}`<_GBE z;8TVgKN!!krksK1!uwvwNpRKxNtr_XfkP)@G+sj8aYWJSic1a7xg~Z6_ zM~Rt!T6b2YRPfHDY>zGt!TB_N)Y}wQnwyskEl>1_9NfqyD9L)-wib+L_mrIc$k2K2 zw9eVvKU96az%R?!PV$%loU+no4)y@x=V6QT;o;e25&`Q1{}p;e`a4N!7E^(Jx@<2% zOeC!MfB#zp!JkRl9;)u#Cf+68%&6cf&edHxwvb66AgoZ4uz@#DEAc>A`V z|LRntQTrthSsQKH(GO1OX|uw^{G7zqi#Lo&ihlzFxwOe&w~>>v$-lB}&(|MhXol?& zvWUtEpZiHcx7CdupYp0VqRh+nSy#Qlcm z%dQlrp^F^=bXl8OIjO(Wg`0^)oy!U~yuF7exs8%IHmPa12aWft58{^PJasMdfH_ns z8a?7tZFoCmrmb@G%|mDQq3M$o=>4xC#n%0QQK2>dA5_>$YvS4dPKNynE*V&HBOCw` zQP%U7f14qfJ1%B@Nw_5;f|wt4D0?A{sXAP?F-ST}KR9MHS4+0JGd|5dPf0k!?&~Bs zG{Jue6S>s*dXY{;bKlXs?mYT3@k`jmLaQ3qh^saWa`KA}Kj*86B{#~t^e-nwdRLdz zqwAe)%D~NV7<2Exm-3YlWN*K-&>|{(K)}nxxfSJ4)w~%EGw~3Dw8e z!v4I5+=n`{KZ@vLKRT87yP6rAHD*oqbQu>8gwHrH$SpB0zS^egv5GiuZ2v*eB_Ehe zZ?Ji8pejZ}5g`$p*$&LBnv~ZPf6$dNEAJYseK|3h_6e=izvp7?1>GGK(XLPyzPvPG zmT*}QW)$AaP7QDszg6vg6k@mI1@+mYVZ!chHm$@he45*ta8J3+9xUDYX+Nm$O)*=- zTR@Jl6QOWWn!(YfETh1|Rqx^+;*&k1jcr%OCkgn47ljK+<3!4U zVg3F0lHldnVdU$6w@AgELHE&XAz|ZaoNPj3mKH6xW#7xuQ7d&A2H2)q(>4JkGn?nJ zhg2!T+XKz2j_cG(+a(ivT`lTb7LVEH#i!{sOZgA?BQJjBA9rsC@05%;R?}w`$}9tA zMlfF4%wPJm3^}y^A+--9JrF7a7W@74j5;A4Qki~08P4~PRb>KL`tXQKmpmDFuEJyd z^g!HPCS3$&wdo`iFN5}T&J;~e@F9tU76*pj!F&7)IGXXn+3Plhly{4#g;T=G_*9&I z+eG!zqLf1%dkOMog^Wf-Ap)`HKNaX%ntvl;EPQD8N#PUOo|gH}mLS)E9I5sCd-n;0 z>`K8=w<=JKTQQmVnyoo*%BHs%8_eL#o_*6xg*2gMmk^erbhQ}oxF!Jhk=X}>_(nR9 zk0S^sDM`2393X@QF-dbuO~C2i$$p<{dtu{%OSHk|ChJI~#2h zYZM)LaM=O8{6rttIRN84Xgb7i6Fzq7V>&r!A!i0yt^u5O`f{h#9YVixh=?OW26XvC z;IfOG0Z!2AE;g9|KpzqZlT_=q9z`VX3Ot8>%7==xH!r5v2uQCUDNHp`I)-nXz*rM> zD0CJ|7+f%H$s$}6;l>lyh%9p7We?vkxiWmVj`VIS{T*J5uCNbrTV1L6l>G8>PCOH} z&&7L7+x1>`-D0kx3GGL}_7vdwC^`{=8Cb^?Y9wWEvj!Df)xopla_<7PysUUCyXv&z zhH75Mb9z4auRa%dUVS(nQ7!#RozCp=LeqC?%O9c0Y}>@hj^z+iykNPErx#9m$E+HJ z6~e-ygK?bm8;+&DnR}wKnPE_sOhr=_&G;utVO^c__7<Ju1KdN9AeY6_7#9obgrjt@Sh-j#0%$kjhsFuG*Dy=%1*Q=G4STJ6QF3X#qvuhWP7Jid>pMUB`E zPRWfFwg0F}wOVDW79UQ+#;HO-hFmP+xkh*OVN#hRxB~g^00NA?op1NHay$?tKy&Nw zT*v9FslSq(voYc*$;=c$l2e~E1FUahvt;OsRSSz-!#AQRgd8ehvDXei`k6%|iihun z2VpcKG@XLbw^XsUunDTem;K^=4V^#W_i&;+o6!bpuyb;hj>^58{j%_B7UjI$=$WM1 zVZjccq-hyoeBGUf#8PRUE0MPC+~Tv9Su$m|mG=HvYXmv_lW9sH#*4$D?Bc>*vr;#y z8HNtls6I0zCo%3CEu#dERJ~WkTVo~*O((iuH|ErG-daXoTH#PL@3(io5qR))trUx|CbuF z1U&NAVmVYePS8q22maG(DM#xu8ih}Bv0;Ay@<|ZOKhUn~p#2HTmxhUIh8Lll+;Tn` zcvU{kmey-sxuSLLxWRq6c|cakLnL(_L;vln8}ifdJK?#)BW_j>0!NbgeC&vTwViN= zIC8~(Xw+JMQN`#hf*x$euxA9UD(9=0Q&meGIUW|=R$cvkk%!g{nmz0QR zje8B|lAXTzf?LmgS#G@&t-+uj9*X??j-qH=9v*K{XH~FRf$Wlz=Y({rVt>G(Sg& z*=#Ea*!F=@^IwS}nQTanlCI0Hn|i`LAG-#z`BkQiq`=ESEa8b!D88>sc}3(~M;Jo# zgD)jad;;h={e$P9Z<_r2TLxSHE42`s`3V%vvdL-%SPw#Aw1)p05KfEkITH`c#IuVf z&UXbOS1&+z+K-+u@7pf-(QFiD?yhr=R2U)Nt3A=~F>%Z>m(`_Ra~-Z_*lH)9bUgc| zGyN)|$E~*x>f>c0uVf+>V6L%QpcKMwgQ#wY=c!(Y5BqvpY&4+mOKhNHXR!~oXAUJ8 za?iD+cD=zxsf$nY=xXsC^kZoAc=;A)fKd6t!y*IbRU;gzmXKf=>e022=xwkz;z@R| zkf6xPhDQO3;|TM4Sy07Mi9zPIn1)eEUMkM?57_q=$4LGoG^QC=KsZIy`Db$6A-A3s z1L-j^EWL&n*Qnst>b{n+R*E`yrT`SoQ;z;|!Vdmrq~FrTik@n}%nx(zGM-gdC)`wQS&wV`U{yPLct!7rq+uvx-ZF zZ>wj7zmIFpLe_+GN{=YD_sh2?W1vyt>7F~6Q`|K0v3^%Ye_5@@&tb}wKaJ~e1$Ka` ziiHPCsjs8F1~U1r9NZ@AUgFuOdjMhe;N@_ zxTd(}2;5b_$wDXpDwW+ITta|46*%eGBLEj!w7OFvfEUux8pinl(1|ZMN|{(VYPQy1 z+^~pymYKT@T}?u!Y$No7o!oz4$mH|Nfw}aNqYM!YlbH*43$C#hZglxd9!G z=@#6flQrn8|DPw+^8X0@;8Q_ZD+)%DaNj-{R$_S~BVVasjvJn!!IsLp*!_4k|oLmror z<<+*&2UY3?*Ti`DtUt;W5E7YzD~zJ0E^!=6+O?8xSg?72iX&(}RBkbjRVvQ-png!^ z|0{s^6~##Yvk#DF7#jhw!1khY1Juz&_JG}H>I*>FSNZ+*?UThul&|5n^{6c>fai#b z$8S=pndvxL9~+ICM>ehrJQ!V>F9vW$UMs)snpF^<71t_~h=&mjhqBMRbq}4Ea$~%L zTmI0WRHfX(jn>h{gX%K~?G0#=B^#_0og!($o3+$dAz($4%E*Z2cjiPu30uD{9l-AC zLq?@jxZrv#?YI@=O;S^0_!-t9Zqx-qG3AQGNf^2d(6T{pQM_>^%5Q0?N^ADm4y{m7 zgz`9xWcEIuq7ACD-G5=Jb=*3F#HJ9Y;934O_tf*QQ&jmTBpBhzWxAwgpKpBq@o|l1 zccLZB>0V#W+Fyk=ZWsp;3x673mkmBf(8hpjcl|IMV)J;#PYlj zVA=>={B2+!tDX}3N#c`{&qaiZW5k`GGP~%6h^ln}trBkg7~?3hK%891X|KwdMi2rH z;~rKFWN=cnOp^?{k^`{+U>Vnrb2xH!B_~T4d+El^D>ID&l{@c`v#cRf8p|cgY$uyk zjs{)f8wpzqBxS2j4oQA6@{5D3ImIuzJ&w1T{S~2oWMtb47H5vC5u?cCX-~{PBp?-^ zC`fg>8lQLf7KdLCo_akERKq*Dul~bGU;1O2(muS0st^Bg>L+|R7xhl5eS?1~3^t%n zNPSVG(4z2tSx1*uh8Uq43fBG_)>Tyc{``ktZ(rfY%5D4rVH2t5v4PDsm4pZpm*$M6 zL2ej>aLpCMLge9aK5ke@m`&%{2ok%c`KbzN``Fd_U3Ov4Be~i9lVNq~NF(S8kuaOce6+&$HhkBmp5L?<*8mv(jwi@4nWLs=o-qA-n`nUk3?B9I zMIq0jYCj88&4ruef}}3DyNabsm%+6}dIa>wQ965wUgekj%qM)mFJmp{_jPX642`|U z_{3#bwG6poM5^H=A)%M|Uz*&(pN<;ly(ufe-%KE*)7i4UjU(%iq7w}^w z4>$T*tt*=+|3*1=^&{vxrqmm%k=jbMh3{;y4t?n0Q$cO|X_E z5vez_Fj$Ags7W%(jU%e*9jjyop;`cc>&8+r8;C7X7m?5AcTH&^^sy*~)5pC1&npXW z$0dIqnd3^tLmp$2pK_^je+!0mlE)v7`yTqXrZLC%QjFW?j%RFHrNR#6Go6m-Qj|4* zVo=Z@Qz8`rY7%ua>n`5_9TWqw3UYVvxRgYVwr9Rvil{$~-F-^GN#(M!5Ty9a#~am1 ze36bl4IeIJZ8kZuuJZ+bfGx*ndmu5%88KbJE++o4*hdW|re^GUx8bBq9D#Z=d$Y8^ z?#+^10Fecw*{iju9NHE<&ulPClxW;NY{E%JFKfOu5m$%QFv$fPHVf-4K|)@#xLi`i zHy*v!tgR_RC=6iDM31aT_#$+PJ1636%mz&6vi!x zqLPz8f*-LHh9#H=BrMf3y(Whv1Y|JYeL_u%)S}99GVh#i)uGm`-ws|53@zu$m^^`D zqsO;u>mcHyI?~4@ak9Bb4P$=F0Iz3ol;{QS`?979SiR+LVjUOIeMV#K*(f)y+br-t zd1aX0tVQNPL3HO}AC&2IHnp@RfM*+y72Mk~FZtUpP*AJ>^;0t=`(jETDJ3;`DxH+H z>=Ojzm{*+5%Ug{1_kyE7DN@Rr&OjF~x)$Lq7MaFSMDfhS${`)a?!3VF2;FY!rt1|67>$@=WPCb7;H{I0 z?j~uXYK);l++?@Ir7JM-(c|bWWwjfx^4+_pKwQIh;YB27BmVI7gfXjVrDU_cbd7jn zKgh0sT9eC&=pBl2LUpRormf?s>U|&<7b5|`YCOV0GwbIo+FxHp$ZV1x!idb@FrtQB zj9|4sG@KI3TYjRWYn+u^q*%VbMX!|!MQ3i^N~kc@n~aHL;I8NvTJ$D_2hHwZ%zHLC zg<@R9qO_X$*D+EWwYkv;>JVVKxH=jaMGp`8F$VGh_y20bQ>04vN>l0t>eK0!BLdPl<^Gl1}C)fs@%13sp*Ju(cDUe}GwbiPklmjiO!xE))ZbJ@M-E>i4O8jMG z-`yjej~*K1JE7c|y0M^2+_5>;%X&;@YBL@WNDrRK;AFx5y9KHczzqhwTl@%ha&vi7 zRBwwjbL}~EX4?$GA?X+z5Mb4i-x&pty5w)pmb;V>W`Q7ycESZc4kF0ST)C+9OtZN2wkwG^MClfio7mj(vzzK{7_N@G{0}4BJJT zyl%B}ap4~SG~l}m!dT$#&e~SkswyduQAc6j^RPqdV=-7HvNk6#38)ADE7lv{G*B1f zgVrg1Q?%f_!qfpywA!A~X9(&U@8)l2)R}SzFKjr#?(~zd8kxS`03HG0k2uASG$-+j zeoh-1F@h(}z0EgTz0H?)M>yHUg?}R~re>fDXySNg=qFuK4EC5GAQMJo%>+Tdea9WU z4cK2!;777_e`Q7rKO*@YBp88($Xk4%Fo=jl0}r=PZcUpK?-yzobcLciE)@m)eWQ8D zoVz{oOmQ*H-x{L;vkKvjsTCPm2LU!5Sy0CjHU$k39E|JL@3Uef=%-T%q%b~ccW#^Q zusfXC()}q|5vrW&WEp`+_&985)@?CiI%p#o0ax*tuPU1^^#N-~?bcc8VYOPl@KoL$ z`{R1i{}a zeHVBtUqXWH!lQwZmWU zgl4$Dw26k$Ubdd+!ON8iY6qT{nJM7}M3e6qeO$Q5R!4442;>tr$^%u!lgWWsLp+U5 z9sReD7>#v57hoOi!^;lxo?|9(QePG~b zT#QPJLK&-6=@=KEb!`-Q#-uAztkvXewN8JEcnA|OI~N2@+aSj8%Voef%$-MHoE`hn&c4(q zG-(CN)1cKtabL{_sq?a-X@eAQBqZ7H5cy)=`a3=y5VP%SS|fn+1VZrMC9m4=E(ULx zdE<;>6m?75zI~1|wL1Tl`S>g%KD8o4S`^0M5qi4ogV?^)&>cLmpnoQrmKAbS^Xw7n z{`sW~zIx&Xl&dH3TYx>bCOgmP2Hl+9(~5BKwO`YaKKf`9ZI(Tk9WL=Iv2*I%7X6bL ze=Cu)Z0)#gN#1?PR6*NJ+)>pS_MZsx3D(-)iC_r7HnV#+)Z&pbq3~E$BaZbW?n6#l zm3rHODWQ^R!2bB`sqWgje}wbG`KGXE&^#1`?7dLx#oqRn&imxe+-FlewXpH)e9J|2 zcmNw=do;mLu|@@VqFN8>N|tMgSk*^(xw@o@J5cfE?dM1J&3goyMHo z<+1}_j+5?I9_VR`jK%ka?=C=KFM@i8bEAi?Wka8owR8v=65#fo-v0aA?qQ~2L z+u5Y`?GTGIog=Z9SDRAnM`H08&@u*0lOL{9o$yb79_F-rT1%E)1`P3T$7fP(t6eQu zJNr%YEoc3>by;nD+)6Lb;H(v>+L{XX#p-vVOkW$S4S|sP=Z$>RSUl|N+5V+x58Q%6 zb>ULuhp3q};yY`lDXC2eKgtcsClZAyP>e5b{H8$OhX~R6jU`S@$aWVg4JO3T{`L+w zr)x4FRHGYX%G<5x12Y8B2)eVleD|^r4In}-09lH@Sqn%M<4WX%q6*y+%?p{pVWNvq zfP&rWnOj6*VBgQpX%HtHNx#@I)3&P^jJNCuc19Da&D(N~~eIjFe06lEqDSsF*YaYDBYozZmX_t|-HfP%v^n`AHBbp45BBUG&77 zCZLw_-6b$tB77JKsx3O#LZD7f%>izGp=3MJZzL0TL*49zsDzL&Y6BEZz(t5U7(J6B z7A^0D*pfyY)bE?~{cwV%GPJVZ98iSTL0?)?o*utQZ=~Kuc>^*+jzg73VymMClOiS~ zp{?ApwI0n_aLhkNvj+b3AdiPiYh-h6{%l;EZ;`W3P%tI)UjOmQLZgCy`q-C8qQ9~pK0^R2ZdPkoBgcre8*O&2Qzb%i_m#EdJrQsl z{0C4gzTU65=b-vHBEfiEc9hG@SNQs=M3jJbIG;iWbT6PrZJND;Y2sZ$)R9o|#-4>C zNOq2jY6b*Hpuxu}5e`6l6N>y1(LkQV;_Y(GWIO<|IO@8!!^3<-*F*^rh)$f_LB+Ol zhwTcatwC<MaMsQ%782XoxSNq-ViN4ITTQ;^3O4JkRDO9f1Ur}AXPd?Ir&H7Ju^4q{(^Y4>TL(V3AxEe6_(WBF~Z@Iu@`P~TA zC087mCW1-;%Z6k>bl3SsCL-Q@19Nwdxr{>bRF=%|f;I|q3@?noyw%b0B*<7cB9}52 z9gXXNc9?zvcec@!3)%cvv+#G!wg5H{%B;w>gSN8V&d11YGrVDKo%Qnkz{r zehQ4kaoIFoxNyFgR`iMsZ6Y)iCY-JKC4)UmJH!peXh}j<1hw_e@|#m~OUMEGcH^!= z;EdY3#3=plCv*J#rpeM#_Wg`}{Cka;(?!GL_ujETtXSgKbu5Ye2+U5uL~SjC{Tue5 z%q;b^1nFXd6S2myV~SHQADwNjaCYvF#tVz9S~P3x!QsmFHV$#y!E9Gn_vidk{``v@ zl-0hKi@RICM7f{;t>ySM7I~Sdv%T~8Z3Wn>{4IP#6H7Tl&uqT3a-lsW6zNl>9hON9 zD=RA&7AoBUXbSZ$dM-|R+H<*7&vVmXGhi|k(3?uhgs9!}4_KitNz-&_xDftWc>|iQ zk3ETXjG*98BW3^*ZG*Ar51mj$P-?d`-oDYe)YD@wnD*a_<9W-y*HjPrYA zG1iGbOED=tAQJY7I6WcHvXXt{-{KH}*^;chm+-F_z^zIv=JviP!g`bN_MppglsCyYVNP3* zvmv!)_x9xnKMDQ zAV8a@2-dALW9F_vIb3hIJYaRVi$23UO&#@10e7CV|Jtbi5H&)9s()!jdeNSV@Was7 z)*?IF3BAhI^}vmS8nP+jg7wLWCyHW;2EYp5C7kOaXT+R_HGnP!N`o-5apMDVUFUA4R>@|ce--7isU$n z`eXi>B}4>WmPCi8Gui|#D7`PTn#kAmfn=Z9PWq6n(@8Ie`a~Wbh$;Z9<028Ref^kjn zZGV|gX!0YB?M#ywC90Ig!HG&*URb!{@x8m^)WR{7=l~_+Ie%)g6Szyj_!TYWdH2bw zzX-kYDt8)jz|+_%sk@~jn~@7L?dQP*G1kqxX6(UJVf=6Trx_@N{y9bBnHBLM zA36SXt+v6}W6t!Lok?u1%!P-%UAz3O>H*cjoQ-}UbL^QMS6Ex&ufRMPhgwiY`YjMdTc zrKi4F3{9d(G7a&>Dxq=B3q29vDF2<7R`qk=*9T|M z#jyEh9xz>CtY)T0fa_h?ah0|ng}nWVT1S2WLh+KfrEhH=)RDsu3HCQXD>(1-d;My*oX;NqQe>j5 z2Z8-jD=qJ*8PKcQFF>=V$HP%2MHeDks&0Y>&v-QJKwL198#cSbk2;VQg*ulNjJ?``S|;V(z@Mp<~uEH%@J0K0gMP(B+=K81uP#OAo!>5d5E@4rU3!a~#uO(W`^ zYd3yMk9I>T8)npCRI)-apM0Zq!=9G<|@Bgp11K>87>wEc(2fG&k(l+P&xC>z!9nvOAnzTVGriz@7sUn|RK zWCd{azTR8K-5u`R^;M)YJrC4|!x%3If>Q=2@y*Ip z|G{@$k?3qnY{OlRoZSMq?L{QNM+S4Jjvp#vWgtJhY7B7e_Mrk_ri}8VR{e@E-=(>6 zv?j*nmqo)6q!?0zO=c+8Mu^?*NqO^Qlk7)6h!}yqc%fs zbOwsOPKrwhL{#xIMEBG3=S_Y9-hh_HQA{ zw^*RIr{+^q)TN|u49VUE6t83v&Ee%}zZ^0XF(n=BF_X7s>NaZ@FEAzz$-d4>3Rah@ z9kXqF#f^i?t}twIMiAFv@5vJfa;^8y^bR5d`9Xd7%A;`ihbhJ3GZf^&S@dpTJTxl@f>f zvCkfu`58`Pqd7LU&?eX_Doap8jCVVZ5fa&ZMokV4OMxD#ihRC3tzgb~KK@}+aq>4S z^O7VeigLdN+vf1jStHBdq}j+g+?Nrz{2q8K=YVqft4=^?w$!Ky*g94(Y%S0!%a8o@ zS+GpX%K?h6w)U_m#&rEu5(j3*>2qf6V|A?tsv0hSej=8`qsn~zg&R$PDv{nYrBS8MPFNf70WfRA>kt-}yxpeg9{(tkX8)2Qtg zyg$>1_28_}wE5+8|U`z0FvDLa)+IG(Lfe?fPav<)+N7 z&qJR=6+sZ@0O)KAW+}CF*a)0%+>z z9NvK3d8qOl<@W&Xhx&e8k}Arf@S(76{my!j5{L7%Y4p5Hc;O!=v^%vZPBYK}0$k#m zh%GOEbkHk{h3f^4!)vNSn{!AU)5ZXf2qJ8v_M6?pw@}+)eu;=%c|C1pJ+)RO$Cecu zkL%f=Kpt!}7WA;>UgU=E_>4SRM6SPe0b%$s4m)hkM$+tBxRE}`-iNFnB?_76p>n{@ zPLW)(#@8*sgk_DPnSht$4`ifo&c{_=TjJQN#hoEI!7^VC1YAW-x6jBf5`khMeSD6e z`S|;6MYmJ2_FViU#Ku)xPDpRjtIq^7RYc4DR&X4LhwjUpGpdGS>NedP^TnSh%@6{5o%j|FgY;yG6>Y9=Ymq(I24giC)M_E>uE+Nn?hcl8Lxg z;aKC_4$w_?lwWSfe!cFCY!1*D#?;{sd4G;shZ%@bL6TOS>694hCm(-6fuDBt<)@my z&Sjf%-j8c>VowyXVjI|cvUOKVt7<+Pq3%go?V)^XlVb*Y8fNOnZeohQ^SEV9O^6{L zQWcMpHi(xLQqR^aREnNBb**r<8eBy0H1Uz`wTmfyC`}Vk(bH7UeGBcUzo$8DIH)O(EFQA9uA1SVB-q2)!hcy6hg^>>*ZJ}A?O8ps>^7GcjX@xKOB+7)H~m`lp_cU7 zCk0hq&L@EoQj@lL4_z`?k<3A_^rJVA3@G{Lp>Vsgaj6(%&4B{jZvs76oqBh=2p^J7 z_T05$nbmLXeUL6yP0ii<`FgX5D#SD$Fmr}_<*%>pJ$A7 zVTN~sH6>w)@}HoL@V&HL#VEC(^(7Rbh6S*N5fZ+}-1>0lHYD>1kahPSll;4$Nn@yIzcbfv(x)ouXS?G$tRw(CaD zI5)D_8SY^mw+>g=X~ua&#`n28Gc_1x;)gSnzY8|Z?Q`S2z5xV!QU98w+FtLdSe0aw z_Fry{6#8(6iqJ%B3v&yDwNV!)IUrFy@*@3erZ8I+j6g2);=R#lIy@tWrl&f!6NITj z7f{FI#;32t-iIb3C)1nnWB^tsoHlQdzx=4*lT6&L?I#z3QJU*=a}>-9`Db_ltx#@qYqs_C_ybhGp&oyg#)igp{TuIO8FW~?rVUJaiFn(B7JHsYXMT!%9y*+hdEguZ!$zTr zX@zV!b#e8cx3_!nGF~u~R>dpc7;Z@9q_*x7w~v)4H@w@LRS{n@Oh{P@IMES#Bj9gn zKv#UAL(nhwRG^as5q6=Mvw3u7I16b^ni(O28}5qwW1$w;{d5$p-0^S>jgCNw5!R#M zd-Z!MePhGu(#b2}PIT|Jr4ar?A^*nm5}h#GH=wsig49OiYQV~7 zYYirIX8Rt<0e`OLa5w@60mj?Iy$|I{I)C9@`NlR-E9*bh%88#EqF-h@_gq^a^)wrN zMG30dcahxvmUFq))!%{tN}S5p8l~plI_C(FraRAj3Zn zkO3uDrPx?PQ5M%|Hpa$yMl(ls{4yrDtXLswKpBr<&t)2!`! z>x*c$e3D>0l>$_0_=OoWXuqg^xyMGro!PnOe_G`YIjt)nVtR~h{xXtX888B^KnE5e z^Xn^Y32Pzy?I`jG&WzTseshj99-W|P>3sb}Ev6yvfUX51OYp7zqs9K~@8eSU=b}l< zMD@44WxeOk($kn`+w>%@?Lx~&OG6$;heRR^m1rBWS?hNEM57~3I8*OV51HI#ij7tS z&iEbA?Or9d5ci_}imny>iLwmj?TUYWDN|JF!O8naj**qoMRbjzHs zWbf`rW0Zy0s_rpP6z*LS23Q7#7dL$SdyJB4z+t`C;G)csdkC9H<(T;|v*w|XKR*7L zlaPa3M3itPV#y3jLVc+)d0F@vQNt(6q_JK&tQK2gxtxC(-6eNG8WQfyu$#PGPjjCE|zVsbhhnY4{4K~@C`*nUvW zGl+`7G5WaM`45+Yw~aECvvJiH(q$aGlp;bkKjD>TIyCth^%x{vt7pu&fgr9k;E@>B=hPhhAtWxj!?s_TSyQy~@sVNH3$s=MeC)iGdgD3O=C7W3o$(c7|MyYZ)P9W}l z(VPawi5|l5C??#nX)xz_)^owhv4}9N?x98Jw9HBl7juev zj`gQCZDRM(dy=ZEOd5X1>DE-!8x*gUC*24`F2z1_?_!{WqQdHCs%X#q+>{R=I}am+ z-rWaHq7G0I_f8cz*eiGGj+{yt12CciR1R_wwB8%nzU6=gwZuzGu0;;ORi9!?)U8Ju9VE#TMqtg&X|Q ztCoHFe@vqCrom2!nCImGwoQTad+L7jI9>d$@Y&_xUb5}qfJ*TYP~SzEH_HrP7fu7K zLKu^98r4)(HwwW;ahBhHxnu^Qsrn08dzM-nnuY-q)bm1V2H zHcvR>6eSxk`IkN`l!QKKD)2?msp3y!Bd(0(Iij@m{d`n6+f zESkopKlybxLjj0f%ENvTWDtM|TZsaq8yUkYBw5oswiT|r5EWJ4J%w7#_9KLV-z-V2 zcv^^+^*_Zhv(rx3( zQ&V$IQNs0M+pm%LN3_c+6%i7%YlV-ZkwJFLob|RKbC~wcl02gIL?bdcepCOQW1%`_yA|hMfWiJIHJ}OL9k|C3|i*_7TF#^X%i0>nk z=0$}#iPSLfakrXrvMs|ZCCNa=Jhd3Z?FYhC8j}Gpo0Ok+h}*rWxYC5o=T{f?x9#;6 zryaMWM*&mFkIX+zMOl-f%v=MkyJ&TAOO@*W@k36`#kT_cytcby_Eccvp|>a&`{S8jpJ@7B68-eXB`NXEd?-( z9qOm=XBH|;JWf$8Vkial#wGK_CO*<;>bDckvZ5k4W<2EYH$eWD2lBTU)cS{a;fERM z1k~obR(#rR@r)xiQ;|U~&~hHC8||CmdpwP#Tb%a~Y>sR|$lp*ItvBB=qjvGMPf3Jv z_WaG*4}=p1YxE{L04I!50?04H;XVeRK8x&m`nKj$8DvC&Kk{(PR~@52BaQYBt%?a) znYczj=`uh?`nJron1BeyEc(1b)I0lr)!SH0|02#*(e!;AsWHQIg~D?pJKHP9cCI(8 zw!Ibv=UZsrSY}f6&~Mt?;-1Qt#fCG15AVqecuz4H=^iFOS`4w2L&WD(yoljh6ptMCnFAo{X*)nv3EM88q3ZpE5<4GAG@`42VmGan3?#ZNSKF` z7>kkNPNBS0hhI@({jryy*IP(5y;5}ckMxT)>kj6P_OfkpV*hVP5)dQ(FN1KR5!iL} zM9gQSqr6u0Z~6J+q5OQ=U#{QVC_dF!3AAQUN7l=#*B-Zt+Sz>;I5tmTag2IAi;l>H zi?$2W)o+Y9^GXon(ZGQr={%~ca9v3Wy}YqX6r|Rv5&-KE)l7?oyBJXOwf3~r#5~es z8s{G?9ZyO{R_FKjbQ^DlU{?5UK8o>vVZAg_<{4aU4e7y&;Y3wqv^+a^beJ+L}pc(t7m z+)c{K76|>0Y~U0v)V-}R@$m&hHd^xZdhSvvau`D^(|79}v9jm)g+3^cJ3O*Xp+Xwz zS+iZ_7c?AQFSkaID!?fu7WIazRk5P@MyBbw6xoUUmfnv8#z)560%Ajxno9#`5K|*v zsy$|IHAPRe-!IYg?_ z12fv8m4M`|7K4vlA1h=Z>68R3(NnCF-dT5MeZ+|OMfVurS$+ud9TL)rbbW_gyr1WJ*Z00_x%ks{=A6CvbzQ&O zySOnpd=R0^4fciT$vaQdhDW{{XnWNvgf^_9U%M`fp{OUB0B?ptB4Lpsy*Y?@mdI57 z!$rmD(J_;csbZc5pF1&MNu#$BlV@KMKQ@TFMnX$sF46PK2zGF zy~8JlVGAn5Md3+}Cwg5kb_q9B2Y3FDa~f#*G#UPWu9ZMA)mDuH;rHM%QBKUOJISi+ zF#xk&!}{a)J(gMMw(ZlWp+z&llH<bU8iu z`)YhsvjJq>%jPx7RG%@z+sAox zG|jpjzDc!wcs@?*c2tt8RV|C=F z$Zyq8>rdSMB1hvNS15~CS*{_)wrjWyyn>lFy-t|U-*BJg>Ppj+)Zpp{ycN!-{%ZMg z5KkTdd1_ZlD1F3z#@mlrQ&#%ualL|L%Lp@XsWOg7tR*I;4q`Ua=Ob(^0O`thLzmI> zm;s;lf!wQJ4sd6@`PYrGK6S6|x&Pe_!&l-a9C_emKr)-J1(A31W38GmWq;sxf-mtZ zT_Q%ZumZ&tf<-a0R8xgSz_niZk~y`vzBKPD*{L)rtJO`jcft+d^ zngR!Y$A*q8&NIAj@E1OE4&l)^$+Jq>c`brtH_AGVQ{DErC^(b*7@YEFKLA(Q>jRl! z9r{_YDypTB@*}(b+{q|BU9H$h2BJ>O_fpc%I3%Xr5=p2TA@{vb4#n)mbN?wnEd~FY z2BOjb-S1>ywx!xl*Ahvc+z+?Sx|Vm_CsqOfoO^cut*Y4N?JeKX=|W6vBMp@^7e z%HDzBDq&Iy^TYMGEXQiOqVogk3g}It(}*uZCinVB@(u30+on)%mXW@jm@;g%uf?+D zqBI8D2tpL72!!sx=d@b3zM46 z2L{jkj+8;6*8*b+Li7zB$$zqAb0;RHPi%E+zI!jAI8vh1$t6Z=44?OgAlXLoU_@x5 zvSJLb=@$%hF$XhRu6N#L=5BuEw|5g*$LjA`=*TD60|Uf`%J$|ca1-uycQkF=X22Ou zi=U3-=~WfZc)c0u6Bob?{v1)%k_@cm*a*)NzZ!ZqE;rI2hl9(|F97)cZ3y6L;_rp4 zY0Dr*ht%hLQh+03a(UH2@UatN#jOzCCEW(v+i%)pD0di|zq22Wo2FQpG}$Sco21X+ z7(WG-@61!i59*1Wd%EbDwz#hIHQcvq2=|0ox4o8?&c zTKS-L;{duLrJ;V%*KYYB|A!oQ_g+Wv@Haus5Fs*H;K0~7u`Alw9?3CS7@H#r?4j@P z8_I2nSi!O8#?>;8-69H?6!@M%;j=$el}a6&@D z_2ihyIxcFDg2c5zBHAB`s$&QT`Y5niqW1 zlGE`A7^LOKy*3T;h7{$iLGKHY4dj{FOD{?_VGBVNXAXuNX#&gceGpxUrPb4?HdaJn9sernuouf+ zlv8z@X{ScJzoR_A+qsTtW2kqAnh6Ew+!tG5R1cLf#F&UU4WglqlFlx0iuTC_q^o<; zmc9rF(d5z?vCABs{JkQ{??Ptj&;k3drvS26{Of)fJnX#h!Un@JxDlI$*~}%?Sgbf< z=}{_O9wzrOwYieSt3zVafEIP_3SNnIA}=?43=Dk&xTMo~aQyCu>gt6&_=<~f~e-e2xm7v9eS z$AuVnmP;+Tx1A|SDNq!gSab*B_+oAlKYfd{mENs=jMO+nE8!kFfHSx;d{391Klwj) zu8!~|?!4`G!&Iu}7w}b1mS7EHPSvDP!J8zZiIUq+J^mEYarN_#zVM*(ymQF z{B4D_S9P#X3CF>M22pLF%Un|l*Sm*{=Q|It_ zc60d74Z8EzmuVcM6T(Y15j{vf$o`k;BZi2!ity?VjRn0n5ryJ|*33dTfAh^q8f>{#Nei${gkB!7J z)NR3s6|Tpj)}6HVLt=*X@$!Qe(XViCpVzO}AT@in%Qj28geYpnO)ty(qS-=AWIP7i zt8$I8LS+@~)*U-1H?cwSSnZYs2)*sm9xj9BwdfB+Aw1tPmBl>onfnM5C=AbWBSP0{ zX-^wxCYv1LX9^a173yn44rk*2=%6)U{hvB$9!Us;$&0#-DGF0})>PF^b>JYThYGL! ztjC4BND$24?Ux)EfJ1N#CAr>bo`DBBli1aIwJz-u<-a`p22Y(oO(mTM#)e`DzqZzb zkyv5Z$!^@X;2g9(Idd*TWg(To*VipY1e(^nKq3iGY~o1^Unrls(x~)zMgnE)yJgJq zqddj0wYX>mx`*ST@&`vhW*d2JpX+ItJs3CMvpyG)=YO!$0rC}cQ=>lwQ(T!vuDHcz z6=e49KLf*686saUe(rCcCFg-(=l?)sI{YQEb0PHSinxvb%UzK1haIrBIzgO6tc{Q* zj zX%=$`U-cc9dF%c&iu_CWVy@=w1<4@|^K4+Ms^5iJeVY&lrwhkFekRJhh~ajU0G8+D zCch!=)2Q?J2d^m-XDj(%b?8{uBI-4576OCyo^-$Gce?A21#h6VYKT~bx)n`MW_G9l zL}%iS=r-u3b>Hz{i@l@IvTc_d=s0uQqh>q1Pw7ruX;w>DRo{#?nW32|j>;OtR=z4} zNUk@JE@Aea+#Hp{%QjFa6IZMk51y2i#NMuhYKo`(-qr{;9FFnp(eY>Hdb3n{1N`I% zRf)D)g$|x2$R6j**yQk$q~G_CYVC)i@kf3WOkMVP)9(O9N8On+9UiyOSm1+{`mEdT zy=Nl5&wB5jAqMXO_JLvV@%Cb9){;O0Pt`& zPzv(4nTF1h%$roRB5{c+yALs4_mUp)wcjx%#LBs`zWLPG{FiAZO=%Ul$};99$<5Yk zP9;W{vhN~GO||)D6{{hPQ9VO1aRAJaf(|io2*-{!7K%b)hB*C1 znOou?zq_E`#1Im`MCz0DA`Z>@I434I)`#oO%WI38dRFb4FtApqm>&~u8}alFs={s3 zPJBiKebpvZMvpfm-&(?IWpNQVv5SA?nY&}%#aZ=@ACu1xx$;OMfQ9fAZk7NXZSm-AyuU58HK=r*^NmaDqg<5|{~)c_Sne zTCF>IT~!ugQWeRrT958JtjK-OKd}Ve0uU+PD4)gXVr3E$S0=73W&jpYUF?vcbgfXO zb%%77a^#>7C4cY=0B(-^e}?7Kvz_UwzrJ%_|PhnnZ~{Qb*IL};>6Y(n-++;4f8F@2~#9xFw%QndsO ztYE(PjZ)PxHI5^E+oV6$9LXhlh5LzU&I1x&`kv9wJV`^~QQLHily^Zzl$4aWlX}>j z7r4B*BVSTzKU!<~B)J*Y64#YQJd3r0mBWh;alJ7_k5^3AE=Bji5Y&s4$Jf>K(0av$ z0PFI4i4S5K&Jue2nH2x{#G-=J9vq8=}CYW!#Sz7%d(F@^H1*#&@w$$!Esy_D(XqJZU0c`!z%^l3XAgrBV#a?KcpV5P@v0LSY2(@47$tl_g$9rvU zUAC~jC)F4Ea>q=m@w|KcCW`Vv_7eZ)kq)dpSkzcyznX%K)J=IC6-Z}}oaAAgm{kRd zCJoGek|$yQxxlY{vz|nDs*#c8y{z@J$Sy|XIstK zfCZgSjd?E-jK7>83>OKdiRFg8s+>}5(_(yepR2rB>4+*N;!<9JX)y*U1t!J6T3U}M z1Htfn{h7(i^o8lMI{w1I>Gdi@|FtWQ;ap*Wg5p6{o+xDz>Gauwb*c$3N|AzE4gx|) z9K`QwUk6!GM?wVJ31J|I9|hNX2BzQ%ERI@YV`86JjrB$jnJ{1^7gfTe&V0f%OE4a8 zUDs@6U`&;X*!biGUFJP3Z&8qP5ecQA4t6ES>^HXYAgiW{;S;WJ(Q1)ee^eUy8keR% z8DO;4uPJ#1qlFc!^}o%Ne1FM$urZ%m2F$LGm)n)q)~=B%zR)Wo&6>>xJkvXU%EUx) z5FFoG_Hhh00&FWR@BGj!p3H%dlgm+r$=3X2<2t&2sVfbcm$T?3XlKy_M2EYTD&!h6 zh3U?UfyCm$9o^DQFK&Ldc=kYZPk+K&)OMk%yz)9W;j;9L`(8^9XYGM;ew(>XHw#2L z{-d|d{vY1{dch@x{)YnKI1I8K2k385{%bYLStu`{?I!z?)v75{Iwaku z5fP~a=>xn4jIEIDLuH!M0td5c_`t~Rb1Eh^8;9g9Vf^!HVCovftQ;AHKND@|&6vKW zf8o*pYA%n;_*f*K@np>DX5q-b(f=dmA_p9-|o{j2Y?HS-wq)s+;~AGgIPq>s-1yhH$b3R}dCpeQ7%W;+vr5U|UyO@XbrxpnlVq zc4Ue68NLSK^cH~Q(H5-s27)h+X1nfXpz2yiv5#Ik=>!GJs`T&6XqDYVJ!>6Hf^^Y$ zejB3GIH&wn4ku~nC>-h%XimD=QI0!4OI1w#X{**u-aorR;KO7a^{328j*=gCcZT9O z9?fShSEgpj>oP`)8ZGC7i!a9&nHmjj_#4pnDv-9}W;I7-l+^XD?>z9JRb4JS2i&P) z`is?s@khSrjcVI&c1bS0Jdl_0hlq!UKIIR-xY^smlFMZlMley`ox77jzsbw3@->`|$Mf!Q_P}`Uxd`&_P zP6r>51pl=CF-wj-&@tOtC`%P3w+Z^+-BEOj@O3*jR#_EMjINw2FE6N$dgn>n17D|{ zIhnLbP)JB6BHwJk>Q}U%)p>+J-1;QBHfnWG%7pF?X(kxS6HjXp*Ju$k>um|5lngoj z{>fiF1@E0D{kNyjM3|o2!o;^LViMr#+g$iX=-U%dx}~EYe(ZQ>6ve(`ifewIqtVbI zeSVl0$B_rS_|$Kjssdt`n*1)O+q)D}pj5n*lzI^cXfswm4L=8>5aXTMW za&T4ff_iNWuWi2)FXDSqN;-;X1P#vO2ULwWKPS_}2F*KMvp^|C>*VDUjSgFrhP` zFm2ONS^fvR!iC~CQJ5P>>O;>LGDq>`HwdD)yk8(8VS$yKHxn%C3yC_4dE`x_b1aiG zpTCj!pdOB9>%O=6&9a3duS$4T07UG z&Et%=I^4XSdW|5hsANxMFI%q?*- z@2w9jZ2OSss_j1p6d&kYlG)Ymxt6%T%!F6D_P-q{HG(WSyB^oZy^SU_wZ4l zdwx&{lzw+M%wzY7LL--P_sIbTVw86<)0Rx46A3F)7=yW*Sj`mFGOP}?{#AiI`|y7< zibVN;iCz&t6D(c%Uq62&08jrbh?dGJm?g9cR%Uk!%Sp2#CnrM+G=T^~9e4;S$Iq;Q z(`a)TXI4kM-$RVNTFDwK?qf^eSqT=r+qv6GG+Y0HSF_nDKI!w&${(ruZWcgoB;Cqb z&tEL`GEw2H>#}bcf!Dh6|E=R`Nl-WJzvk~}iJ5k}U=`pbXuFPOc!!%?T`-B>CK`4m z_~jvo{41s)whOi?uzT zgoPjk6p`@`kA|IYzZi4OTDxutIn(rnZIZWUZ&_j1WJN855AcDN#_3jo_Z%AH1ObwsjWW@|?W9whwxr za5|;-chGZ_y`v8+9#@rN3T|pTsC{XbDXF7kFOPju3ZAnn&pk7l7eg}|9K zG3;==L+ChE2}MG($fA>xbbA&=i6q6Q$3l>tjvZlRA?hky>#u)dhvNkHD@Ac`E3K36 z*0}gqiL7A58o3F(j%23gsHyq1bwJ#oe=V&&cX!H3nKX^O)0YBdS7X1G`wU(C3@DBk z|5Y3@Yo>kMYSxXunlbh1ix#x~i*EA>f(S=(uEiON6}1x>&Ls`3Fme)4PRC!ob9;-! z^~PsZ%yQQrfsJG%`y%u(ZZAmixOAMGKeKCgm1*ACIf@)w^!eITv|w1zT`GiSN1D-b zce6(dXXuNFPgIm)izAL_my;ydkJj>hqU@!k#j4GkS82t+?@Ie1D9?5qAz1Z6q zA`h~_ETrf^P2&~pm*7IYTn2x0x+##>aaW_mXO(94z_zjt;_%dqEuyPXV|4a=XT>2huV}rAyV96+-P4YvOx^3} z+NGj|pj@>_De>}ffp6u178fX&|8uyc-MG~D_BlS3k1miH4<`_TQ&=1Lzl9(`@G7pb zM)P8Y?J61}r(j3y*cDT{6uNH7UCG(B*a6ze&Y`kddc~*$&hqR4# zZ%CLiQB%=u^BXN*}- zg-s1SA2|60V^_&%-uE$9DaL!p{_l>^zVzX=_0NPAra1m#y=PXP=(C}2vi@(e5fWA7 z-@o(j6t-V8oSXQDZ=7zjU@Qeu$taNIM=naLfqvoS>4ZzuPQd#h4jsc%kD~*0OYU#k zRmeq2GkH2}*8%Q7$0G8iMHbh{H+ywQ9gVWNFE3nsq6*IPkpE!OxHj7!XC;3%D~aG_ zF!zcxkSwDSE87?A1d+ov<*dp(%i^rd8(JxoxPn=ruY)EV&8{ylej)*02K^ffd(uHFYx5_mZ(C1WsD)$_^z5mn!yzD;30ZxXE+#LrAQTKN+f#wrz zxN_{9IwP-rAYrX9C6r^_+t?o-e3kNIbN}G@>$XoItz2Zjo;^O-i=yPG{}7_$IPH1i ziW+HG8GMPc|C_-FL_{I{pMeSpQO0QyP1Cu*SpdqS??Vs}0pBrlY7yjOV17@J%8dov zN%5i|%A?S_?x5FZD*XnEm^Uv+M6v+GOY}2M zD|C!ibbbT|24X!4?Pklx$enbM$l_Vr?EdOc+d#bOc*Op_gK;(zwNA;|I)PKB$UuNH)rhN~_M={k5%QzPqBMW) zAhz?5=3!GoUmcQonPCTr>jkvbPp+OgMDK4H7d^eypCV5UWo0nMGNhMyk?`xNZl^*z z0;W<91sP)*3fx-hnHEkEbxwHYSfFLucRqlc`UETgedmFa<$yM4oOPr6dRJmi7+1dn z7NaS_A+I`qEH|smu6Wo2MTXg%Bx++&nvx~8AulitNnf{K{AF8uavw?TG51i$&V;=6 zSKl1v8|fY_dkeyCr7Tj~R<0>TW1+N4Q@#}c6iUs^ecwp)9rZVi002#4 z0GLuC%geaDxY*p+yx`6IMkKuv+h0+62!LAlnS zbKCR_#R@J)|BoqArYI=!;bSN(3GlN2v@$x;`IHTcJ+nGPw0MEaeN+7Mp;1;p%P+jd z$A;gFr0H_OBWtnK%1w&Y7p>Co`K+;L@@p}}nvo7wZZq_X-65woj0rWB0YVdB7;n?0uiBl{1l47BqA_Vb6jQ~8 z@6C>z*ITDR+#sefCdshZxH#!Off7Y4Q0jjDJb(E0U8St&Amv1&Z}Yx%3BQ2kw-^sC z%36n70~Q4SI6c7b-4h-$fc+fBXLG7GrvJ^5NNJ$^N2p}0r$nD~HP(EFG7x9Qdbyi@`)pDxWf36vf$9NtcpboR_D zD0d$w8oz8wj9MLU$}*+D*r>WF3P{GzIoT(_f?Yrb{dYo*E>Xk}UuV)L$R`$1nfBv=0($T9S)y@D2vzl+p&HbUt~z82rA8&6l{EP>%ecY&F(;4w*B>Cv%0(p#ekd;%wNG@>ec*M$PE=G< z+4e1!9PemY=hU4ZBlvAC5CsOKyV?T3lRR1N`j-uALYv z0Mu!qyf2_~Y6f~I2_w}7Toq^3>xIl7RbpdQlQYC+!Lx^^4@Yl!M!s=SDxRio-2JCC zFjLyaa`hwpn~O=+j}Gxz@G@s!yvs5^w|&z1*D99-&iD*qNgB@+7o6XvfVq*d)~eZS-}+apH0E3DM^g zGD3@MyIpt)zK3o*X~{-Nc!}CT9a?GKH`9M&@uxN56a{iPx&1!wyN2G%w)vl(gF|r% zC#_8XJP{H3{y#V{@PP;}3q;;&VWb_z*euhe{=(>Y>Q+@@x$MU61&3D4dg;*`dl&j* zik|uAd>%U-YtC+{7DpX1h!B~pS#m~6p3ctH`P&Qhg~F(*cadmX_h++UQ-xdeCWN@|8+714aaiZ7Fes*0iv@dY`=lIgsNz1=HZ1YPh zC5m+Z(?RY9d$R&|OkK;zD3S^`-H4{CAh_8CtRJeCSVEldS9y>7}XBMy4<%GfBx z^e(tutxxy1_y<8yKHB)cq~)gdy9ApL;E8pKYO3obd6nh9X{_+Bvwbz^#9BU zh5*DZa98cQTkm%YBn1u}zt@;6{AAX{6fYjM?3c$$ z;J3NV#d1sih6cLn+(H1xr&z%U25Vba*TL2*V5uc@43X5mx^a+~Z09uf;M-xrfU6gT zlcmm{{K>Fi-=#!C(u@CyM*;KJCYBS6DJVZQ;XUWG!EX9NffP+#Q{Fx-442{ePZJlt zL>u;<(#9l+;5;MRlVfxjuvH>QDYkBYJ>i-cozv60qi?V}ZXpP|JGY4K#VLiVE8Zp& zddF~S!e}eg%#N%D|23n>N&SyjkEK9T2sF}l483DyL}M2J+geeRiSlxrOvsOM)df&A zx{hiblg@b8IRx^#9@)-%_z>r8K-{Erz=1(WZ!#RiFl?=KvPhJg&# zKdGt_rQpK4#fA?OP;?^a=QF^@cIR@DRdMCy)> zxgR4p@S56Q8_04QO@vVkANP3UB9Kb+--2$8dYeFyB-6L?QTg9v2X(@puERP-(_HcX^tfRCLT&cXrDOlBc^ft#rK!b|yCXjYTIGJ=8h`hD;?8Nhn>H6eMnwrz zKA!*K;_h^?qh>R^FAQF#%aD94j(WB3PZ5759M5^?0RNkBC#QQk30(o<^m>uMO*=Ky z*pQI_FxzPX`O{*L{+ZT3Wx_wSNBTg%4$`5lhOjGH8sIQTg7x;;b%2E_E;PKc!267v zitI&QRVS03!>Oe1d673uNT4*>4-}b}Jyd-gj+^bssk!-PS@ucC7q8Z=W{T$PKBfei z=3|acm2b4DO}PI}+^=H2^kpR*Szjw?ogm0yky(nYapz(EFWGt+J5SO{J3<)la&V;0 z0B(+Uo&Fi)J$A~a$K2d6m4s&Wfg6eshiB4$GoA-D2EWtse@6kp=W|1(-_9pHzdQiA z3}CB&7Wqq%^K|{EvkbcukVTF31FUmC^ga#(TBILeyz9Ktod5DH#q*opZfUXLCdXvB zrRjT)Ir$1qfl~U9uBovs)HW1X2%Dl}=E*d|5Qam9%vSfd$flKNd?hgJ59tXo{o+h# zfE0}V3GQJK#g}`=6!UQ)N+v`ICj_gYer>|-#8YK(pPe*j=ObZ+%Y%`!4T(AzhXlK2 z3v26NC-uv8A|sB!mlZ{qLd%sKd$5X>?AF+wYG){d5K}maOxpZ1&$;?@43IOOA)Z^C|N~(ey)eXGCP!Cfzv^Rv$ket{w3cFo*VAXDPkD|9=60@ z?vFM$l~v9t^r5hqNpN_WUF`RaP!%e_Fs&PW_!e^NzQ`jE`^!-@AesZ$kCMAV9iN&#ZCvTjoiH1@ByM z0m@w5>|qQH_9j3Lg4&#dXUh!V=`CPUCgMZhz&mG|1;v_-+Hm z%ni=mZKzr&4>74dK8CN_LH^CJ`5x$o5yOVC$GktJAGr4R8uZkE3)AZ7ZxvNCN-?e? z?~WMaXrCQ74ZpxKo>O9$BnOS0dOop9atkk0B92s z6;=}F}%%X_+gk{t}+C6rAXlwjJ=mU>T<(ijd-avJ0L zViAb+5U(j?aXiTWnuL$zeO6ULY6DOEI>H*`OeqWr!bG_Z9$H$;5vqO)U?$D9s_|3tlme9>6c)9*iuTgp7y8b;qCNA52=917z_gFZ0bm3Z{aR0Z?_kXTC z_=AyCKs4o}8K!2YrW`B_qJDk?Z#2W~rwA}Km6#2U=sfx{3d5EQXNL7P8zZDrhKg4N ztra2I_(e1Ti8B#?wK}4lT3Ul}HB!v*7ryllT>UyDzGZr?HzhS!U9e9Z%0nQ>O!bDv zVFa=o|FqWCZFeKk7oAdIgok>Z&D-RcmM-5(SG8CEdQ{N-!iPDnatan?^+Hg^;6e$z zvhw`1+mkr(pK#zfm%q^~JkOvnmVU^%0kk$f&_n!VNc8;E8EXJ?8W@+mbN5xw2Lc8N z;Kr+Q$-h$7agZo9BI&aAyd_)h%BeA@gi4>+6~_Z!1@w zQF`;*4oc6whm{rCewy2Izik%EV6~mb$3xJLC9UVhW_e$R>WKfjGyMW6mFb4?n`&HY z;6`VUoeeO3wW$2W<;4wF0l_8>%M=F$Vlv;j?V;kwNcubMrv_MC`BemtA{3Yj%2xBY zmFFv!x6eWw$vo|nv!T>~bz`4ta+^giryB2n@qljfD_3((h8C&-)ju$t`KL0%0EW(1 zHuG-ePaNZ>pfS+v`p|vCLLUbApH<;{R&TbsZi9>9H>0ae9m&LhbTU$fAywa^Ms;WUHmIHTAK#)13#rK zC11i~TwnbsO8=W`NrRGcVg?+WcrH^P)YS5|fWVrCc1+iH^x?1GLvVqF_&j1Ff$4HzzHa*y{OqOcTu?_}~DzM^|Osj36XP!n4ei z|3jpg)PqN@>X9W>$r4^e9%s0fE%>TXq|tu97{1tVa^jd-5;UoLaF-hlE=OthqbpBC@&oVN1a2m^ z==4Fo;^#~^g`>?x7{>hHzr#l8-iwe)V#Uro`~rjuJ~v4R=5tX*yveejcUD> zMB)~7Ke`!ay;ejacwHY85%JG~iHk53s~l~D*}UHaKM;HS%=iwU{n)4QU>WVX1l!zh ztONy>ZBP;p0>6L!>6gWpyF~o%Kjv?K>Hk`$JT;W~@{6$*Yj4}mG%M1p$9@z0vl6zs zzk?Jl;Tupcj_J)WZ5ALO9BVWBAt1TdUk`~0^Doy(Gf;CT^YkN3_m^d;ipdX*(yIpR zZpql98B?Sk$-0ivdkMw??Q~j?S;wsoS&tT$Tilg{4 zrV}BtpDtboE?^L^F~-0Wj`I&1U!U*NSC(4}_zgw7k{wjEDq&_jV|RO@M>~#U*8N;e zU{FYGr~UUKjira9oAD6+;Rt^0`UfjSienxz^cT~|YqqAIPcz1D@MRCO<5hYwOY$g! z8z0ke5cRQJxyG5>YD;1A&^Ywl9aBhckW0TN6UBIzaQ_KT%NFUVxFy?-585(xy`WrlGt}Z1Y(glDs89>jo zCpmffpB?{Y@9yMNn3l7_Z{dncJ}JER#!K7{}zco#OQ>;=)f#d&QA-*C;w3;qr6Tnin41xTW|iRImwfiCcr zsQ(^fs<@Cds41_xv4MCt{qKmI@SA&+zLzpys^IpQr=$!gIG0yvQNhI#(CyW4aK_BF ziys8Ql{S9;>6ve}nXa49m4Wp1{3aM0+0b>%^fLi(L;AaDEv%I2DeflykRoMlwQr=^ z#+0;>u0-6|-es!G+i)W(s_vxAfQ zEz5vf3oKB9rcJ7n?A??8u6x+}-$m-spxRmg;D>SPq2GE|S313!cv0W(cOE5@6flAe zK!eQ#g(s-~N-jo{HK+sjr1Y`=oZs`z7kGv5q6Qh){lwe~X2O=qeq*HR{U->ced9D~ z;iq%JY-@hSEVjky0HKBd6vK$O;OKi2(>peRNryZAZhrt!1@*~t8d%cPlkvKCo~#>RReE@PYCJbL%Ii_M4=$<#*T5 zS9=cnRCp(4*c*z?Y^7uO0tg*$ zv<@p}aS|;u2JG-e=m;uG(8!ZKnlXCNYf>AKZt<%BA~rYN3b7baO*jk2%nQJ_$FKKs z;p-X=DA?s4qBpWizlDlXN4$5**fBPN*P)vCiN?-*VJ5pCg?Hv>NP&y&v#$G?0H9SG zmwt3UV0D5OnyHI_Vvp8XTMgJrBX4<#8lI zS&FY^#T(maZ};_Lh9{adEtW+4^KjC7jR%5pX?jx3+m>t0nga2gAU z3avgqaIuLC**1I8iFctjxDzSO?78%h{HXD}_;XEhI@9*hH;&NWg%^IybmH~SBII?ZKMwIF zF*E^Z&D{a{DR4WXQTv6k{Erv5F}tRFS|3|8$FyJNwecz9Q@#=+a3e3Kk(SrmQa|7} z3{P`O5)XJ(X9Gp#vAoRxDoRCsLfb4mh$UYZA(xDg5MXdJ4~c!I_gZ$lf5SgB%kEk+ zjocU%A^)9C33|Z$%R~|1jK#Z_*;D`^XR-2`f8PXCzSd?_obP>rj!R<;|4uxo)Ij?H z#p>O_Y^*p9JLg~yk8e-acLe_mzX|;7}ULOkQKI-gMy8${8s~l?L0q za>IR22v1e;KGX@J~9inR!#}g;m7mFHOJTE&qt3tLmZMdu)x@4IiI7|oj0o% zVil%0!*GfJyeFo9Y15tAPuFyYG`}xLJ|ekOUpBO?wL$_u11>inW<*&z3bnyLd^WgV z7amqKDNpVoJfLoWmbfp?tL3!e@$@9 zyb~GuTqc`mD!)3yk@6wYSq5`J&Ku#QyM`{p!Rie5zu^|%su=S=R+fwSAktTF+Abna z;dGWc*Q;R8d9oPuZ%V#Ae&)Bx$b7W>Kr3#K><_|bd10ax7cXLN-s9$sD_Jt@??q0 z-POg8Cmi=+6q^=R?^_Sw3t!;hwfsJjwX;yV9Nzzp0xbR-!R{{;u6;u4vNA$>Pnm#r zGW&a>_cw$`M)VFF4y`J-Ht{bD!gMk~Ui>T_nHf-2Mb}HNPsl36sGd8$| z?9bL|>2E9j^9syZKv*z)(M=N{X4AcDPh&Dv1Y6@W|9$5z3vpCK5|RzOjbzM^maa^{H6V&?(36V$aRbVMn7qA-PRLjtuJm>%F3!xg z*seFsKbapk(C(#3%0BtPSPm6<=53n$pyxr6QqqQb{yf`$SMG~qxi7O%WH6cplWZ69 zZ!yVuo2;gaUTOFUwh?5(G`w6h{+6?IQ%Rg(E6jW7ncC2srQ+usqh9;;6OF2k4a@K$ zg~FM3#A&*q-e!+$`MyV8>2tI2(Pf+qA=&GdRH;WcuO_R09CFi0rkQ}-WTLeew+-kR zUmKs0u$i2fScua6IX;2En`Hfaw4OiP*t*`8dg8WI;9IkUu<}XMYR=KgS?g;n8pL2g z#jV@3i~1$^_61_5TM;iMp0XdmpB9{yZ_$o>TaELQyb0k6#ZSk7-=3M6^ z_l_wj?Ga_gcW&t_2EIrrB6bMeBF3_-twkEz;LI5?~!;RwGJ<&+AXsD| zEHZq0|D#-QeX%m(vZ?I5DWCREkNX!)L1a$1Kv-YHBQlLg8OtrlmK;pxlI!oR(>1y|Hs#R zN5d6&UBEG!#E9MnQHIe=Nc7%gL@zV?5E3PN?*tJ935JL+5oIu=MK2LV4U!;Hqej%| zo$pF{-tT$8^?qwvS^0DBz2|q%K6~$Tek(n3M*$BiKA<{O2`_I}P(1IxGvzEB=K4sR z#RgB~=n27Wm?0_UJp1~rTZdoS)A_YPbL%jN)GK^!8|Z7yx0z<~iEH0<^Go05|Cl-= zwCZp2K}3d4(G0C3>iF};@iK9s*@9!uN}hMn5uwf z{B*C{OL#ZHaG#cF_3Uv-ksW`{h@|+sygVC_ zMPypP?BcK89+u}6wIjootdtY7R_*=VwP+9jVy?`67R1NITZizr+m}=%3s`utR?x1Z zhNr<~_vCtKs`^(QXv*d!8F&0y9K_tO8){wdYqdm6Os*7dw74<3;SR~o#7|K_po{c{ zExx=`G8wm`H>{T&YMUX?1)?ED5Wp#ZOwYz2X3qw@q2XQ|g z@w7(lSR1}3p9#&EpPf~fne`Ia?k@ZFPR!cxr}0N6;S&$XGrRh}os(pw->BQ#y&t}LN2b4mwy52%U@iYFHcfRC&F{Ii=fLP1m1x8 zC0h>Rs*_gtREuyiQg(}O&!B6_Nv--MR`ea{sAMlgu+8JL(^PBIVE#;x2-^}!KyAkZ ziCna~J%k*dV0VpjqDHfQw*I(TPBB#g_oO3BN|oG7RbXDJEH1s%XRf&|%d?}mZjTW; zAWlMFJzi5(Unv5>w?LH0;K7JG2!CW__1&sOawFG z#?$b#?0$rHWdqT;)fTcZz15W5KfWZkud7~HhAbO4I`oacC|b~v zE?sTI*QS<}-$*|&(y*LU?dM)WuPBU6%JKw#-zELbOqKOLW%TEugSkzu+uT(r7nkuJ zRcgqNc24@f;p&zcm)k=6Dd|(rzZsOJ9qf6!z9z-5^(5{6&N~2sxqpANlJM2amtp`D z*1>z-^Aes$D$9aRl77<@f;k$=jFH7r|IL)x$?6Zmhs17*_Eb(;$O%-{<_C6CR>k;v zAK}|Xhu=e%O$dQT<6Bza1iPBX4suT$bFQH+TZZ4#D790V9%lE1 z!8l2KxFaaw;zHfC)P!>P@i5l?VI6tHB(aEw)iB#9h`0#^{Fgle^X(jB6sG*TjP&S_ zgBwlQ;3dfL*{osdEE>rI8lmky=cjJjNqE}6)@_prETJKuQ*NgaBD?~=3LE72Yw)#% zjST2{`Zx}9|6=@o5-vd^Qd-mMZYhnE{LeWM4OMRR-};)A9R1*-Nfef16FwUrC7Jt9 z4P+Fd%~!J79m(ZSK(r7IYm4WLlAE__bJ}dvQvsKB%DsY{r#BNatf_wz z8|FZDOO`-We66EVoKPe4t{A#H+|&10zsh#|8P5EY?Dm5dkSrPl2762~FeBICYsb9_ zZ^m4aeV(Mf{cvR0u~B0d%{Mo*Ji0{cc%Boa;xIRy_l?9{MGJZom45z&=lrOYUrFok z-NCcdV{SD3`V^9^!sOTYH){VWn*nOrpr}N_kZ&{)~c}OhCE`?#3y`#^jyI=gM zWq1L&C{TT}u5Iwv!KdEPilPW%r+j|t;>9c4z210yDYs*@FDQEtjbwbIPW`8}OBFbF2 z76X;7Hn=1&L%QoI2BLhGRA`9=YCDCRrf=shh~8JT$UQeZBRF2<(k^*AWUF!SO&kO4 zC`{X%l=3#AF;5klV#=v^?pv)K&;9g5&*=t6H)VH*ND**vCP;gr;l zFe0OSbO~H?Rk{Xf7*tn^i0)D09{W!JDvSj`b(Lt?WKdMs7ySKQ7xW@BgKn*Qwg0?l z($4FwzYm@2@`|G@pcNdByav-Ma%q6onvceY!W?hXm6uZpbM3{<@URA;Re0EDqzFxC z<6us+<}j=9;shYBuUc=ns^skJT_sDK(hW)pZrU3#RTXQ*o?*fbr1s6S_bgf{e&=}xGMtLGgSUHo*Hmok zqM;kB7f!qNvB#{4+~unRU9VG$czK9pR2rMKE9t^>eeBSJ8TRVbbscvbZdMIH+e!Nl z!xsbwpVY(yalys;H}KV`vixU0dutY6{te*(6u0!eb@rXg%j~R;@*0nteA-kl(~puq z^1yLaVA%ns2zKy(bA=$48ux$=FG6(zO8Rzi!v0t(Xv(v+;LDs|Ef&~YjivN?Xo|Ae z30rMrLDd1ZFLrzymLLftgviH*qh!lZt7{x2ygVYZ&4UCxUw-vjm2Exno(Ug@$K`zx z_Zh@UD7{#zTF)%4Z>3Hz{Bebnl{XusBTb%LWbCcIq9=Qhp1u>gZ7%6$r`onp;;K0I zrT>`6`;Z~IcB}u{r?78-yVRVhOJF`3MxmGnup&PyPO;H_jY}7TTtBlt2;8w!DY+aa zk)fgTQbd`mavvQQwbDD<^t{g;gP-EH;iUXJw+-K%3TyMzserWjaIYMHxOB4KOH@={ zY111$+g(Vm$jut1OH=;3YuD&)AE%KwEiQQ72Rq~uB3kJ9QYdrNibOC%ZRCc4RYT(Z zTBMrnyxrTsxjyw?w(fsgg{vGn8m%UE6^f2^)nTJy_zF3cVT0F@P>bl;dByv=l-aps zW|UYPLo(dsvGkkL6CUEZtvb*sGtsiRK%|)I`>XjFR-5azUihykV^_;W7W4WqYpm+< zF)B0toGlI=wz5cTFg5i6jLJTiW!aX98C3ab@}}3eKeJ~ywz^o z0U>ko7uF2n>*KRKbOPuK!PTV+&M=*8NFZUE$thBSjIy!*;tf(U$VabOzX0%kUzHLO z^GxJjy;_lP;tm;Z?TRb8j;eEMZxOI>m$jRX>ea8 z`xH|kNMIL`0oM{`&ll-~JrcalW}c5S3f17K7D+007oSVv4!<7)i2kJ3lP}WzOeU+_ zMSJUG9&$C>VK2!jA^D;C8s^^qE@re?-`VAHIrSvcmT`N6Li{j}ux4dGzaDlR`=M*? zZ0Vwo(-cCL(2==;VQ#nW6S*SS+Z`yXZZ^o4jb}2~IRsX~B}&;RR=-++Sdv2o=h>2S zcNZJwnr+P7Ce40>L%>Nz%4Z0VbU+A}{7JL*=?wiDzs&t?i$rFn#KF%R zWyAvrH2y?Vqqcl%=z;@P;=Yh|qyQx(GgRacVl2yU9K?oF&oCEmy=Q<0f*H51(sXYt zW8QcVH=+djv@+QXC|)YzFX$=}+C!kjfbp@#S+BnDUcz^i(c{TjfCWkBdbyfK*fa8w z67gzMU8f?bHo*4Qx#2w~wm??_rJdR8qxUj>4`^_2;@P>U#2s{(DFg0Ry(gHIT4 z49&m8o}^A8#LJXGxn;x6^X_mxrBUW=E0sHVP3oNxUCIUa2mV^=2>!u;>?P31AVf$W zACyahdjz$(ejH8KMuHW2Spq&HFQ5PR=3^UeQoz^u4j*nqV_7tBy!Ly?>Vwb~ ztw@&+*M0bs*qKVo1w-eEfG!amyhI(^Q#OQkR`@L$Y+l}Jj&?~C)sgIey{PFJq9cuI zABV>nx9T01DMOMPk?tWYyTWTyt{-@NCC5Sn?W2PIZL6#~v;?ZwADwRm{7IH)VpKGL ze|M-F1ib6Y!yx2`!aum;Mq~Y}>+LZJSA3+P_`+@PJ*WN^?-#eFOczK9T#7>dp z@}%vD8|~M^En2F^Q+^a1l*qjT^LZ@gum@;BK_T5G_Htf-$cKfK0l z582S4X-2kJw9KnU5F0_s9MjtmE${8IdGCtclst}+AAqJH^TD*u8Og5~5(U$};@+Hn zYJB!_S8uFOH%@6))qEnbr5}`%sWwvR+CwtV156;;28ED4m={`N41#fDpQ>U_Q9n5R5AC9lDBO6)2x z_-~0~CKtcuquT4BU6MU0OmYVvA{tR*$7Wxf8~*hPt8n3b6i?+7k!4{XQoi?;rO!!&zKFj3QK|8LsxM@CiOa%Z z^Ymo;v9#brWP|~{7frgwxu%ZUvISD^2KZVvrui{4$8!-_f%^ItI zhSsEf1r*&*I?HXw1^2&%|B3BO5TZLkOox8|^|cEEHfg1g^sV;xh%>@s;~&1a$y+*Z zfe-zB|JDNzq(1?d@yBp7GLX!|`w9h-=PW#V8^)bA%C92Hwd!l7%rK9g|FKS=5%X%Kuu?gkN#efA?P))}l*8KlDORJ5 z*+F!kVzXA80BqFyiTeGxy(OX&!$ylWIKybI2-nnIH?hsaA3cMTO{V5VUp_vvsLK4I z-OIw4Y~Y;0Nt?m|HF|ozW3R%UvqJ$=EEa#hoyIGtm9TL(d_!niK5^-BdysoMIWBo0 zeS7>Ga^GWO$+?59Qn^)6<;WX8fA*&o)d*qzyOgHy9IWT|&MKK5cGn=8^octnK9a((1&(le%7|kCrSya>cx~{Kk7gaN)C|o%N4%VP01ypJJ>I8NP*hqI z_H}q^Xon)23f*d6_KK2xEaawErZlcm02O^h&mfC$v+t3bQD!u)>^5n|{_q#w5Bcp9 zZUGsTwXgp3ikCS52Q}j6qbzz$iDgKx0wii!D*;l02K%(Xa=xX)x$yI8d!H$dLL;55&*Pcdw|r5{Ws{ngbxa% z092-nF4bh#`-bn(*a&^8nYo*TcXjjhFNJElLvp6cBwYUm5>LCLpfPl9v}Wt3aLKxE zmpc*LZ35WBsEaOIi9pRbIV!hI!u0DB{g-^VX2EljqsdX(LB^ovEcKY!sr#Iws%)Ms zCf&dC^hjS^;UllP-|RxFo4fA73GlwT4RuctM$*Q#`+d9ar@bvcalyOkXWLsqf8uVP zOHo;}H!~#zx}r5fAzg7st})c0By@%}+y*QihdJV(YN?+MmNx=pGqH$g^&K=`;7 z@5{oIHvHah_}FcIB{Fng1(X`^aCN9J_piZSTT_i>Wzsang?O0ydp6y)J>W z7C{e9v~@Ay^q{i>Sp5MFfy&1P==r|H6GSm`!>}n3U!hfR5BLNeNmedz#etH~B@mSQ zb-TEo38@839MAa@S*g`ui2v_}56Yvg?uXF`6DlQuf3qE}VWAsWN(P@G8pDS6L(qAj zqi($Y)I4_QOTQdSBVEGju&mE2O4!k>Kzu7uZEqycn+|kCC0%Mv<(P^D)V-d+vKC}s zGQ^GQ7LJUfZNl1ULd`_9)#j_u4tb|X6-UTkmq71nkU|NF`KVXYM>$Y8fH;T?5@|0! z&Cqr{*0R9hAjoTJ5TNBl!}Ea}#6{oIaa`;>EhWX_qFo|~zrh>VCq(s^sQF6%BKu`Q zhf=J!X3%ivw1k?rOUC-jbdDSwN#yuych2erE{wNcHWu{}4Ke5&x}_SLlakbV%2W~c8qPbny+;~36y zE5JsC^G7U;A1ZAv(a|G|56z~rWt&T+mXj!}*iknZAFdo@8Zo~X?>l(uubMS>foP=3 zn_kCVyShbzH+>ChMS-1P)mn zOpB4|o$yEX#?0O4VegGH7gvq28B1T6j~11AW|O8r%0uOIU`-6)SVOX2P6qfPz-D4bk3mWMim z0Mx|p618vm;IZ8wRpk<%Ilw3UghsnfK)*}jX|!VwfBNxvFJ$Dz^v?C5sZ9p3QeM~X zgIZ?7p%j`nZ_=~qXWy|hAuagfUxY_K5X`}dbkT4DtbqA(%3&lqoHwitnxg*IE~p|H z!Jk~1(f>`PPOqT%vg2wNg19X42hS&Q`CLle1A(SjX{|vHqFS3^QWT{u7i)NQ)2he= z9^htVZdBUd7ho9nSM=+i^w@05cf1`_2r}GVGKSPYEN7flhS}GTABx_zMvr4MS|^K? zzisn$Gay*!?$9e&tJLwN5Gy$?+OVxGk3N{*1@o~8+ z;nRFTmY0dU>FNB;>1w&#kEr6&D4rcZi9ho4SsC1 ze8?QYwf9{CcF<2S@qkH2-V@zaa91&T3`(A@{JnyPfGy*Y>2qMBm`1-7MO*tZPbz=X z6Z2(H#TBIc`CQ8py-bKP4cSKk*fnhg{K>Q(Zv}T{x%?mf2hyp0@0&==%|eg@z?=P7 zX;LT_T%!Br!XaR{dsM8|`95J-?I33uID@p>@xs}PPe7na2=e_eNdhDV)J~RQze^MXSbB7)G=@Rri6>7sHX6ZNI z)Vo#N_@XXal=r%KMIuU>=Nl2zwlkO>(r&rk5_QNeLKGP;!t6)hmQDU=`?-0=%^t<9 z5~KUDy+$5jIg5VuyeOB~Oo{%j<-b+q64;Cd;2uzpZ(6$7P=&!T@> z_Luo{cSf`71_gk$@$mkt7MXF}>L7JRU;xS6q^c3Q^@= zWDJH&0B;=a3KQMYAET(P^hwU#M{i{%mZ#4=a>z4K8l)KDrKw*ArKq>h2J`1W=5s)A z8OCs~jnaFQ@^T+ZHhzlT{puq-VUD4cb_J(I``X#@LAc5*y+2_fXT3Uy!8S zlmkRE>96OF{{g65c$N^P6%E#=l0$aPR6xL#H1Y8Rwa7?tvJps9@uP_v(cW%?p1A> zmP*6iz%sp!)HFNlY~|LMHbU@rUJ@&Ii8Wl?XdHCP)O`z8gnV_1KSvd(CV36%bKdsG zpK6)|be~lN%m=%lRv)ok@i+B~s{QZOTSh(zL-`F$w2QdX`Lcth1yPaajfpim2t19p z>{V%TRc`3h`O*${HqM)cxLff)f-htAMdV&Q6DiDWa(=Q^wG2C{NEOPi+nU=sShu`x z{$Q%BfMfB{KpPgHcJ`^~mQTj6SA_=;%4JFAH0WQB#G>T|MKMBovN z3R~6tM(H|Ip4mu{HRA0Qg4kq^jJ(Q) z>MG-PJik-}yY!cyI#v(NHnK8_ds3XI!^g&)%1fe@Tvr@*p^K+!iWwo*nP2n_OTeA=$|9*`;P==_O}l{$dsvi zPKTNYOY@=>8tbe=&otIg9K=Bz^DOF z#lA^C;Lo{5AzQoQJT(X2pX{BkfqSmNbI%(6behlNrtdgb-7TI^8kxtFx6!CVP%%f+rn}?1&ML))WI9#U^ ziw7q^qn?l0089j6lEfORX6Qd65pNU_JKS#wanL;q{Q)lNQ+}KRa20K@*AtG^8}&v! zd%}lf3vmHI>*=pev)rT#vzQVS31hy(XB;3W%40e#_QOU@x)eH0AtfS0QB~=Yv~I2S zUEm(Wqhwg1&axpS$1FW|==@TEWppU)-20o%Dn|gyjV_m5mM%eW-MzfyGdz+y#oLi8 zJGtA0P>bc^g3wZ?aTjn23qUq2=H6U#&GIj6&qBcVTHSe`Ph8Cx$nbJdmHCSZLqmJP zo{KrM<-u(W!`25l@?XiJB0Rsf+hqO+LDi#LRuRAxCqK`}h>dO07l{Ujhoa>LC0_fJ z`zdmw%HQbM8NTj5B`7YuBT3uN`%Mr)F?Bu^xb|4MGPh&eA=6&T*as#<3V*)3(uzZ= zS!y5WYsMq^3l>$FJyrrx%8inl*8C4LxUEv}Sot<)TN3dP?8`lL8; zeKc~er)4De(kOwFSVPGG4;IsHfc7R#(NSQ?{cv=`vJc!YeoU&ZXYi&Pq5)NOvh8&O zjhrb>$aR!iC!GKW6PUR2O;hcw*pXRwl;L5!;(N+oYg#Q9gZYU=EsmtyQc{jY>!V48 zyg%6tfQ#cGTzV5wfT3*QH z&rftltjYaK`opJcV6JjKhebze8i_R;MP=Vk@JrB>Vuj>4SfO2<* z?WzztT|?-V&7LX-bAimny8SJs0JE%{=64l6Eu>z5s@0(HZI!OYhTQKjvAXU)*(U?y~L)C*Zj#~}3&-8NPn+9`! z`s1l*>}ngP#Hv{wNyb@Cw}1143+~@4SJr-eAG0PU`G|i1NEREg=QSi?+S#hUtlsr@ zigq#Hu$3O|Tm8~Jzk1@Opy=z*(9AYSz+rA&5=82`%J@z2EdKs@7EbJ=k24Yv^LaXX zs~*0N(NiE6A04erZpL5SUKR)vj|!m#J>;^(^K-!h40Lw2aB3cndw0(A~o7r z5RDe}%Xz$&^07{XNgaHvIS#W#g(FJfjqgirX=vJSFY=AWVonmgZXAwMJ?iUx>ma*G z!#_IEcp~aAy#@Cu36sXL@1v=P3cdYWVnpDp)$=X0vcnV%z4>hfGcZq`qYlcGXC0~; z@^+}L_Nc>o#Ras;$4K=5-LKOL0mZ~m*Hk6aoBT0BpLRhckYMcXwr}{YnKD7 z;$P8^7NOm*<|_3UdBz>t-D^4?^{^6rB`Dv5G}Vh?ol1v#hSBRchAxBs*>CDy1=eCNk#B8C#)Pj(4qy3rwELx>q z=xQ~l;nw&d!iiwwSUL>n7n9=$Yg{yCRIS};jnL(_Fw%QUNr2|)m>!-SyMfocqLm$h|@Rg;=BYXx(o{<`$uqQ9>C&Ry^+h^kMKmJxG(C>6S7t!S#$6 zHri}MO~?;Lt_P?{?dv5KDfc6Yy|`t+x0)4s@Qo=NUX1SdMxzEA}KKmmEW7 zo!!L^x2$UqEbz<1Re*F04VocR%bOu2|Odi+#KWV4N7rHa$y@7mMN+)@8NaE*ku^eX+!9e z;2)r)E+;c9JDb>>>{OOyHwlfQC?{uUyNq?vz1;_5#&gCCqFdGtCZaQK^E zN{WTarwR@t5J(Zl{u`s=PTcMWdNv&{!h>14DR^wD$zNvj(TYb8g1|LOls8)fEXdUt zTwYyQw5z~rHYSRayrYkFeK-KWhd1r!*6 zw{FY(G&s5`PTACa;Lc@PMDIcECOh75>LTAU_y2^Tzi7fb!ehrion;{9X87lD^p=#a z<`>oFFDKSK_0)ofIp`e0EqW~DB=@l&s#xIWN@2w*X~z%|dN{ca?63PeSQ!dyLvLPE z>n+!!6p18_QN0&IN@I+*e}d2}P%aTQVgoY8$LWwma!LAc_F5b4s0C4t$DC--hkNAr z{4!OU_-HC#Kk0%Mkgh*O*lU}#7ptn{q{fH>tO)2t>-`suWX{n~%xFyAK)H_=r#Ebb z)hjD2ALB`G*?4U?Cq@H@sbz!Eh~zg*M)nYp7#=mX1i$@gh(|b!K100E!0%<`pq8th zz9T>B)VURBYS7ft(xodee;LmYe_=97`0kcBv4%YfU^1d4b&TA5_EwaXuQJq@R<>&j zk$4U#K+f$oFaH3yt)%*Hn!TJwPds^Gm_I^Q`Wl!4aUc6`@FuI>d^yhDvt9tT;8RrP z7CT#1|KbXs2Hv%)nzAIq{~!73>GRN!)0-NC0+DS)Hc!W?i;K)Dah}aPT2fG}aI4Km zJtB6}5q3_G8s7WbbPe7`+lr5z0H?}S2$(}yzq2T)!W|n?5EBX`_=Y(&!ovVzrV<-E zd@xEO+oj1r6HYvUaSO0C)@I3g8K*D(?&?=6;IW<(38#c!J!z zV`@L_Irh@aFr#*}cW2vlKr|{{qUZXL8;dl6mG~I`)M*EeQ|NwfEAR=STzc(1meaT| z(S21Qrtfu;_c{;SS}11Y=Cj9LwpEqLgZy*fq^X)>IlNjSS=mml)_+9h7tOBXzhf0+ z|7H7Xr38DPWu;E9I@XD3e~nZ*$PV?!)A-T59wF8@i@y0>8VTrxPQC!G&?&fEU(>z5 zz!1+_RZSdojm(vWMNv1i{Pp22ie?&I$iTxw=pc9;P#aQpEPZ zVlkh1Q2l@Gy=4_-n+|J>^raS-US3Rsq|P71Z7m8UGJ4Hi%wj`3&e@qg4v+YGemuj+ z#F6tHL36M?rM8WFk;64fv5tt0KtfR)?!udL*A?+y3udO&#w8Hu{6%4$^^>w2S#RtaI+Yzn}iS zY1okxCro+WBpCJ0i*OUaRZjlK7K%IJ#aqp1mh)!wQT|Uu21d42dMuj_vF)4?B6;~p zQX>gne~EMk6nLMB91qi(rMSqx?leoS?K0my+d`n!I@>}B{1Y%_#~z5|n+d0|Ex64P z>w1sceWJ2Z)?JQZf*8vyYdd(Lh11QbHK$$(g4IJ)V~(bh!8$u=$x z&;VECEz8URZf&{xiqglOK3$Nnut3583sr~u5CG_Mue<>b7_HO?;z@zn*trmi>QXZd)a4S@;HHL z&SeVc*MRh3CO8xR*cav>r_34?>ZNvGL~7rJpsYJ^()=!BgGRYEd+(K#%|* zAX`(X4BA)GS`2QIAGS_&m^BUqfr7}M{Zhb2k`ylh=9fwCxAT6L7j~?oi;t4{OM%8W zU#qbUP^z8QF-F8{nkz^9w-CV@Ow*^B6u)G$VZClKsDXNP=Qozm{yuMcsHWd{e>Lt( zf$j&q>2QU@?st2Q*SagRGGDS{(l}xb)ZxnE0#yf`aV#V>YEHflQu}R~d|S#y{U4%y zip}-@`qLDZzxvXMFwIrGuw0{H-+G{xt@jKz`JwW&&9Y^^O@?YVLstBVAK=VOdqt#GJSfxE?%Sw z%OoZ5ncwVF*H59@KXM*0!;V51Kd=98drisUv$XrNNPWhfpN@Pe!5_zeBgfw-`_2ri z2lI7XHSK?cdem(fI_fLc0yus^(cyY1EL{b8;x1|w;WDOctIBu;hr2y>Ed)Rren z1+#l6g}MBiObi$)+Ai^hjYB~x#!tK`aP#t)*#sF^#N3Z^W`a6G7yvHT5X|?{)Y%RJ z(1Fu&O=4$SUju|V)aT3vE}p{n0bZ=si;=*U-HI7o5s&22-Zmrs!P#F5+_Q1$AMG1@ zFX!L~-^~LK+Qn%a`wp?Dze=t21lHx(Rzv!p)^MNMz)z zyyCcOy64h@2fdk^rg-E&@GMBA);Lht0nT(2-fm8gefmpb3h8x} z<7-)Tg6Ir3J#(Jl$jg|_JDAMS(dwA1JFsrtUl#oIA*SWCC}7ZZaI`Pgu||I>elX^4 zQO@OcYJKXdH>{Qw`{ufi!o-lthm-an*r9@~jl9P-vX2@rQ7$b8Rd4K`r%tu9g5Ayn z%CpSqP<%Iu|MD4u8h{(yrAAzZsZA=SuOM) zGu8erfq;Vm=JWAVo%NOpVMW4)v;&LBHteogAN}mEko-H}8zdz(FRYjlsNO{07s71O zu{A9L&p}v%^s&K|15Hs}UB`SS?HGxYP-P zXGK%MqX*-(*KIeK&miW(MXC)ohj>xUvu|=A*WXs=pC6)+VPzUoYF%apuye96EH_;B zfaOO^Vv+ChTF_2gaTCTr8j@b@@tuNYaZsB?tO2-F2Va?8M$Blt1{@%ku zu_SNt=OcHSZL;&I8JZ7j?&P`}(jS2V;&G*0tGXPp0k>pCP0{V7HwX9Q!>Z2kZRS*? zgTE(1u3+A`J(y|s(cN7alX&#x&$ybqMuTLX>-pKKDl*sC7TxRRR-Mo0{2y0pry^ij zLgMay5&-+t;8-lYSS32|O9}EBYei_2#7@sOM?J~>xy9Df$z(#|@OV&3O0m!*HuT%& zUOtOzc9#bQP++_CDR(C@Vqm$p{$<`~L751GY|^L2f`Sn#8|WbI3bepQy`D3CP?#KN+` zeB{{q1@kVxS~y`AB7CNF>X=Kj`Ny|-(q47@R}i1&DoACa;oLL!xvVP!RAhtdEcFRW z5SL*kKv)MJCi+RfB7VnZ4R~6ED5)q8BC^ZmBTKx2(OqorInzJ-x^~Nl236-ko^#hJ zahfOVDZTnQ%&&o}F1rV3@*$u99Br_!O`!?nN`&jIEvy*KnyI+S_CJ59#jJeBi}x4` zhW{@Q*-iqi2V0k_~dBO3jROt0%^MiQbijK?ec4F5ed>D4P83 z-IQR1PMa2+pTc0`ZZr#vN@6?1bVo%2WduWPdsG2IS3~I(FM!e82}F$qOj2?UyVYoi zdLFJ8Hes8C51kf&j+aRhAcaU+sW#zTNcA-TIa!+5;j$Bc z?}bSa$rA{g)8z>bzoQ{)-%hSFt24luelgX|2J+bQ{-AY({@Jgl%Z#_f{%E@Zga5a` zNHP91h-KJ|q+_1|1GpO?nSuF>naGhHCK5L5wAAk~1&tBdtb$=1F#{(ve9wNt_MU}U znL-XTC`s+U|GF%E1GCW^5*NH*P3mcG8hgq1^YKxB{Ri~zqGq0Rblpc^&zS9d3lbAL zidXk5S~*RcJ%p$Stb__>{Lr+Kpc`qy2m9AtJ$5)cwui7hd77v9Q z&97y@jt*e&viYD`(_I6C`eQDL*|IiD$1W4^Ey!{QSiG zg&zpZXns&~T^JS}s^Wf3%3yZ{JUA`z0nr1z~!_-cGJ6?`#naE{6?khbKKOo`{ zbDlzg?mwGf3%?|iZT2K$Bb==L*58tZ(v~OjFb&SBIoBT!j*zNO-1Y|?T~gGwpfEgw zDhN_?5-e4UFNDinsvX?R8mL{49(L-0Gd^K1$>td@Jue(r$$4h|vHXga zp-+s=f`&&=ln4*-zDVWHmZuBmc1p9XsvtTk1<9d?r7GfLQn3ggKD~BH657ViPb6z{ zcIx-D7p0Lk68mV12EKd2v)iLf`U9iq7JQnu#N=TV0T$@5mwSu;j{6jSL;L^MR|5~^ z898a|73sqNv`-Onp;~wvUo(+%mMH=OlI8{Jme=s-j)6yU~j47e< zlP$Wme-d0WaXp`Ymd=>@TOg z*Z?pFZWScNi_*qCYAN%*|KnX;$^>4n;~&h@q#d8df>L7H>g;21thY9G>U1$uXmrS< zTZx?SD3;xE9w0Qne@7LPhp#Ok@yvD#=3)`cH4N}3G{AQNMkCCd6omF>W6H%+O>Or- zc^!?TD`hyH#jvl^F9w9gt>%PahHiUr$4Z~EdrfRHNo@)yl%mL9~j^n&=*aIL5wZF-6*;I8%DOSfKxUs-`tgcWt&EZt3nZ-vOE`T zK8zK82lcOe@|zmuD)TQV5qU{bVXek=!!fwT>glf-oZ+{zT)2STQ*Pf87zlc2w-Ol5 z)F4Q9eq0yh>xFO%Z`M6+xJ3WpIra ziQVk|A3xIfws%KbO!JqJ{(gC=j0@73U8d@X6~D%XqIho!-_7s>i&yUVhDT3%Q8J=O zQzEhrU1*;!B=kyYJT#16^77c}^@UpZ{7h`RhHT@Ltd5%fOi*0^LO?Cb7Zxz6*($t| z^u(C@3{gr3+uKr)&|^==#rj^^;0-relB@T#B*<~&aACFyfA%Yg%;E347?!(W8d8Bz zCp(QaNq{FD7+d~bEgQjR7b|Bd&|WevOcwRBRc4ViCP__*8UcOJBOEFJvQxJ+p(%W@ zn5I`I^U3IVv1tG|1CUW;*k`FUI|F3HuwJjfPjCxLciY+`BGPb)A>~1F(g<_#jRrUW zQhiP+{Ok9dS%}3$U?k+_K-y<(ukwAdv!$y+C%pNKuWBKj|KFVSdH3SXRFU~rNH^Ic z|IFI9K7ss)^5}VD6mS0s-U^Up?Yz23^10=WQPpT;Yn9dU0lLnrFLA6PDG-uZJ3PY5 ztZ&T-Sg%H~%GsP&yXP}Gi$~!Q7 zpT3Wt6jkV|c=br~Pqn&985&BxIJy63tqg*6CEZ!P-%wqw8*7p{+C_F>{Pt62$gH$V zVn7cW^MvrH`(`kfjt47;i4W_E%xoXTKCxJYG8vuHTt`Itj%+l}Ed!Rdrd!H2mNmwa z5&rJ$6+K$dXX6?XqD_y>gkursd0T`#zVqnZ4+fWk38tdv)8LSw+U`5e!~R?kTL$t% zTp@qk-ys$(r;CqStx~vg7lk(80(xQa#_-<)Mur3t-Xg4eW;|#;{l|o2&wtPA*)NJg z0l-UhZKK!b?S!VT2E{|uj&xzppJnb9&W6fn6_jBH4dc_oEm~N9u~A2wY8xg3kJr}- z!}-<^nw0lBma_c!5)uQ`62&IHI&!L?5V zB~zjM=!XLYc{Id(fE#h31ncill1;=lgAg3y74ip3tFzjm{o`h_`7OL_CGKydLt5iTA(ZkP$NG zn&91n&)|d-+^Xd2g&Y<3i{c*|!UM7jv8^5cCn#!0Ic%_5Zj1=qe3}##i%fiKx{%G2 zaZF0384}_l^O&yPN0U7N+w1_LTqL_Bxlw>s{{rk3mSC(=K7TB{uRBL~YRq_REE#!! zg7_>~>7q@^=Nsm>R&U$iFzfo95VV*=&os>n0{|}^2WIs8j572Bk8(F965lZ%YEd1LR}7EwY;0P`!8BeD+q0!AYs&HS9;QF)84 z`VwnD6jW1mP&&M5z3IsM3YOwUP>yBAT3g!;TA&F#43>BeouoQ~}r? z0C;>jhu_3YnlKn`@N%*&Mr`!(_7(~LGk3NMfAVRGpv~K}h^D%NTywNxYa*j@V%H7Z zn;;(P=ho%-%gW!W(y!?|6CxACF&UG>TNna153RD zR<$``D&yw)cS>Lv!)!*a%twL=-3)^7^NJ5d?fwjU{38A99JMpP3FhOcQwRX3<4e#N@rDar)3v<@+zcRGWJ2N|vRAQv4oDZSw4`Jy;rgFLJaN zdDEG7w6b6 zdbj?vPs_W*o7cnBg0yo4FTn7|zSQ7VAF79 z=bLv+tRgZy4Wo#j_~!Qv$k68}NQ>q>t8K{?(gI_yVr41f4}Wn)k^Vn*eRn*S@Bcr? z!Lf4eA{={ZBAauF(lC-yp`p@HL^j6>Nk%mAwpXG=LU#FG_kADg z^LxL)J^U5-eP7pWzh2kt^}G^XA7#{!qM0+xs+*YlvJPC+%)k1L6#HJ7wkYYoE{llk z&)3*$qzBl*9G^>!r5iG+iPE|G`~>6x{g(CK7vHW%y?mY<`aQ==eXXwb150a~42OO# zbE|%B4c6U5a_4|ou{mdns-LsdpySc3a}OdF4vSjn?wG0v5>v!t9Qw`oP=CUwN?{I@ z5J%&Qq5KH-^M@G?3-tzW-2RdS_g##W%-)6-Lk6QR$89u`=DF>J+GOHFlR(Yp zg3X;s!*H*v%tM5m6!JO-)-fcq}-G!=d+A zJzl$c>tuHH$@~7nj}4;M77YXrNPA5f)`Ovp-gFk=#G(V2%h+Z96(?-_8Nmq-?3?7C zw28C}QVX6A5*r1j7C!_V&JL;xWTGpevw^4m4tjZ>s)LCXyVDo!7qtwE=S41>7Cn4* ztP4GO^OA`7bE%|o!(*0u9}kVBIaQY&`_^F<@++;|)PWs;d+lp!yw>_+g_c@EI03|E zMm+<8tGZn}RrwbetBa090#rU{ha0X`ci15d8$!wq)T(t?LB9IM?zOwhx*kjcJOxP} z3NOAJNVApB^%U}yoHNtwyJ{lg8`AG(QaiFQwmx1#`Yn22EbBf^iEP3lAb^+# ztMlaOt+lnz)H?3Z~k_T-FN^X=*0L>v&ouU@5_=5c0E~lk%SZp z<8TGaMR=C$u_6W@5%cvc@tw?lB)l+GB*Esd;NqW=q}ubl(rA*m+dIzoaMC^r_{pFv z#u#j08OypwSv{bnx~<6g$z6r6U4LWp`*enZhJ zXgxEN@9XQkr%S6g*-#{q!2?M^tuZw?@Z1%NBv?HSb@*XXXF2EL0HSX-x}Z}KC3?#E z(a&VB<|ezj=N)~eKn05ozD-y*e#R)wC?cFqz` z`J#HilWM-3%vN#yzf^Un7RqQzOKTxx8@vcp0Lz#WG#FM=$^>X!RccJIoWabG7V{X_ zv(Z%4a^!?@SydlBMUsvG>K1-Y9o>i7R<)}_-R3~w)uj67-Xj&6Pu|U?i%pxxS<>m< z<^xye@a7-uO-CIsy2WNJnIeA7T0_V%TVC5oyc6zn&=OHjzmb#j+RW2_3bEKH1=#6g zFM&hB*u%87#mfbqVdy+Z`{!bb{Fh!F6dyDa_2Dh4h!x|Pk}br!^AyzYGC82O$~?CI z%g1u0Rd~mA-O7%Hq?ZMSas8uG7RTD2fQx0+QmJ5AdvYR8(ZJtlP>$O{u`XsCfPWI{ z^-a9l%MB{fA>p|NRqb38-CoTB`|d_tKe2jbE&Zss#7B>E%rMKoW_`DQ&4QdUr$ zFso;|CFb&j@AoI>htp2ft3O(sGPhKSxFGtWZ@N8yOhmXZc!z5{<39!ag}JcbpZq;v zpi%W2*lI9iI(((}JtXOrTr_gNYuo!Z*~?y_$zqEu)V7yJ4(5OJQFob{;!(q8;b`A+ zo)9o1>S%xV?qMnQQO3o?ZmUOnG=Ih<^ncX2`ay2?YpKlD%45By-9BF(?>?%FYm^XV zv`wEv-;mRP@wjlR<4ld=yE9Jh8vEktXnnXgU>8N9{(vjv{4G#~k$Y;d$YJYmzDLM zA|l1Duj@bS85Z9A*=lmqCS1VvCH5)9owyUxMz{^930kgz(_GW1z;FZ0&8R$H*bq`o zKo42SNtN2_v_^qlK6%4in|*801zO?gmfEyJE#MSC-j^b$HcDi>W%>IX9||3rF*H6R zWL~(HPfT{;^9NzC{gr%Vvm;|Nk|Pe&g)Y4h&+RiO){EjPBs^%qKdcnqGknr&m4x4y zwU?9JY*$)ZYFxir^`1zFj?w@E(n>^2$vQQc=-q1-jaNZ&{EqsvbV3O35DiYpk3DA> zxWuKTAj5TD&GhOVSjtL#%WnM<%Zs@ewrm&gdGmw4*lT~sO#!PViSZ<(ykIfH>Fo)El-}GScqC;)&D*9TEmB(7lRtbwO?B75Wi&e ze9B~$AoMvPp4gNkk!?HE=+Cq>4x0BO(QpQTok*E)&puyld-m9`b0yD}Ey@4{7IRl* zogH>YlO%g9q0HyYCGIR-Pt*lH`X~EU6w{=ir+W-)`c=HGDK+WZ`*5jd{o3)nA%l8E zTAZ@@fA}~pDbQp0CiT8QC@ELAsqi$z6PbKa<2{FB-1H>?%0u?OvkL$-{KKT-7q_6X zu%+h=UzmfR^zT-AOP42#uKLaTj~loGRtLdY@VC`-^ucMw&5rZF5MOf zRr4u$z%sUTZ0zNDaA3(|u>(Zr#7eYe)I!mG!y@?#xzaLct+iq?6||5YQ2Isd?^J$C zIA=8z|GzUX=TeBlZf-lbU3@*-n8NechQ=D2?8gg`Vz1NNHOjx}V7K%8IwAw+@Yq*W zvsrdPhHD@^V+$%$Qh7Nc@z6+aw&xG>WACF6X4mHuWmdkJtYDj|VHZ3Qz+k z4c*)SF(a{?DT9kFm!Ib@ricgw%FtPHkD*jz)<^d)WL*5+|85Zqma&IW0Is0wdzN5I zsZ{5!n8hPTgNZt=)L8+IgcKIW`xnMxW4*d*tO1fQ8J)~ML+;b%Pa1s4ugeuPL#P|#8si5xq^~%9K?&q5HCC{UE~p75HJ@OkN713mOc$4^0lK)W8*U`%eiY-kH3CG9yq>T;VZzj3L^o4V zFQI95b!#Wj4Or$23W@#DlS4ck^{|r6;-`D;$}8@k)?fw0>)3+Y=WPX?uma)s|0@_o zp&TWXOeIgAJ=;kToplWf$t~Cmv{)HS9YOCg1z;LxKCDyUGgYgTVC@oI;HMHsYg--U3QNc8&GfiwU$A)a8$m~(y9t}7nC`0cEV3)mE` z*hZvS#0=Lu_%SH!hb00H$cxa|A=faj8WMJ_=Uq$v%9$Cm|GgLnZKyFC6l8VNgwJmA z0_CTfU9Cc6{ERT4gk8Tsd6bjT z*|0Inh;PRL|6%25t5d|W0Oc2yGA3wZBajL7&RUjacI=a6VA%`S^m4$7zzE9$mXkWI zZR8k-y%~S*J7V~8L;Jv=Jrip{9|Z>FD+<#Ju^!?+JMIF!U=UoymS(9#i}L4GHgX?`Rkm7s0%uK($bZuHol&3^f$8O>|?sLQ~-16&0d z!DSb}!DII4P>-y?7nHNSlmZYVOJS@m2uV?9|7E7p*+fvsrS&>6~+P$L_S`M2oTN{#r5dj3!A5FHoMuYD) zyNSe9qMCUcv%>z`AUTOXV7$*=CwkLPuDw+Y4IK^0NUmMb0@2i0uB{c2VFy1%8%)3) z`66R{< z+lC-0yw-xoCnrpS309xekpp5n^W7wQ*ZICjbx_ma~F3Nd+<7&Z_^`@xi7yDon04QP5nC(0`r?Z5!av2S1l+u1PFn#jGSurtug&DgWjAyOP|03GH2 z)qott1SUCjS^fO)ROap22lRM}$rXkXF6@lWtO&jc(5>uV*E_!iJqmJVVJyv%TcAOs zi~uM`?QqO%L4_E=V}8J6FEoIT%OpIkm+z9Sr$EA>%z*O75D=i|y$oK;_l3cRW=Eg7 zP&NDxRK}M5gDbO@omMb3wKZNtd*p(L$$t{S{3Pie7k1;YJMZ1->&swEH<;uHYfP^P8}vRz z#p&v1hpWNO>E%*|HLbMoe=Ie6(%xOUP;?XT~S zVbnn?4(w_erdkiQ8(Mpm3dJFsv=onEaL#`4KK2x6A%z$j3VeMkCd>5{>mKBRp0xW0$K2Yb6oq;f{ zBfB3tKjT7KD=+d`BjFkP92G^h(V&hMtIS~$0*wv=aSe78F;8Q{DgwD~FrXsi*o`~E z>XX;GV+TPQNE`EKa;+?EC`m-Dv`}cK?D@eFkAw3)LDI{!>4K2u#SJ;34m4hM06hY{ z=j7L?rNG>Z4h~2=rgFkb0O!0M^u55J`Uk{L5$n%=`C#i1;tlDwbc!L27nX_%p4H z@|`ipG{%U&g>oc_I|kvlL8r6S$^f*Q85$BiKrlu+Sj&m0 zBas;~(ylWnUMK?0F<=sefJwMr%GZEM$x`y4W&r9X160%w3J%CT$a{Vq0;`!2{gbmi z^$OW4MS%n~_>2ob;&#?y)rBC^qE;{R#86Z>1U-$I!t%PDD?Q_yRO! zm;6w+@P%Y;dZ2bELRn!>>F47|;x!904~UoQJYqSKb;AO=724rXLlo`Y%tw`EP8_9fF0dR1c3@bJj50<(8L3@H`mRkh^N*{)n)s;{jDc6 zw#o-X1lcr5;FFLarWTdq6QL~hwWL(D+$%1i6XdO$GB5C+zL*WgXV8JftN;?TZ=JQu z2r;xdkQ*=}dk*IDpw~=5{&Z)yX*PckK@Hdv0Z78kj%w&nE(fZlUD`pnAE*m)FV_Ra zIxnUFVeFr90PoBV%1sg6*LE;smQpCSEhq(7-WQ6IV@=FY$2wm?T4xAeGqb?WOO=ny zP#5eD#y7nYC65S-81y-!S`}8vmbTj}gBDzG1IQ?j*U(Z1CWtPlE{00~+voo)cLUPu zo3)WFf&RFz=f_dl8S#w*MBr&8*LfUh%F3$&vV`c;+yV?7MNkYO7;6BK^=NP4N52lL zg$Evr>#woLtv_U;iCZ9hWg^Z`kttih8?ogPcu<#N-^*lz%tC_b=fDbvXFNfj{{lEe z^nl%;I|@G3^lCAwodUl~8&u?@x|5Y!{CMfaJLT>CAbU?Kno?X~2uhaN7U34Xe zr~*YHpULP502CZet}8&ggeWQhmB2x^h4`dSld5WH;!YJ+- z%|uGmP{4+pKwD+!1?)RG)5yHyT}Q@oY}QS0yg)J@ILHHckH`^LnY@r7Ps5C6z(!~g zCl4s(ED!WvLL^SL+*jV7XsmNv33Z8)?_^{sIsZgOU>vdI3bseYd03FT5E2I`aFslN z@e{w5DI->1?YS?KDQ&f+xMOE_Lr$*an=BY``}v}u&=(9?!><(8g3uEyin>}=J=1u8 zyFyx@P5jRy?*4xNZy+WDAHlFdBxyFQGt-7hLhbC0tS9YB1Yt}b2dQBe*A2G#<(+3%sI4BVq*XIRmBxu;Wgwr|~NihLX=5}3ooyi_hg?Y8D@#X(Wc^Bjy zuKtunFhKJa1SesGXpW`4iOv3pK^}!>Ma>3U=PEM0RCqazZcE%@zlRt7;0bAwhbGqSHl=$f&kRr#EgCuAxr$1GV2++D>F zO)op|Wypvzh&=!%ZbSH!v6a6j9)tjmUiKa)Aak@s9PpJr*TG$0$*r|Jp_Jz!p2_yA zoXJ>YbP~^m!uon|<*h-Ik{-&7C*hlYh?j*f(oQ+?}JxgO*}aNwl={bqiN^Xfw3vLnyI5WxtB} zhn`h-uCE+CP_v$A|M?8OQ55DLi*4Po#a(GmW?OnARzvB_cp>^c4^HE`z#`=x{z=D} zEGV+pTB>Z&_K9OC+kP9rU{;?}jW^(OGjtV~5qr3KMPZd5&KYgS^fCYAeW6bCh>E54 z>4md=gXaV@xo;E4Tg6@r z%(OgKi;}vSqo9BL>?6r5UTmY^?}A3-kJs5`oYhhepme}rW2K`JVq8p;cnb-Oyd;IP z_-ZY!X)b zw>oHo`ir0K%Rlg#?h*^UCw9`j65r05{>02xUI}{n!JXulU@#1%#h3{%o#Ic*n|`9I z5m#!T?V6AXDAghZD5W+W+`>%y^_BeN%-OpM0Rusozcra{`TpX)6DG?u_|lefcqu{{aVI5!aHMOP#>liNUatY}U>be)Vz5M$L%hWnh+XU5 zSJm)eVlp`|ROUCRL|uzgJgQwh`!nhbdByW(4J49-^jCGQ*LdoH0M|H7tUAS3|0wk? z7H8GXp|zmwZ2I!iog3s9QZFHW$H?0c-78cW{hF{)%<9wiz5x2aV1*<_SGMzYO0V+X zd3-8ndf6+LWJo(X_L^_DY`tEK)hx4;hCZ(^K7bh3hXe@@2$@<$DN1~A0o9&xdpMjnn(}X5;*fUUCKY&0kC|Y0FBu2x zaGHYh!Nra!s~?`DbvNCFuPll{WKb1N%1%iQFHRzTPY~})R-To0-s7}KVuf4n?*6S0 zAR}DqamvN`iX`YAx}6`x`!aIyzYZMz>e9a? z@E?ni!3H^9dEyzo`q^#DOC_vrg8cp~%nzJ$J`LUAcIN+tkQQNo@cLDSR-iJpY8;{x@|GJu6os8;y zaVWCikhVELoJ#>_87*m8up=VyOU2n-d@GsxBTbMZyg&3Tuk%pYK<&4vY&^gzGy9nQ zcJ*yYzI&@4umM7nSxK;+`OKH$9vrs3{9)ONl0qfFNK(t2$B;mGZYOH&Ove{Hq*e=r zozV;%(Bm$6`{75>6;xVHxs*S=0X1}CMSkaz@gv58&VDcpa0Seydr3S|uacY;9rPL2 zLQjCtPy5;Q`1D4)aGrhu#L!gK8?rXQlsJ)2R^;yuV=Vl=xWg6sex4N$+`1I?e5SuL zXea*_>rhF@>1=$k$hFR?v>%lJ;DLxTd7(Npd^Kj_h*u2x8aw-oNqJaLpq0#17VpV< z@r(~;c{6{rS-iryFgwZ;(ie3s+-dI%dtjCNmq+K}51YW+d1Oyj#9ZORm7CQk3V#e= zIh#d~P}5ol7-VrpcX}O4X5JCW+UG&zmJ~!S1XDya_35RZ6=WOd;5Rv9OvwPQP361S z@uLF5EOoub8pwjUjfhT)@)kR{s~(uNHmSw!7JB3D)3ua+%A*umx5~NKUtp%Bi6`x; z(zJ-_rQ1Wvg6$d&tv&kvnZm32ybW`OW!Ma0PCMo8`YJB~V(QNa^TM`|1+wQWD?_$FGz`=GwFaEBPw5x4WS@iZD`6%nTBZu#rTk72Xv{fIN_#@}!eHmbG>aw^7 zI-OoyzI00Hm)*ox)$Ndo(V#wHlxHINC8mv8G^&2%ryZ-(e>XPP2><$F6k3;^T>Vcy z8;~jQPs!4-X8LnpIA5ChdsTaC+HbML{X4#MU8{4T4vrUSP$f)OvZ+dRgQI7nmS%KD z^0)en_@?1UJ@q`(y-p}7%-g~yKj@BT@IMOBTgOs7;J31}T+WYBk{bMdyFc(~Yqjj7 zWgDu!D3hj8g7}I&_ewGo+%>xoD&c8OeCn8C?HGsr^Nu$6@7GU-2alF>55p>6rU*p* zqI%IpqrYZv(JPypL+PP}TT^#rrl;Zf$J9@%bV(HGX}T$w6!acS3o6Bjobsl1wP(DO zAwou2$fL^^5n;+6NZQ+)M$%c1HcyBD_;iHwRVe8GuM*9{JHbuHU<+msQg6dsFvYmC z`Q)xPo!c1(%jZARfH$vd2pQZ(r!L3tQj)Z&v`T3xZa8)`^T%%byj>O=>laXI<54u{ zAWwz!Euk2@**A1#74dcC{+L;qoy+YBBC9bxaE{UcpJ#pp)<&4xuc zy)d8|-8a?E5}+rNQvMkIpEZ#w@4stLrY&!WRtUau4IgS|y;DpsJN?yI8lv&miaJvZ zXU}w}ADjY#liP^_)jbeD@MaKSe|T*h$mY`O6@@Lo%wK|Dp5n<&nEq5akqm;h&^T3L zn2Cqz|1XnIq^P03kiHw+bgGpWxyDl>1GUpr_QH;1tWf1i8CD<@4%J7en#(G3BKUwcpsFS))<7=e zm|UOUQ+oxbnD(Xe9>ddLwp2i5Q-{cQUBwKEbz}bjhzk%igJ&~VD{2UtHlUR=Ke}KB zT$}{w8XwGaFT^{C{2JGpL6*UJJE>UQqb@%r_!p_KI=F4-nP>p;ti_?gvs&jS*1`M9 z;Qa643UFwaZzEKbTUVKj3xQl)ARIA$R^x0_l?G&bd5@D5ruHeAMc%AFw_2}N!gdX- zEP>=3HxKQpG)Gk4UFAq+U}EL_$lkqVC4n9p@P@Zlex9&E#Qa~;F^HU*P^{rjsM*YX z5TQzKPi%!ER7pi|I70P3h?^$!53X7ME)O^=z~66U$4^xgLIr;IXYGOeq5-Z7S?eu) zop5~K=3xJ+E?wBEarAeJe#wySc|b(9Yo@wzXq|C%BiPdU=e5M z+}yzffDnkxKViC9%4B;O0yjVmWWhy(Us4YLUlB9dNiwAAvmGGyylLW$xb||k z!|IwVqsjAe)gPtSKG*=mNp{aJg9Im$eq{Q|k5=I}!2xo2n89M|>nO2vuss=iuoIgKzWPjF zD%#!>yV~)~VZfADj?Y?7o0-73sy|(i1?o@2k>K!+bF6!DIxF6I)k+HL7!JybKr>^ zZC7$(iIeBfc(CeO6oi|M61LweXo%!(G_)yygqHL@beNi`&#SbQ&mvLL&hZZ#pRWSS zr575@!^<3J-f+9sCy*3%GbF;!m_v~o3*q}fbqYv2g!dcNhwv2KH5PB}YQ0=q^eqOw zNVw1xF@aY*B6zq?FJ!-IIIrS?1d4zPCzuflJ~1#ceE!N4wns;wjd3n}`>3QxbbnL? zGH`b6(g)bSx5#YNKO$~S%Wd)y=X(I;9L5eU%+dIal%Gml=<^OoiLd4RfoB_xyRnd> z+`d4qdK~Li?{+r?}p4+L!O^I%)0An zGuhsq&!#hR6;sNoJ^*vZ%pAn93;$VC*+N##R zQNJYb4@Pw=%&AcY4_A-`K0h`~SwxhcxA48DDXodrXxBJ*!CI5bJBZ$nOdt|`wUyOp z@vC{XGh)68*NKyKgLCp!lW(1-?&!b@==`dYE*IWcqmJ|4efg4)=}dy2vaKA_(rEwd ztIiI%>nTSbS=HZ9$eYoXe%h-r>i7e6yFQ>EU$ak5sP|H*ejeqGmu3$f~v~s^+ z)!xe}t{2-Hb_8T3h`r}JKJF^^zrI!ksN4Uh#Xt$U^(hOa@0-$n_g?&&JR=Z@4bfo&88BgO= zp>cPYSx>Qw!;$&EGuQkvzv=6``?=S8%d2)(?H%G0S_S3Fl`EH3{iC@oisj1HBs?rM z$1W-+#+;g(l#*)a+cC#3I=yRGb4r_db8kCe*Lrp_Nj-ZdC7Kh{T4nVz+xdF9xO$?Q zo|tCm>*DR{QqQhuR3^{p>f+_->EY(-?(F66;2p2M`xv(!@71&HS^}Wy1KdjKiDG| zN9TIL*^#%v$JNWr!^g$T*~87%^&gv!aR>c>-=^|#cXN03cIR!xME}#ax&8Nt_QwtJ za(4FibanCcarN}@^1$}}r;RZ->z}s4{ojrcpS=I}^kVnio!x!hyqsOVy}jM}Y@p?Z zL*vP3)7`_<R|Nq@qyZU%} z>7Sba?xXa7$gy^J_w;oCKmS-e|EEp#KvTa*;oAKENemBY(6m8IyS{wUMWyQZgd96_ zW?D)V-}?AIn4Z=xDaFp$uBACKs%uham0I1>(t4%(Iyt5GFsH?I>lzj9$e$Od9w}Mz zJ@^yuR@<(gT|#_}IWd**jCKJ54*u;OLIWJ!9i6|;%5%n~n4{9-Gt4|+&!ogu$E1`v zCz&PHDLTs`F~*4}cfyiVlhRXSu%Q3ER<~G(o=LIhgj6RNA0H2ggs9l4jHqk}zSVd+ z#Q3A@WygXuj%(2cf9?`t?wD`0HEF3deY05J@wQ10y3g+g| zoL!tb(VP;Mrtf{Yv9k^?u8y8wj?O%HhB+lQK8f$tcCK9W4F7ma{P@(c^X0RF&ude2 zVq97`zU8`m;L1;o>WOuCO-PDL^Z)*QNyTPGrNrUh%$w`!_K*Abzb(jv9}9f%{_$QQ z%SJ0aEhRpd*TA=i|87;T|HG=}y8m%i-tI20yzC!W<-%L@|9)L^XZUelye2On*;Qk| zT>k50_&@EKr-!Gfrw8Bk|7mp|-X5O+IBw0N(#$FGQ3(;=5z$ep=76Mxq!h(o|Lc)ACA3lDA; z92Tm7%vv=FZPYNdmHsB)s$si;u&|bayfj~ad;DIy*!lA1^u2WDm-HV>H#=WX-cvpk z{Gj4>;R=uwt*-&k6kb5z&e)$sF1~GEOt<)iSU$%5Ztj8|jpD7vYd%gnAM$^~)sf%c z`L4;YhpryZZZ2+S2fktHuf@isnC(ALW=vt^w`)m`=J!WYg#PH$Z$dw8nf@aFKW!Nn z`r{V=(>57vl!>tW-yTyb@flGOUE>q^qaNhn?q65x_Kyi$CMBhX;`rfd^22ty|9^MH zzF&X(HsSiz&+`9rb>iHoM)mBKz>j%8$vJ$!%*@Td;!EKesA!7x1L?^ zl&D_ee8KWbmx`}az0w!PFGYM=@m(|(_HCj6c2dLjss3@T@4d_qB|FkGKzV543sq)DAXfFTYQ2u6|D_3p?-;wh&7K|m6kIByz zUtR{}c{#IvdFg2yF#aWxF!_;N!NsYdP z0C!}Z7)*z0;7Dgl7jaikH^!Yo&qLgk(~I$D;7A{Fq^~#<>jH3WgCB!^H;xf%lhhg~ zY9z*SJmE+sj>I&?)MpwnsL}Ul0vL=13UEw=8re`XNF06i8ZmHWV{s&wheSX4hq{T> zNQ`6MAxu+oB(@8QelsSNG3J9~d12B=HWx>>U|KTaOe+S z;Ozx?2LX;{p+NxalgX0I7SG|tF~%{2Bl`&OzS6_7g9CU!0p4GL<9K2Wy#dTXW)L%&8Nv)@hB27t zCkD$K&W!k>Mt>wTiW$vddQ6Aj7;z-F6N&yyWz;G%+Jg;W;%mDdNUZzGn1Jmj>PiNo6Vp`qMpOdWia17Nh}9GpIN{x6yP|H zsFA-&MvJ45-XaE$#4-SUF*A=@!Yma>V*S{TWz2GMB(@Q~6%1-5>XnkK#F6N)mc)AC z0KP_mV>?hI*9vfK_c~@hvq5sBI1>FB29De$z&A7KqqjvIxm6sAWg@qUqlRyn8o5Ip ziETmd6vwviVzBM#VQjb5=^tOLt`%sgS93h-y*$mat51@n@5#k>~a zZ>0BD9AoIcV=&Kq=7Tu$qc{@FM}87V4gV}P65D2GzA#_Kk+IUtmHS&iH)kFuuYh%7 z-Kdck(nn%iO9tDBZAFcKJ_gIq&xz#&cmb)A_)G#gK9dDG3o(TmIMPZSSww2|i!#V! z;z-oR1vr+48d*ZpS{#XfNe1i3w%JIHZMS8RrNoh_v2PedU79JwVE@Ysa2$tnoaLDc z45qEfV0r+@cEOR@HYEDkk4g;Yt1Q5=eDu+)B95#ojjv8K1YNW9}a0jW8*meMS6h~qoofv1v zMI7lWj&zgST^u#sgYjg%7#ufm#)t7`{1_9XF^VCkzBm%k3IJ~)HPT;z2Z$pB1$aYo zWRL)FB#vw>z=IiN6LHk=5Xq+EsNu~dL&Z_U!j|V+1(PJ%D3<7(@>)aYl6BXh)&eWdOyjv5}qV1N2C*gy38Gw35x z4-nu3rH5t00ep}o)(aoZ3}J?fBZrA2f0BB*IBNI^sgWZYta}uLZ9$FxXsOX3BlTEL zjAJ_V#)%`xiz6q9Be9RjU~wesiPA$FpHp~{j7<`s%!zHr{vc6f`%q7j8i{(U0LQWT znVH5+7e~$zN6wUbmN;toYzFI@!(d$iK35!x<1>%JwDScx=0_jB1L!k{*@Es zSReeTI1<}}<9m$3@dohY;>h0w_zCHw_q)`8a2hodHKsc$jyxrfG5Bezkyy?d<}7oL zInP{RE;5)F^Iu{xewn$#TxG5?e~KfqEcC83MveSSYV>dXP{Yx?DgD1WZ!xzSIP#7- z@-BmU?lD;AedYo4Q0hmV*ajr_$=Em4bESvGF-C7RgBpqYG4q7M@~~Vu@+tF-!TPZs z=%e?XdBMD7UWp@LGg#Ie2FnKUv664a-*IAE%mYWh7e{_zJ~E$}@#4sF;>a;fEK`@M zBaZwmz-vn%y)WWOv()H+72ud2KUC*t@(A#};z$c|OHND+;Q7Rn`57#?04LUm8vTNj zg~U;w3n(nUaz=;;7-aOev-`Q$~Q7m0me<)bJj>`N;C(sNof) zMt0{OfLD|n*^PSuUWuv9RAH(zc8on!O=@IyrUp}!sU?oYcR>KJ&D3G)GW7(wgY+E5 zQNx`iaZYeG92qabyNe@xFbPagCQ%%jB*1%#Ba;Pqia0V=fTuCYbny(%-b|)s z7H75q&tZ^##8JchO7;`)&pCh@C^<-cFy|0vC<8|hV}4?WGb1ENilc^)k{UUh8N-Za z#)%`x3-Afz6FDad@X6xHDFS?|IPzx!K201soteSRWM+vYXAAH-;>fuIe4aRRKC^&X z$owL?NPICTjtPzt9Jz#v=WDAg6UM-iOQnxYkQ)7ETqA?UF^=AH29Ct^0KP(Mhu9az!>%@^*27qH-$o1k#)Efji=0_jBjpE2n;z%q9 zxmg@F9Q%gcB90o4{Y7pS$M$Yx$GSj6uD6Q^vF{K^VmpvK#ZkktO~_s1sNuV%M(zbHJM7{$h`u*qBwG&0N>9bD~O|pACN3Bjv9VYvYa?-cxkDThXnXx23blRHN3dg z$Rdm%Kj)5cnmFq-UQ7c?PjS@n0Lfo@dN_bLlsqbq8s12<11B87n@F}7M-2~^8rhU- z!?a+I@v@FHzcDAok-rP@Kg5wInN!SZ<_vR|Imeu5E-)9FOXA4O;>auF$g2#Nfn{A2 zNB$|muQSNM#PPfOeg?m#!;v?5>?SAHi{Hr6yUC6|YV`jW;Mhj|o_>q-J}2ti45mS% z#PE)n31 zrH|el<}LG%c`uIqzzkwOGM^Ys`;-d+8BgB3fzI{>%^&kNv18B6wjOnw1gKpa_+Da4fEX-hJg4!yz* z9BCzv#PR^Vh&Zw+gY_0;uq~+3FD^CuC8W0I#5kry&&&znT{%-3OjA;TV>zgiHjFJ( ziYYCQEW=>i%QDz*OoLuFFAt8)WU!ocPOJw#OjAzAk%PF0M1LzE696wSHL{G+=PWCZ zTq(YV6U#u2KAz7=e0PFZ;IWF#5MCD&btMM#RA#D3qQDj2q+5c!(oC8LZEX!TM37?=3a@K8&yAkF}rlkeC-~ z5=RZkej#^p!jY&o=^+nEPe~t%X^5%MG+_Lh049)W$OJKs7;I-_CYWg=z(d55O$B%} zab&0f4--c=7vL?JmJE(3jxWa03m4$6q}N)!4JYQo^cX|GtvIrs0B>$89GRRKi zojJQO5du6?92vz#GcgR-4@brdaBPp6>B<<_4H7l_@HlZ~H*sXV0Pil2?7?805*TbF zfcIpu?TJj1I1>AXM86l4%wXCS0gm}o87v#?fFskyk?B&SpCQ1peZ84XCX2~t(8K<~ zkvRgqj{vVJj>KmkW5~YZNMl}jKdF&ec7J97Gmsg?3}%K%4i(3?4r6{|;Ks7H$<$1vEIu?)5YiF%v>$3Bc_aG$diM@|q&P83H@k{W%yy8}4xn@G$H zM}IeidGJ}C%qV6GGnM(7nZ`_KW-v3E#!M4t7Bic{I2?&-<}h=ad6M(RQNtHVE)+)% z|3z|<_+ri_%u>l^;;7-vC0B@}hOd-dC5{@tT59APW-YUhSuc*UoTr&Hl4r$H!_P^c7e@`hAbC;z66a;+isV)CYn*>FI7V&Cq(0d~_K4&AD zF$^4uZGa=OO>dcZ%zJU<2j(O5iTNy!{K9-?a#`?q5C)FS!{lWw7)xAcoj1_|#|As0rXGzAEDJ_n)mb!#^ab9l`#)^R>Z3K8>abyu*eo>|v zQ=BQu>nXu$!-?9O!FWlA55NB13eKz2zjwj$oeSp>jajYLXSRC6lfV~DM99dHwiERh)TH;9TFM72Z)JW8rAC9cU)Me^1 z4pL)X{TYlQ9i@+S65!5^3p0_Y!803(u?AZW@3a` zPV~%7S0+yACcSvh?o1CMffK!+Od^vc^pajOX9|-lq;aB`&SWsXh0Gs%S?t*Y#xY$E z(}(FR^pjqHPOKa20|OZJ1~P+~!NL&Ep$z)y!G}o=|A`sSj1WdjZxrWfW{fbF6TNZF zcxHkyQF@a&Co@xoshsFxJ}l#BVVd+Xj%lY0GdR(k$;@JAGuS3<+Z+b-V>xq$dD5HD zxqw+H{KAPIwsjG+Sirs*+rNZ;sepaKK4DvzG0O$)3wl__3TCB%<)MdZS23#v%!l3@ zW-YUh!8WaDuuYhM1G7=Ua?snvY-Y9yTcx*+b33y`*vX0BE@n5gN7yU9eVqH51HwU0 z^bRqHnIpol(mTp|j5#j+#);ku=6B`~;iU9Vah_(*2xmFbJI9=7E(q|80{oHyzsy`= zt}@pI_@Cm)>jL~QapVmFep4Lzw*bE-j=U|v?=W|nd(3_2fz*a09}4hC%wy&W^HhL8 z6GuK5;4j3HF9rB3apY?O{ze@6R)D_~N4^)}AH|EW#9(F~gC?1bA_#1Y^yVWNf51 z9Es}=*Br*+*iY=AtpG12jw~&}%ZMY(3h;8`$npZbf;h6G0IwvDtSrE*h$E{Ca656N zy#TK!j>L5b;JD_hbJk#L3h-J2yf#xuYQvFrnR+s2IMRV}lrh7RPK>jR8IE*eTxHB~ zq#NTdV}>I=7*8299O=b)%NQK^NDqCuuK@RBOi~+;)EFgWh9iloFJp!y8!-MdW;il{ z36wFzkqwz388aN&h-oZih9hx)aBeUL$1%q7$1w$P^Z^{_tRaIj^so%naP;6fUO2|6 z;YifR`9KfH8v6}5=0S~PhhvLA9H5V5hy8|QdL(M&7@>##4`!M$Ap*RqIIJJGi_wdaAaGios1cdY|nI%F?dI&6Vq9McM(TMFp*NjqnKzW zMu5i(a5K|YYQvFnOg9;WW1r%g?hN(=wc*Gf4E6(Kh9eUg><7l+J()x%iRmS^;mBkr zMaB$ArZQnFf*-cTd^3viq_)W`t>9OrEy zGl&^1z=wze!__;3d2Yy^XI2;d_H_$X$y)bKIPSY{kEUTVXU6PSrIW;k+^ z0G}+5oFc%diX(q!rb!K-&dgwD3h-It$Y259guywR&7=wNIRbnxGf!&6k@J}aG6u&! zEo6RSu6oas{(e#tcW|^Mub5#^5-AIB%;2 z_-b+F8Uemm9Jx+_uV*$eIDZ=jIL;et|^#b2L$**27UAnF^8pwACcN{wc*H9%xM{epOM;d^UuTf${l(m1j2;s8O#%M50KX-Uye+`*2=Ke&$a@0(z5st9j(jM< z9|`cs;>afg{HXwcCXReAz+VXPm*U7*0{pcA$8kW7d?UbdjBwrIyVOBR)W*9me4o@v zdjXDX6E(7`06!v*tSrEBouWoo6yV3ik>v$Au36N`vI6{sII^?=$MuUEX)C}_iX)Bh zTyR{=sFB8ZH24{*k;ZpAIIe5dNaH&o9M?E%r16~*j%yq>()f-E$MudHX?!Pzaab8dx=Lgq5J|k}#IPx8X&jV^WK>t1SL25Yqs4*>o<30l5mJff5^>!j2Vu^{UK4t3`gQ#ktAb=BXO@t zmNCPTxNoG&nBmAL%xoDm9Ql-)D`SQupEL7i%y1;`CwX|=F=jXt_mjNb$C%;B*UVBG zGaQL~%Q6`=9EtnP3K=sTiSvVVgE9D3#)8*%LlU(m*8q-t7RFKMW8ldA;z-PkL?8ES zVD#YV-{l1G0s_3C0LMBoh92(Mm>xA8ppSbrfEN>KvcM;z%Z!2QILCPrfvL*mH#0=$7Z(qDiFFvvi0 z)bNIqLE@<4jig34W`da}Oo(Jtanx{Jb4XloaO@lQv6(nBRDg$xBby8G7UIa30z6zC z*-C)77Du)b;BCc`?F4vxabyPp-ccOcNr2;;Lyg2W*qQ0VM2I6J#gS1`M~kC|$4JJC zqlTL$yNaWR$4Pb*M-7jc>@JQP-a|4$95uYBWTH4~c#>o<@nlKVaAb-&GF9p{an$g1 z$qaGS@ZOS{;;7+SlG);@;W?6h#8JchO7;^+4eu{GKpZt3=LU)M0>|;kvBq(QBaJ>1 z=Mz0F7c~;gG8|(#W=I@sI1)9^iBaQt!?FKZ1`;)nB@)LQjy@8{503rE^hne=PDYJm zFpwF<3>HTY5#U1^2sRI0G=}i-#&N+jb$-t4b#F4Y5o+FMLK38&{_kh$A;LI9HpP&EiO$ zCjj3fj>LHa@U7xVoTqKfc4mh-a;E^_C63%J!1stF_cHq!oI{*HIC8%@@_^I_#Sd{F zW{ybyDvla{RPvZOYWQ)fk-rJ>6XM9<1^6Ef@}&4F&eO~p297){zz2yV@!2}Z;2h%o z!I9_1kr$-CD2^I_N%FGz6;ABiRY~j*9Kf$hVxQmu{--4N34WdVi@70rQyew?Z^>KY zsNwi5A!mx?oZ;NvX5h#>0{pHx@}2;{FOGb`;9Naq9*HAyo&fx@I1=Xxz@LaCaekgM z&zR@p$QJ_qr8x4H0ADSRTqQO7mW82QDgfshWf2I zJ_}d|5@R@aNE|CT`bZpWI6iBb9*G*CF{6IR{+{{3d=y81k{bQb4DyRO@~b$;;JNaD z%iNrBWFB$U@Vt^1;z&zzjKT9s<`+j65XTt2pkyI&WMOfP!L1~Vh$D-NV+>wQvbZ?1 zggD0F){-T~kvKN!1LHW^u-h`FBvF_Cp)MnJSs6!Syc`2ZmKR4>5a1QXk(I=el?8Ye zab#6-q@4h_7e`hTM^+c$HN=rM#gVlHcx`cH9dTq`0bWlW=^&28aR6{faU_mgO+K!; z7I93GsB4HLaSZ}^M{y*sM*wdxj>L5d;BCc`xHbX2wbV#lqW~T*H4@h;fVYquiR%@> z!=y&yng#G?QX_Hg0=SpdNL;@F?jbc2*D-**NsYv{4B#$OBXLawxRcaKT-N~ZAT<)# zH-Oib8i{Khz-vp5#CZX5oEv;b@ELFt;Lg&+Jp_(1q>H4hI1+tK2S?&w0!LzcB<>w> z0Cy8dx{D*R9whp>mjF2CK_4~lA8@3HIMP!biRB=@#8JbG32@v$keCh*;JEi7u}nCC zV|}F=8)gRY6C62R9Es0Aa<({XI6nW#x#FndxECP3IpF|~djZl%95o#G1>_>02M*x4 zFCdqQqlV)ifm|kz8jgDea)mf*IPMq7bK0FHYK67MK*052tpcN92)kHkG3j`SBt28biE9Auz4YB=@< ziTgJki5ksN3hNMc$We=+A)K^m~zV^rE{HIRsQB_e>{R z&GY?h-E_7yIrvwkv70i(C+pT2z0I-S_#8 zI(%78+TdD={u)w+Ue>dx>s#%~?r}wWbh8?bDOQda+d6Bw(I+ALwU8EZS96_~yTc$$FM$+=*_Vi?LX;O`< zQL(dSY5k^UDlsdHK0R2c%*&(bVY~Heuv6r})qxjws!@%jsMW8#RP4?O+E&J%yoXh! zLM5wEjp24wH@h0c-YaZ8x`nvx;T_4G#lz0>0lZ^h%^6Q)BenS6gcXvUx#Wo)IHY=KV#geUmvrh z&iM+O9v?4ChbQ$!$c?;8% z{&sZbX>QsxuoivzkeixKb)Xhk^HGn%p?;pXmaAJmYSG2GjVj4HuV3NAt5hiuN2=_j zsrCtuG-_9%`luE5+t1^}FR%6c`(a*M^4AE{?)?R+&xvWKvhOU(qQrGmfPa1p*;H10 zeW)<~vhpWw)XW0pw&W+RSzoTw6N+a|Jbh zviwp5!#g8hmut)`yTtL-;zjD_<3aL(_q;nh@V_CdcF!vocuo14C0kJr}P ztA`fjO|BNDRFNU`O(iN=s-sRfOgH9FH6`2MH`$IkWE%cc1Cxct0n?YEBmB0R@oJ?18Z&0bDQ^~K_DpjmgIt_ZeUQN53 zPE$^;R0W5XF_q|2ha6n?nflzTM00Ehn7SUSM1fWr)U*8*wPM#O)xK(fntW)u8d;$) z%?=)==1%NGjeB%9)iG6~ZQCDfPkWT70|BqJC(X-~qwN>1da3f{Hv6?Uv}73?mFuxq z*Ib77G`Xnd&t00jObgNPvq{Gq(NNzoTG1$&Dx`!`(FsAc=4~8Nfgrl)98XIx_|wX} zadcw+UCr|6GIZ81w`q-C1^T?}xHh{@DT*5#Og``9=zMr%dN!aNg+6L$D*d_?;WJ-^ zr;EI_%EdBoN91up& zJ8xID$2X@*hqtNy%|fa2oJH!>(M~k2%K}xie<$i6GgqA)+l3lyFV(5brL-&8o~b>( zeYI}aA1S|~R$95qch%`No|@VDnOc`8M)M84qwXIrs$G9HO*L;9Nj;)}R{pI ztKXY-rWf<(sxM1BQpwz#R0n>3F38DEC%P;$bt$u1U8~v8)F%HnwJi4xQ}dt0)uLIU zw7*q*)$CL#{j#dPn)^9|s;>>#pHIcBZ&sHJRnQKeZl>z+bVsUhP)Ex4GbP;!P=_~+ zHtjr+CJg6)TCcdtfJ z+_2SJ)qy_<}H+T%(aH)*_5f?_8rURGV&^kkd#t{u)7Z`Zd$H zr{BOov{o;>(9sX;Re0eFTIosaRLF6E?O*Fn?m6nl%5qw(vd6Rr;gR%cayzvmx{TJO zcW-5VCs3O z+1;<9o=)w}l$jhuqnEUzFQZ~<()3o;sZ2~l6RU*6#wM|~GQmshMtyoYi=V(%!UKQ8;c9&MQ_v|qZ%Vn$Hl)q=H+^U$mTjr%{ z$WSX)Fm$e_R^?UZb_=wE83pw1{w3{;hW)~Lrvhyh#_JAlr7)l0;=u~bDbi+$!hLD< zp5Y41zj$SsdY?ner_dmU^|rb@KwgOrFqewyb)A-m=ARs97Q!=c~gNmQS>oy zeSLql)%D3TCzO899YDn>j1KPcqqdu)>GN-Xo;R@$-+ov>z>udPRehSysffoJMz75k=!wqRP;qY)Zrgl0N zEjM0$zMf2LyU$YZRwYxDatqaOw~}euyG81Az9jlMc7yVs7em>n7b*|VUVY}O=Q*+T zHeifuwJ4ePCj6wX9!;gf4z*SKfD9_+HSEY_4xWN%Tg-GivYOA8uTJ%~aU z7o^KPKJ8;c^0p763k|Jlb)_JB=~066o@%N;&ukk`Pz!d{qho6t6P`oU){R%~2G^zE z{Xz)Or_|%46`ohU8xB!;er-HBL=}#EulZ$!sWxX{=+{{_Qyxm5+JL6q{-8Wl>yzV? z7b^0xMl-MFrl3!*boRpsH9wCV4G;LFLbkb3r}B9yWSI+Xt(>1iE4fh}hx}A>zY8U7 zFGkyf-AI)vL>+oIpjMBIQt}<53MFhQpqm?=-dKzZJaeHh{45VI=Sq`17NreDRNbl& zHC|Pp!b=sRW?n>5jq^~IQ}yZcm^?JFAyJ0+Cp9ruQJyv*)x5Ptg`dAxr6!vww(Ki) zCr+a|m!GIFS-#Zb_+w>N&X3C7vZ1>!7Bq9P4ITe24>ev_nhKQ8OV6^ls9#F>QT1o{ z)W+qWRA@&9+UT2?f}Q!9mTf^F`8{`SmIXa?d!TN0@}!HCpQ&l1d}wyxM{3Xs4_aUT zo*Md_EB*PR3Vq_~0^+OC*WkQV%jK>*oajcYdHF{1s$8RbBT*O-#G34wiEx&&xN}jKj{f{9Y9*GawIL*=k2q zo8_g5qIdb4bD{Xc57g#+F4S*k5&G-7Mm-J{qkX&m$TYh+B}AL(P2d_Gc}a1I+dce7u;#atijs4k^QJl(irW%b$=S}Z$qzo zdeWACrKzriJDu`&BKHqIlzz#9_8fPo#7L_dfJfxD(C0=uWdeT=nO> zI^m{2@6Y_nJ$}v)EAFm8=kfg$&-ugmo#<3S6Fn%U`Qd%1Zdef$-XrjSf$gp3R+lpN zny9nMf!fVBk@L8(e#80ws8G~EQ=36q^z4riHET?3h4+VWi%f;*mUG*-%I5bdYIMCjeaPQ}ZZznjXYYF5=~{#O zdOx&EeHyqko)$fg(sRStu2ivfJl!rGM-6?t6W&86JWWt7C&kmnr`;%OcsFY2*^PS6 z>`tp|ccse*o~cgOy_J3ISL$rz9A*3dg^GFKU-|o3(4^(VRKX7x^y$lBRccOWs(Pm@ z%`!#M!|7eAYr8HKGp!q?9pmrNZgF%VEJ}ah`!wE?T3;HZI%MUeRvCTOjp6yJY2E$` z-@D!&j8Yw&=ch#uQ7Zg7fByOV7wY@xhHIF<&WI}7SDt^I(^pgFb|#vnXq3qXV?Dzo`&by z8s6_YKl$j#VMQNr{kYh^^VN@6aB)BV_!-C7cyGsj&n;!87JasdTJxqf?Vp;a+}_yG zr!BqI2x}YKRAicIzAi&8oluf0rA{|3+g*}o4ppX&qiiVYULB?QbM4Z)rv7wG6IsMr;2N?dG71$!2!aSttMaigO2>wvCP!C0D!kWE>8kI3y($ehDs(9V}ba3!ztH`Ve>Ve)k-uV?J`=l;Ds!0##6rql%YSH~XpH$QPz0{2|UsPoN z-fGX6&;0qyRK6vOQ|j`R@B3A*V}8n2A)4xPj+q@s*^z~5>E38P>-LVJKeS?0_H3A* zU+rpB*-B>0wX`;M{w}hnxtnYcl#-8RiG}DCwmFZ2< zELs~?iCmSL3Tve)`&K4h=u?W8);3c-KR2w`XHwqd)^x_kOc7T?=s}ls!sigV*u$H4 z=1QfHA46zP?o>Kl+=p7cOQNqen(BG?t`B){PoVHlP07T0dhsjm)v?bieAfqU!n0yD zW#$E~Q}fTN)WmCAzAi;+e$D_@`E5~ZJ)^&BWAR1Jy=g-S=8e^?_SjQko{8Gb3by2a z)>`iuXxBx(+f^+n>@+-`X(*8 zu$R6Z)StFCQTY8XDSEIzecjB#>dc$xs_1|atx@skD*xD6tzFo2wPx;2ZTZ@7-)B(! z|J7DC2)vtrSDSZ8Sb!;nVShCrXk!$)9$BR(?QWo+G|8lR zilUr;we{tmc-Nb%?F^@BTqA3?s7WOzuF){vHSZvOxGji7xyj0}C|S;0p*)Wj zrJFVR`DMPM9(^f5AxW=Q+v^2rP1F@t&#E@9;+R<)hAoAZ(>s&Heie4AwbJ*Rp+-;0vM{i@aE?=w|9Qum7SbmmoO zt@MCiRH9FcHm6z&J$f=uJ3S|rY9Ah<&2&sB{BGg&mA5HZMfLtn8sYba+5Ej~%qKhj zdrvo8d-a~b@7!%yQB7MOL-@U-7k|&e?-i51MkxG_5tT7q6~CL8G8{*$;J~J)9d>+= zGN zhej*>o?W;0XocUu7nC2XGP37sp68oT^MapDEoU~S;|u3&BWDE@ot>|>YZgTJeF`e~ zCP8%WhDjZ47)17FQnmB@QHxP!)WCN2>1x4(>Yil)eQ>?3-TOO$dY)=Q6CQ-prOxfC z*{)Cuc4Kr6(#*>?%j^GHhY_Cb)R}_d#ndt4XdrDSNGuGEuGawYgc;mrja_%@BJ$? zx2Q%7ooW6BO>Incru8l!s!0fc&-ofm)%r$Jtzv=t=W2v+L#jSMk}93IRK>UZ>CbW3 zPQG;Rnx*QN=tE!mZxl1zoi}-QjG(B6Z%p=|vPu29RmDVS(TA+Ps%XhfdK|S!-CmKw z?;OX~A6e^Q?M!Hi_=YPy@7DQ0x4yV-o zrk%(%_E!}|ooTT7h_dtVL?`R)RezZ~QsS+>>V8}tC5IkR8KZkppQrnk-+>-9@zEhQ zuvjwrZ$F@V3{R%6mk%rVo3YeuYAAK@8cRPFXioiKMv~8xP-^sih&JDnzlRoCplz)h zKog%9(Jp1wr=a1bwQ+?^RB1*V?b$&;dbjzb>HRG)@_iGaZMow`Q&Qrnt?glzJH|{K zXB||jp&iK_u}j$$=|o2k?Ns6U+flUdW)(3#ir%a~tl}fgbhhjfHMg9rqFr-yOt(UV=(jC_rm86oXqg|$|D*ruq%F|`EO77yK@~v~G&kH-yusZS7e`h=WeYDxL_O$(FSN%Ql zwBHPc_eQJdQxx78kF1`mh8N4GQQJ4`?{OU(ZBxOWEvZHGZK~?eP3cOlyxQQ*E;O=E zUTs_brWCX|M5{iji=KavZ%TWHPt{y6MCf^KbyLb5wOhk=Uv%tlEv|MCT5xN&)+DPt zecV~duW-vmia0h~OZd5`elNV*BaJd#=4hq)dhgK2$*ESKHgZJLRD-QH?@mzRJG$!` z)xJGh+%>C0_q)^kJ7$IVx76X=72fA^ADgE39H~Vqd$;TFYrAGo)!*OJ_HEVQ=UOb; zs__2i$IrQqe|S@y3mNn-HH7>*^M!`c?5o*iRo7cj{rzcMKWf;L-={ch+{&hVdz`6q zL^cgr9!Pg8W>UVv&h&I#Zz?l}>uYI*`^xy{X;h$bAZdZUsBvFsDl|KZGQtAsX76tF z>k_{IY>A^hv4QmUbS$}FcBWC5{99ILAmR6iAr|>5?`X50n_aS~-C_%h>0u`CCH#9y z8@{j1&P@^Z&3b0`?@cTBeA3@%k$7J#dVQ+G`y0L9s=u#QvzVdmH(k)mciX1$-uCL$ zG&N#ofAx05R#o|InrUILV72pHXA^$U#C47AbflwSpY_3N=!qbj6}Ukyb!kOI)~?cX zeeeeL`;;iXkLlLF-=bkTnSHlv7Cw#W$ot9aPXD%acXb@)pVox>_KTy^L)y?Pzpnc8 z`%vBK>IFZ~^S7R%cE2k?ufzALeO+qMsbl-}=XBob`}F7X>>m5{=W^BAvlO1o=Qht# zcrGXBnx&fab9u*>nQH#;ntr_9#za%8CN9*icw1Ug)t~-yb*0>a0sLLansR3G@1O6j z=}KpQH_!1P{QmF!$%9Vch^8(@EcJS2%MxU{K9Zd8UR3k0N0P<1y=rDkbNzRSIkmQ{ zmpQHV`_sp3PH5uoee#{9nQb& zeM@|A^jI3Dj}I#tLLNN*!{88oy@P7S>f6=tN({Z`^;`1#BYW>tBmPX&w{L#^48r!d zdXY+X<8A2m+9)bi-d11!>K$dN&&?Ro*Lu+CGb7cdJf5^QY_MAD+KV3jRhjzD zh@v8QE9>jIbLU&S?5sks#`3=zSX+h4x&%?g&C2x16r|Tyj zUf%h7?@W=?yr|8K%9OC%jheVrrs{dz_4UTxZ>Vqg-E(eqXrc|Nw)}h2mojvCZcB1@ z>qfYq>zwaK{ri3U9l)}lo4)-$#^qM&$B6v8|E?JsI@^uVM^4xtrQa`+VfCMyvZlq- zzT+h{WXR%W+JxwQ>O&8I{rQFbnxpB{BQgD*_VsCHQdJGvBy*j1>f{ntnEy73->;G7 z4sX%l6D@+5>)G|cU zj@y3E4Cx~y*EXU42j;4KBO|`&@xPbqeI&kr-kOq4%ghzOXTci%_3x#~qjL&Viy*IW zIn$fw@^}0eMsh#sKnS@mKW#!@^vk6UY7p=}(f|8RaTETXh@Pz@sm1{Q8=#R!KUc)J zKIgArTGF9nk$U3$QvSY8^!GdDLGELFT0ZyCw*$HRY<+SLiKMy#{(44#@TZ}}qxAa9 zp=f;^Iig~Hy`L{8iq>pSr_j0P?^z)$i_k}Q-rrn*9wPt9Jj(R?OQ->m3N05=|+e4frffZ9diT@Q zGP|EXzVmJjwNq*2a4$yxeJ8~_Qm_Bw#P2=px^&cQyNHf@y`gg(y{_J+4f*l-+hr~E zy6f^5dcERoGrcZ%u9;pp9oL5joW89+nb3#&R#>5J;rA0{saBbKKX^#0o)3nl>V1<< zD~jvxrm_~c*0X;|I8B;YRV~`j{eG2I--0cuz^4+bgI#92}C)KB|JpJb5q))%EqNXqJ*+V~ld3&$; z>g$^x>qF7JK8upR`gY*+gYD|GF;U;%s#_BE?Zx{o_V0d9cfIbodaU|`fB*1ZGgdwB z)1Uq?_TD=#ilu88C7LlHqKGJBPN;~ez;rRyDvAOsh&dpN2^GbxfVwf~gn|J@1yMmv z7+|`g2F0ASZgWE2m~*gt;HR9De&dd4c} zmwLr2=fkrTlyl#l1m)aYpQ0Q?S&9JjCUV1l%K5DZ`;_x3m-$*I&iB4@MB#&j!<74H zHaJYVf9?t4$}w(zxWYsH&0X6G@jU*JAa6m>>z8#sP=NY*-s&kp{mV=ksMO!$_7DNu zXL(|%0PWKxFHC7aIEVIwb7)_%pU>MD?4kX^AGE)g`-A%f<-z@d@NuE%>)D-f{?Wo|_ zb39o&lnLXmk0+Be^g<2Wa3$ZGRWV%o`>RVMmA|j@8>w7RD-Bbwe_CxQ0snh_hbaE} zPEREcn@b@|`S6@Wd~gnN!TE#o`HFqOlIH^0KTCflcyWKnzq}E^-*fZ#0+hG#!bbth z>mTz$iN|TiX941Yzjx;G!rviYxE|^Q*F$~4|6*R>p4>mwch}t@lFok*;5f=El1$po z=Oy?#9K-o}>hl50aTh-V593h&p8d*rG@;ryVVPW=z;Ovb0>AaHopKIGIN!3{hK%EX zha;S4o-3!E!x7F$T`jGg!x7F)*PKK)UMff6czb#Ya^>+j8X@|p6f!0t6ofJ@)!FdwEN|&9A_WxMAEx_5b_%Ml3u>=g@jEViT2@N zLMgoux%KUZkkX?)c{AXd(5jL*X?O0i65sd0gGzjGlz4n_g!q2(fkAv@;yxyy*`s zVG_T8aD2}1PuK&8e~!Rc8`NAmha;TZJGKAk2=-ZD=N1+?P8oOoT@KKE)(`&_qgQZdUFEp z>vy3TY0umDS8j0v?f+>-Nn*#_ztgQ!1j--G`wx^4M<^eTGA|#FaDTxb?l0KG{Re+= z|G^*h4=4}%2b5R73sv6xSn=c7Ql$wkCj4`R_fkjm{gvN=p27ZPeLy|o%OYPg_J*@C z@47FkxVM^6@n~n_waiO^zdO$)!W_=;b@CD113D5r$Ie1}R40;JteX(Nz5|)uCP*lC zxvj#VThLB9U%H(te{V8KOFX!rBYs}W_0Nt9iobU8UP^h98bOHzc!=Zn4NBIutD)FK z9N?$kSsP(s%&`{EDnE_=b*Fo}-y}Mv>yC zHHAoiY--&`2s$^M%=lhK@NGAee5>IuOz#m!nk0+DNRtud#mr7Z^tGX+ZDKoNSvO2mCHRe-C!?fA&|dJMn6O;%9YGKgItkzNQVH-_!L6C~*J}<%7LN zn5`fU30BJA&i%AsURLoxIE1e)+8A19_XL72Xc=AuY;z2;XwsDd&EVSX+2@VZE7C(pU&UZyiLvH{yXwF$hXuy?!O~{gFH>m?i)VNR7xKGr$Pt>?i)VNR7xKGr$Pjomj?h`fc6E*G= zHSQCI{jbJ-qQ-rq@PAp1`$UcVM2-7Ijr&B6`$UcVM2-7Ijr&B6`$UcVM2-7Ijr&Al zU%hdks5LR}6J2ZECu-a$YTPGk+$Tzm`$UcVM2-7Idnx-Ajr&CZ-Y;t0Cu-a$YTPGk z+$ReE_e}jiAI5#6|JncZVcaMB_y6}W?h`Hg|9lwti5C5TK8*WB|Nj3T#(kpyng8=) z+$Z`!_kTW&`$Yfu_&*=UeWJ$ii5kBrYW$w4@q41i?}-|}Cu;njsPTKE#_x$5zb9(^ zo~ZGAqQ>uu8owu6j~KrvYW$w4@q41fiSc`)#_x$5zb9(^o~ZGAqQ>uu8owvn(fB=4 zuu8owuM{GO=sd!j+gcR=BLqsH%v8owtB--S1RPxOE7_u!5DM2-7I|Eur8 z8~2GC_lf@BeGlIFJ<0T@Msq zzwjWQw|WWzE4@gW2?K?UQ-oOD9wI>dEKdv-IxT8Tn&gEETe^2t&OgL=RL=ie>8se! z@8hS~N0#hLz+YF7ZbZxdMRy7y&0X6G+gKn83Gx=ge2n`48(x+MB#EMn{bttQMoX(~=qAn>v5{T%8E6ns zQGES5-NiUlUY2&C!L^t_8PiFeS8)SN3mrn!bG^lc{)y~%@sJ`hwyzfAFFwDWz^Z*- zLNWehawoBJ<*h6zVKMco(?$GQX9GLxlt#<8)QV0Qx3NT*1qS{xe@iB!bJMNNddP5k zcc8O4G&zYKe71--Yvd+|N?Vz0b||$qX(N6ex0yArqoqL|+K9I2Hn4U3n^N3{n6GTz zTHLAK!rnPLQ;cytV;*0N%X-q&O-#6y$Oi0dNGHy2B^HZJX2Tu`1~_AztGLT?Co6qz zkU`8v@n)Tyh^-r>GMl{l2KB}E*rxUMMq-uTsqA*M*)$>2MZ6QRlLf@~r4#106dy$- zv#g`;bioxWcG|a|C@cF~RSL}Ff6T5jbiFVrUEAHH!z~)TeZGiFpT9Vd9d|5M& zwY!;4Z8wSH9oNmQSKb~2ys);PczjAc>pOif-RkWxmTo(b#m?MM`+Ij4Z7a-U-$w1D zwh!8h&;Fdxwn>NS+bV6vQXAH@qZ=}4Vs2fr#fZhMeT^LIZeCXmOx(y=VwM5U-(E*t zDkic+DH(L{OmneBTml=pKF0v3)Upu6>MUb{m-^puZ|e_Es0fWxQ0HMVk5HA$;|p@ zJiQxjE=KrlX9bC|^mx7Zbmt%2S?z@R^z^ShI%3~0*6Uglectjo{cFy4wrsI%fCIak z=j^Ya#>$RLq93QnW}D@wu!7~x055oTg6&`_Y}ZCT#aNgTn{9D<8yhq6v0d&6BJg4uNG-mZ?03DRSi8Tw`&1^HL(N!7O z+1Bth=36m|y0+iXdd}O;zB(>2u)+MM>@6(H;Q$+uGSR>W^Q%U!Vz(Bgv0OTkVvKFR zo2+53PW#zj=ibzO(>zxD_)hj`?UuACKEcyGXZpAlma(rAjSr4tpH`=^^}k`$eG8fA zk95|(nG41EQj2x0Q;B`-n`2k{(|tR0sk@)qZyZf0_Bg_Fm84FIa+&5_~ ze*032F>VLkZuHnGmiBQ!o0`9nVthODAlou~KYK8I27Oui40F`(XT3vX=%tu9tZSqF zOz>D}fY)t!!*(=JV=wP5p%~*BIy8I3f?d*BAG0KSVD&53$Ss9U=FdgNoHF_fLsOaQ zoo#gWMhkuPj#QR5ey#!T?rE;C8NQF%`ovI-J7&CL@l*D(pqeps(r{D#nMHfqxhK=; z$(_aY8MSva`=FE*9ZM^DMP&e(5b(Myg~?H0{erNTK>{01l z>SpJoZ__TB^bi)odY>*$#W>$Jf>ok_#$CqwBR!ZO6dndb5qZ5^SS?RN-Rv&gMfz23J%K&4W>{S)?JIoSUo2xDqV{Bs(1G0ZvEkJL(YzylV*qzR@ zsj5$U9nX>qsu^G$!?R=l`iY6_*r4}LH0)TAKDf$eR>iM7Ep{qUU$AF0yVGyD0Y0&; zi$1zn96Nt!6vg=I{2=|kfs5EdkG=GIzX1J;v2iSBY%K$f{jYo;s5kRp#b{zJ8dbHI zzNhnAcBivpxvWMHz5B$q?3wFuiZT8jAy+bKuWL(LZ^x?!zdJ$Y7SNkzXRx;+CB*c$ zvuNX?vsrk0ak0PWMEc$K59XX$M#MJ9B4g5iscM!jt=TaBf>|qId>|GyPwRW zFGdHj)(x!1*6uy%%u%!0rWfT6aPAd<8ggnT``*Y(TwY-$tv&7!R)14T(K%!iZTVm} zJDg@Intx8C)5@-5-CR#mjLj-LXNT;HV^8#_>9RYmN%O<2*_`Y%v?$)O(P*+ifey%YuHag5Q^I}+^ zKT3!p8_u&d+ZeW_j+uy`{n=T^89f)t=2?^!t0(iZs#P?L)t3{kmd3N*6aHW$zm*Vc z^19mi&0-rzmk@*IXS4QhtJ%ub3v}^Ar<}MOt66xR^9H!&{u()*c1&RvYG0Az}J(LA>vn`UpYPo>jx*N%&?v@uZ#xZvtzJ#5%8^TOa zR1$k#OJ@g?hOpiF)?&q+qwM3e5VkDaO2qXIos-A%L+zNYdwEefoX&#BRbgf(wxUnN zWo!qn!d_0VBCh7K^=ndv%^hSXZoWQh^O#dbzR)^)gve+SSUps`$A4GG=13szu+Cc4Ff{_AnE#)-B#VvlVal zIl*}olVJfBL>v$12d+BJZDut6{>4iC;&_TJd|8e4{Z+=GUOqccu!rs;?EUvr26e=| zbNXp!`F=9nSEhu44d!t_!F;W6m)L_7GgQ(CY)kGiK zb^-h4dyV$>v(V=y&tugSFVLUwEcFZ09oPeQjn1rHT3@q9Ro46LCHk;?3B5`7l)cR5 zI+e1m6#Q%PW!0V{dkXg8v-I|PvhyZq=+%LS%2vS8?qyW!o9%Q zk@v&F8$#%p3sxe=*rxFQQnCi6a@mokKw=6xQX3)^W?6rN=q z=McLkY}MQ$v~oZtrJpaQRVeD`6#6;z+kl`@sy>hI){zv(C3x;EVxwpze+IFC%xAA# z$5z|?L1Em0@y9VZhQj!RW58{D`|q5DLQeAV?=g+Sm{vH>P#9-!o?gXFg;^BF9~eVs zIYm=-3{hh%9CIj)IX@2{&F-HXN8|aJ31if{8>^{0MyVLv;Bp~fDt37r1sznFN6`m7 zkHT>l=2{eTE!@W-ADcO8D{aK{G04-ZyQNUbC+GdGxhQBZ&}A0+DHL>BQ9S6lnW1U4 zpjs0BmUW#urKQn|7q=Ps40e6PiifAs1IM<}zS(8;7ZOwH*7R*kt~fYhJGCjy8&wRs z<;K6ZQ^+j~b2-}gU%8xu3-dktgy(yOc_4*65c0!b9Trl^4?R80=`-4vr9+)B(gzJH zD9`4`mlxICo+j};zc9C_p9{5*5Vo6wJ}Qa_Ewj+!00kWcI->XB1GFmF5rw(>-#-7= z1#~jk1%>%MMY+9#3v+dv{;ynJ!G#)udUA~bxw>=sKI&AMx2qW26z1?WkmvBOs9ew; zO|<)IPp&&ak0j3CPeG61m89deQ>;UzN=ibOGe{>&M1X$nA^bA-DhK zw~DH{eW3GNs^<2e_iU!Brcg013v`Fd7wR$!+6`m-zjYi19f$E!haUPzd)HFX3m98) z&2nRO90kpS?J*znBT%nj97~sQT?zW}SE)p*YDpD`{;gFhXjP1NE(+2Im0d(Pa_#dv zH$dOE>Oz{MH?+Y#Rilsxg1*==ZWIN50XboJ=13tY#2Dv?v%}^nx#Hqd)&@Cb z^?9?YpP3W$`N@Au$VCpA0xfGd-dx%nf3G;E-dqx%*VQ((;Od z4a^x<@@zw4&Tv)GN&4=3D|(RUd$oMdD07CnXRauG-?FV4@ZcwY%v1(`a(THo?$2RR zE}oObJl2~SV;eVKU(1#A8PpeRQjD<;v|;&b6WBQ3wpe>&-kIMEt$Q$odx34R4z=U= z_wAf+4DK)16nIVsesj;aEz96Hw{YBMXxwHnZWoS$49391aaG|9$4R!HkC`x*K7X{0 z!I+GBJO_wv@H`>rKh`(T8F70vvn}^QTR2uT7^^Mj9-%J}C$sZ>F46k(F*?XGfgLLU zM!Pxa0zGzoGh>@eQEY?xtiWru!~AWm|I`u`(I<&1EL~rpw#&Oq7cEI+Py5w1 zunAvsgZ90h!Umi&F|ffr_KC~IHkeQSeubL#Phh>Pe$--&?J?hX;2j!OW;=U5yFiO= zFn>vSLSIbU&T7_hqIk~PcG_!te0&~MyxN-+>l-WZT_}|TRA=Rsm~yn!x+!;`q@^|`@O5f22M7d*Tv)8i(eC2P)Gyjb?B3} zilwF4nKoxO2`8!kaXoRDPZQQ9PfwdJwiKIfHp?nzdWwS0=jP2R*wo};cD2BE)XB+$Mr4h}#izbO?S$8Jwr@(isV@|WV78=0c z&lZ%JN8$Y}`1#9Y9)A*Gs>t@5}uazwe8jqqWV*>Q|)|#;aHNy;SFptYEnDuvAG-ss2wb-Y>dpEs_$#$3bEl1Hp zUW>}2P!^84D0>`#QSscZ(p$gjwkf+1$=66A-24IOdHY<88cs20wfZW2+VVivo}z0N ze6W8XefzPd6l@C1RbqyAP}>$`oO|OO9{kX;rVRYN`q)Fio-9q;t zaN`*G1($wkfyem<&QG?~x<+U4chIXEzt@g^o=@Spi4rhVN@A zysyU?-dR}uF`L3Wi)H*>#^{V$6y9a%`8$r7Q8OvLU$6s!@G$|(qyW> zn;26#2MF&eR1EJmhU|)?&kEmnv^cz)s_#4g9S`qH^4_ha@ZJQ+iFsIe(R9RC%HHKt ztS>MR>mN!#N~W;>0oGb9%1flpMr6@Fd|gM@&5d*fU)OjA z_V;>^f5*ex2D6CW6xKFCPB?AKZu*k1XTUx&#x`g9dWKHr)2O7Bz z&sXiSAIPy)8;r3H6U@EvmAUmf~x@AphLkX(v_JVjUWpOkpin zBwr_Xb9^$L#n*{pjIV{YZSEOcDXeY7Wx@Kl4hcyV*1utlZD1Wv{dY;UDqoL;Z7>h( z>pq;=Mz`{Hcd)+Btlm}%>+5j2z4$uAVih-2SZ4@p-p-ELOksT;#;`^%y3H2)rf?md ziXnfFIF(3YT^!`hIn~xvSi6WZtf|XCwt>d;b$S@L*kE1dq%UhJthdA%)`&LnTtSEOwWEx$ z5&i3SEQK|q7{i*)}7*Zz}GJ1>rwkJSwUev>cK``#ET9aD6Fdtx#=sGI+j46 zo!o7Jm-DrGL%zq;{(Nm7tmVtKi=(iX4_^yfxU-l*RlTfY{EXvg8QWtXbm;Ln$rN-n z#-K^b;kp#GDyx5;hApm3U)%kyVO1X6gKpK&t)+|ucuWA@+BmANG7jJ|0W|52xO#LU z*R6O=D2fN&I__{is_IsCtN`6QPg74B6Y%%|y47`EU8?F<)On8)u3qRLj$+uGHo zHsQ4>en0Z=`$SeSzX8oS@=5C-=C4n8GNCicaoVVD7p@~rOdJLurxjZCQ1bTe;WB+V zC`j+6God2~8)B@9ez)(XGhwQ|ilMB%P9_Y>!a4=#_L#?dq^SJC{d7LPeB`IL-`(5V zR>wTW`OUs+(>i?9Lhikw@^@{0o_ph*AHU1M?=0~95rcOkG?jUzJG14lHd5KDxnBFG zAzP8Zonq~eH9nrJ35pWLm5-g+^vyfyH1kV*jZh;N^H(Cp^J%f#RJP`qGX?+nzTkW3 z#LN9EG@?-MA30Pkd*<(Fttp?E3%OpGM)7&MgJzeg?W0C?IrqOeQV@M>)S^%>UTcKc zBjI&Qc-;}^@wz6QZ{I!EQ+%Fg%3?G7E59}BI)A($0o%0O)?M5?<44X(>sl1!M`MG; zjeL$G(54o}xO;Lhu?E*rS9AJPj6=rwi`m@%X#N12InPhLQ_q5JS`lo3m!x(TTaUJ2 zvp!Fvd7HZ_T5S2YNfckJc9L%{p~n9H+CG2&gm*X8EHWm(J6GC7oQK|_42&2g7zO5D30ptlezx`%Sqq~aHLF?K3&P$8r@!k-;k6>k5 z3wrQ{F8gaEy%uo6$elTWZ92`;0{&Kr!3OZBQJra72bS}2@)vE7P3^TR#`f3`*pKjQ zpAGiEUyFGa<9NWQS}raNuxgKOa17xGJoV4*YqA!X?`r{H)eOo3e8;b(0me2e1{)Rs z$?-Gp$LpyB1wSgrHrOZFU*=_jJ-!y(;CKLIdlmm~qsD_{z}H$0^VHAY_aUdJdua;z za_rNb;t`eU-2q+omk^HmH#T4&-tW{u_G1uMuf;ZiWiOpl7Wmg8tX>N?W4WKM=0CMy z1AG9-mrfD>&S{lzR|AWSQ|cst)2KuTNGdDpN=oAFZWOT z71jk~9vhALSDVmrh3&>;Q24@l{=vLnv~OXXV+{6iEiM>B_y_xcSC;A@Y*Y+o;g|<*yv8QRPGL9q#CknH zovq*m>uX+jc3fk*YZKVPi?LqAZe%OCUyEyAF~@f)INQ5})*@>co5Zi}->QSQC_ek) z2F2c^)=n+Gwn6c4W4}{d_S0&G4|Oo5%bu@Rcz-)n3cQ||yI_1%g`dp*M}#+};D>R( zrAZ$Oet@t3y*Gt&fqxVoMIj#G&-1mUMe$HausL*T0qx7{1=s4YETB+dz}dH!P-qjV zSH_Jc^fu>1rf*~ZD=f6QO+NeR75<%nO)YMp)&ut_JgqR^piM4U+^X=aM;+GUHW_HL zLE&T9nk#jOHitF=KA4xQ`O?^+O^$Ovz}LAIV9+K|F7SzqBMj;eaRUFXdW=DRp2d;xZVUmaDM?qKlHORRcxRg2J?1+Yk_ae`waL5K7#k94ZK{y zhj>4Pc;J5ZNO*cz-@r>ZQ^?UwQlBx=;S_L*X~^_QZ93zsXV$ z?OB_*Kdxh1!;%W`$?q4gBk<6FR`dG{yjm~tqwu^x;Cey1z!Tnoa9toy;9v3nhT|Xf zbUkxBH;N5jW=;ne;<9fV8$46+e5vhx^6M7Xn%lp>7+~-md3x_r_%X9144$L!&GicZ zuxbp&&(4G8*A#xu-njMlzK%BrgYFbl^`v%kt_=RIFw0LYR<)Z(` z9*>jIZmNGg9$x3|+^sMkJnp^Z&t2lJ>9pUaSTDf79-9?Bk&i{d3%pMP?#+3?%lP;P zxO#^U+Vvc7;Wp)e!`S8~A1A?{@Mi=t_#De|RX(l)KZHM1fPoJw#CHJE zKfhoD7@l$54w!Gx%LN-4A8?yM%)rBV@_T)OPvhh5?{yEg8LQM6c(reUpCO#T#p@1! z)V=}r1>Tw07xxE<4fy4S^;PdX=An*Yv#PMZgE{V5Sl>Y$*W~pDdllpR4)q0oV_|*O z`wnpe|D~|L>b-`#gm7N1uX=w6@v#@~JM;&@z-M!u$j5WwfAYQr82EpORU3=LB@}yq z-X{Try)Vc8`4|iR8Gc^?0}uTfu-fMVL;r!_7q}MqG5i?;3_Lt95CdR%)&RqESN7jv z)duRK-Xp-k!}EKw)Jvs5K>Ogjui)c6^ap59Tz9k0mU`f8@q2;mi1{r3n*ug)?*Ky| zPUrU&Y}7uF>wl|G{;HIDv=$_Ivzre?J$-uih{4qxJ{zquwtl3wX!E_|^M@ zd5BrJoJBjUm$+quNB6x-V5C4aalM9uu`*=Xd!BQ79L%(}2Mg;sl$Bbpc9V2fU+pIEA{XHbHB%6&sByp->mqkKele z3NFUW8o%f;`-A&=*`W$`J-u6r6XH=Z#0-9*O@`HcsD*2x-8S-i-F$qTRolCfe&THf z<3P>J+i4tc&meBPjN|PI@vAnsdHbt=AbzkBczZ73_ZN6aUREr>zYrV56LjK(5_7SRRsP{2 zX0Qhv=nvo%>In7y?sbw?zrKx$$4u$eO_vq?bIl8Fl^V~O1LwEFAqKe?>^;BY5il0pBMc8LjQ+n|M%ZPct-x+IMe08O_n@0 znL<2gZ634j97CK*Zg~n$;<0VbKdacJ^Vn1#Vgo*f+gIA)M!^qYh)wkavCV6eulOm> z+o}d}6nWlGL6Z)?YNKG#s&&rWh&-33pil3$c2qFv({9>^3I=_;!n>i!bpZu^iZQm? zzpuGs5Bl`o;pU2e(5F^AS}HtfvCio&6&~~{@La!8(5Jxjyqbc30Y6;tP|&B~2YAps zP!{lzBS8$ngFeL=+dzH62K4C@UN5*7^eNOAFyu?n4p1-9r??&JavQD@C}`CxCN&fc z`V_a%1b3ed?KE-VUr)E)6xV&k(2`0!Kn|HQs^mXy^O|4LkXhLK}iU#TeVP zx$#P|2Yq_*@hin1?$?}`Pbu7A$R9p^eyZ?re*r^31bqrN(DxvJfNOyVeF{E-2Yp(= z;{go%6k>q;1^N_YYy))xKcG*cj&LpL)7G0xDeVLKB(D2)z6TiE4f0Q1FH-U&1s-x& zT*p%%3KSmnDXt^%&}ZP;$Mpg~3eWokt{0RGJmlLreuxuz(5E>52hCkXu1_gw(uai@ zv?_k4@N?93yR*pkAO(GjpQDea^%WlUDSmch%hXVK(5Lv>*>c-P;X$9`=OuktsekNo z{|P#1`j3CyXFQ!gQZ*jjPx8vXqFnb;(5JYcs66OX+-JZK*n>XBeWnX97kJR8xNkt5 zz=J-;eFN$RJm^zA9xmnWpxWax6WUGnkH^6Jyq&o|RpPPiBxa7sV&@aT4r7p8^J-kZ%{~<0|l=PXPlD`V=tF z=Nafzz&xL1kk7-lTnjMJr+|S6eG26Q5Bd}^@G$lk#Y0`d2J{GExE971s5@X7Zvlf1 z=+n}CyyCx=3^Xb5T&ptBs({sY!|gMYk9%Mb&kJsoEqt5=9`q@06U_JLV=UOfvk930 z7BkSNU;`MQag1@BjOFEm4U7-C?hrrlFrNHgU*JKn{a$yq4*<`#s#0I@!}DzhdI9{X zeFN$XJmlxNKR}$ogFb~g)%%Wls3X{bJ_XEkat0a)Y`CUipil9=#yr#)Y(P)p`wnpe z5Bdw@RPQy^h3nIQ>Z{)05I*+8eTV)47x^Z!KYfsI{bG5c+jV~j+js9zbRk?_YN@hVbFJAqxN}> zalN2iumOFF>jH5C5B=@;_~HJ7J_TOAU*JdW58y|=Ur;XapiiM(^}b*pVpjVeVCa)- z{AwSDYt{P#*Qz{}3mE!8l&jtsh#z>+rx2%lFL0m7W#Jg`voI^mUgSE9f+mH$2ry{X z^`k0_T#HfArw*5DDm>`Z1s$vu9`tG6L#uzTZE>c!fhpj_yi346w2bdl7T*jcz_3e3h@I5 zeG2h|4d_#dU$v>r+h6qq@q-QMQ-6NHfCqhgg5O_=4dThqwp3yUeX8=%hF}ji&>z63 zT3_4Q_9EA(itg*t-B!V%2TR135xG94pigIx;rqim27RjXpaFsBI+TJwg=+zW1_Ymg zK?6oCcToI*K85}d&;IYfgYb;}yK&~FPeqaIQwH%gu`erfeX8haZ7Bx@gFa==>=YZ& zrz#Jz0narl1APj907Go5ABgRI*)obB(5Hz>fd6uEP; zb|ky!JgM|j8~N6`l|sn6CDNhj5%LX=gE`LNxKD}8!u+pIrc*s)W$P-(URWw&T+yQ=xtx?Mb@~2Dz}I4)UbQEwgKNlM+24c*;Zuc< zD<{drla}g=!q|TGlM3XUOIP_%$8;UWy-RNt275%vzOCJK1NW9At;Z1g^r8cTrB7E) zSX{I`KHx}J|HnC+!Pg_@?sxX<0EciK#PPM3!!+}?QF5Od=XJ9idkdj6!{xZ)%Y=o= znZkxTqvett=X>s*R-Cw%3X-#)R+QM0iX^wLpM0=qX#uw_=FQ_i3NFcg@d@U~P)z+Hw<6EY3uR6B!paYf2+;5%brN1mBjOny1{NJbylWj&G zI*em}*;yp#UVoEHWn2|r6ylN`pQv%;bBeN#6%_w_yj`@uGv=Xuhb zG2ZgUy5FR@rJJS7yN1ajn-@wqu9cE!Ep?UIp?s-(sZ@AD6!9p5GkYu|*+ z11*y@W4p#U5$S-R>ioF)=Z~uWzgnd~Y3+ zKGzQ+ahv7}4z&t&`>ZCAUx&+*M^+zn#J3yqo30VAcD$iu_ESl#i%okAqou!htvW*VtgZiA+GDLeUV`_2Z~F3d?IwFr}62ImTUw(ihGnVHLrpY$de&mWti z*;B5MRIbDnV(aCtskN?#+&kBsn9N$NIbCgxd@gLCkh5ixrevoM^4SU13E)y3pW!&0 z;}V4!+fSPAs_E$+B@gksrMXe^wC8Y-NZI9QMPc-w#=^?D0rG+S`9i&` zzl4Ve?4|tdV0rPJM?xc)9a5WZp>p(zCBnFgoi$_sijqe@U9Wk2a-inx&rmt{$xQ*{ zp=XjjcC?I^OHSUTIkF<(!@tRJ`J2xr0ppop=V#Kd!(_AOmj#T&YTfXdK<#9&GQK3a z(Phogi0bkUe{XWG|4U6`kL}Ws_hZP7xO+nK&vR0Yt1szQ&y+-3I!bxLy~qoTbDCBA zzhq@Bk0Rx&FyW@Aq;6wY7zv%ggaZpJk`WS7?^ZdaCk68uDGa|rYL@xYyTs=;>XFy zBDP4Q&RY|Ip{qPDK3Icszrpu~zt#_t1I9MgV7%!-898%YQ#p9mduge|L&;)SGx=Ds zwOnjiYhl{K5c$H-s{+OYBgShqr&`O^XEq~tM|4?NUqs9Ct1Ea`;rI&2aU5g*@ueD? zV%EX(;M(s5j6WAIA#Lp4OK$(nOpb7k*Cn-ek?S0EliR+ytGlilAaA7a1&pg)(djr5e|+v!que z!{mNXR|psf+@_3taB%xwu zd0Nd%a>JwRrS#Sz(&m_9a@jFWgh_uLkc5U|a;*+kg*{0Vv%cOQE)Q}% zZ-8-}Ul(-JZLljTue;ELSd6mPY%66eS8MH0$~?)4YyuB70eRlEX*ZNp|JFNC#{6CX;gS>ZV=3q%*UPB*Ra~OUGWm)%C71j?`<{ zOIn$`OG-XIg5*YylU9xLm4CXGF~BYBSCJ1!e3njf{}@+2?jg^$ca?++^$EtMb`6&g z-jt;MUm6P7e)nlA&y9AHm#r%)U|i`?JE>&tY4TcWMb=caYO=|S;&RQhl?ld0*~E2O zF6|Ts%jZ(}3mDr!%9f(jM#vo-mXO-+ohU8QPn0{}c&eLlr4@P5(_Bu~y_PfuW+Yem zDLKqC>7-c30|kZLo|nE;skl30=*1c5?U^ANgqq7x_U|H@RCWrW=0N zN{&48O}cN=m|#38!%H4Xx=NLrI}(iZ=1q~;MYWVlIh7WMWu20G9sVJeNNOizjQv+W zR!yET(M7rv+D^_WKS|E7G)MaKtBE@<>+s^ba^K~xrB1hae?u7mj+|Uml9WiRFIPBH z%;0xtrh9oZ?`}EyV{v=ZZ&YhRb9K0U=I#-p$+b{n(U~5yRPn2TZTz}966;p`q?_Gc z2)6k=(_iSDyhoZFHiAUQ)g_0Uxk#5?G^9cOTbc=SPq}Njr2+2tVYsgA>}a`i^?jai zkB-oV-isaM3{K`qBPCdQ=V|7q`|ZQv(6_ey1l&|f4C+| zT+~CVJ;P1zM;eimcBeEQOHYyOdj<*Lt9;OCTTYcr#<~a{*?djYy<_C}lhOs}fp>K- zm;1=^O-%^K4*i--wymbgowIgoQfD00Eqc{kzL;u8{;=t-v3fRLUSd^A!2F?*0iI(* zhe+0wrx5#P8r|71*^=3%FjAG{GaQ?8eDLWbPxJTza{0%f1&ndbwKTJIO`GVY0{bws z&~24uW3f;g@?``$vEEVcAdi>yhcyJ(x9J9F*=_qKot>jQY1|-Ax?cLAu99m6`SaQ? zT~L=aT}-_wQgKHI&ztTCbf3ROk%Hnagv#lux|7wXk@ve>63KC{E_g``QhQ`;Qsvg6 zJyn-9Ct;mDga_%zT12ExBh`wx^UP~v(Yo!oX!5m9lFo6IW$V0p(Ij^GDrw{L0G9x> z3FN|DR~govXU}X&a6Fiwl-otl3e0z((7=ZDJMSY$)>*47Z)I;#FVC@BdBn$>Qs0A4 z26ez)uJZCql?b-M7~90VRF;>XeIZrY+<+7d zY$$)RStZqJ){LyL%Ks@{d_}4E$>AjJp_SaU@eW-xi$K!mO}zB;IDAitY23N_O}n9RApgoP1&{7igXdX%3ADd(NcTR4?K)rzEkrtSHyf zzZV>8HYAr%68ZVe7-3?iY6do#pS{6Ut~{y|sXNn&V2o`(Zlm(rCv}Av?;Q!oeiN(9 zDajE+&U!*H#x_%ibdvY}wMuibdsTw*nYGSx^4bK=?RxG6;}OAYrFWZ-XqI${AYTqF zmX5txBG?WdN$Rc)kaje0MZTVIXb@+N=Nz3!ZJn^V^C)up&<@?!Z8;jR50T`xOH0qx z4jG!epQ6b2r!zdh9f}b;kV)j%y|udUPudYDu_g&AJ=dd6!+yl!rHO%m%rA~zrtxe) zh3ro6CoGJ5pmUuOM$RQ>3b?Is`~Nwkv}Q>YXOcL~gQQO%=IQ;THR<@W8Tq+jwx;>Y zF=Ttd9wEh}yJmdpsbq>pcVSZ10%3O##Q&IoMeegQpRf=Yiw zA2U;L{;4Cc`jG6>CI%SW;Bwn_Jniu*!j6PJ?M#j}es!c&hBa|G*_9Z?8E&l!Ds4;R zTKOCFvD>=(I{$mcN#_GS$+}_w~itusmZ4ZkZ!$`1n zxk$d_gw-Ak-J;2hrkgYaO7Q)KpZVC6l%c^s@3)zs^~NTeEWMkesgZdyE2C>P`8ary z=J~u|na92jCo9s=2^ibyGo+?YVWfD)%EGX@6Q#UlUos`UG{KnK_Lok++#%e(I)c=D z7cXfizt_CB9!I)(-Phf^a$d8yY9x6>D@krsOKOf(k0e7@RF`7I`?-(GpH5mVe(Jeu z`Ct-S^NBF2+(=j+`l#S?Efv zmN$@b%%-&-O3RX(5fW-G<9f~Meq3nQYbbea<|54Aohx+M8%m;f`3l$uw-vUrjNan$ zZge!UJ2O}Jp6k1J_lFSOs$Lq5vHyo5_l2?>hLF9Z8fq|}d$^1|CA=y5bNPEo($N6~P*emkdhrX#CeW5;AkMR1}|ZB3Zce zwj)_n#ZtyLn8)Q}KErvKu1jDkGW11|jQOu8S_)a0N|MbFyU7^G*Lp8iUsaxz8QoYO zHGjS^zD#R!zglg1GuK>`DsrvBHCH6pTw9k%ka0InHTuh~$c|p-#9DeS&5g~LW*-?& zx@6Q8dhDMljo0(vnQKpVi1N!&IUw!u8MpRxR?H11GaGJCg~TofLjd`k1jjk`kKOM_+X2lI2dUTEwy zl6Z5yaOmL)UGaBzWIopdzpPeDV=af0+hJRUe69O?wR6aD?iMX(02Dp=poqTxSMkw>%`5`q*lg>XXk@1i1$n9Mv zN$vdlq-XD9Wc!Xrq)f_n!ScI(k$hxKzVK?rO+k3#P0o+>AP1v13GFUcB_@8q1mcE1xZgSBedV|VqjA~=9qBfy+-q5*GTeFYD(%n=&ngkX+wsMb0$?w`5c+v z*MqFt(3Bjx(oJ{dbQ_X7Ng&I=)sj}0uS;Hk^(60J&5>e0RX3QE#5~rUZNexSy5y1+ zl4wHQIUZJs$E|KeDm}a^z204oU`>iKwi%q$g2c4kAPpK{n-ti4l7ScZNrx8M5X^TO z?MpU1EGaEIZ$q#?#X2;3NIw!>ZLrRK@-LxN!!g9!XP>U8#U5ehdUI*WoGrQtt4Q*P zhpklni?z$f^j@#$DO&M8^S-8fMrow1Z#?C&L)Pl%D~&2*Aq_jNb0!F^XfCd`{Y4sX^zeS)(6~ zF_@FLy|PvJ<3{7mhK-_SJRkm{d~3mfO@YVpi_;9|#>J%4Bz$+K=guiXGR8&CpKl)C ziF8RVqbb|eUdD5_4VMff4$-wWab>R<%->$OY((q_y!VuY1Q}yI$D866=b87XwLE51 zSA%(7Jicx8KCF8+zLC_T+cbGu|HGOeODuI}=cCAsL(eq%t-fYuwvHmVOtUoaN}p`m z?nM+CGU=ek&&f>F@mdrKnJ#G-%(K%ZABZB`>gH?M+-IJBJfg^EzZV+&i(lG&^Nk{| zLpliZ@?yHoXH!X!60d}*8DFzbdkrE3HhBv2nNzLjZJb5|_I40lZ<%WPJe^8}M#lxQ z;)2ZH2_wmY%SpoYx92>6y&g-V?SY; z&@=O&V>3mTHDIkj~O+XQmq zQ-2b%AvW{w;%`FWq5#5Y0W=<$%aP27rlk0k0?n0`y~&grvxTMKnP&Fu2?YQ4;omr% z=ipqZsGJAqGk8u3&x7IlF+87>u+T%csQpN|a>!gBdTP2{Guuiy_c~tJe(EsUZ|ZJ$ zhe21R8FuaE)ZAEi@48O%!WxmXy}N}}%{yM#XMl(NzDvFox7$?4evVpokb8_v6LQX5 z66Z-(Wv?BR1YsT}*aq{s+-ml>by*YEwizB1WpFL_>HpkYnGbySv<7Khwu4;x$Uf<_ zl?AyMR!t5qGe+vXMN4qZMcL!{i;5>`5uejext7&*xfj7Ws(3^B-hiYw_Q8Z;yx>E$ z{H1J4(>Fs`WG#!SFTV}E;<;t57r}Vfp=kMIy+)d|XHv3o%(!ha#<@4n;la;~dX03q zxgYQB8uDtJ2D+)tTbA}a$z4ZZYPpWSPg2gixuo8WgP_&pAOceCU~ zu;3Hdo5b~dBVdg4^XW~S3VG5nvTg_yaIRkMk82w7dsSlbsUyKSqqSCdYV;&B&3>k^ zv(-FZX2DeQ=$#;pKG|P)cSAJsZ!TvBKe(p}%Fanv z6ML*J>ErA~F#b60mgexE&B&i6T9J?C8VVo0JV+h*a_{D4;o-tfnz2z;iKbR3g88JW z+ccs5>_~}%PNb`ktuSx)J0Yw@e=@GcF-@&%14-M7Zv||FdFe)NjoLA0y2RZfMCfu~Fw@WQY@geYY)bl7Bww4aZD^IziL9`!NW7~RNN1|~kU+kk z0sF)l+kAKZB~2RIo1|}c5d0?Sq=MEX$jK6Q3~=JwZ#r>pBq?2EqHdAjJ!!(XAtWHz zRD*fz1>Yr?`@Km(&Dz4d=CbGa=VQsL(#g`=A-~+87nqPL4f@H~OHb0gK5a=_^E}_2 z=lSLMym*Oz?lQK=ey|P3*yfeyx->7L7wKcYS;Dv|8yxe@*#RW6{6oR!;vNaN!_d64 zq`O{A%y^EC+bX(yp5T-lKq`cvlW?2=I^Rwh@8n1B@*F#0Whc+;3;akEzUBnuojl(@ zxT8H;%=7JJo^J=9>_~R-e7hZA$I@h*FImmkv0(g>uhIItrYot{NfOfe`l|`s>mC}Khp44`5_6a+*NiMwJzRLm%5 zOc=mSkg(IOqL>4SIcE`bRz$y=9{k_AzxTVI!?CKXx~8f+K0UKDm0$)`;RkbHEB|T=<1gv)Ot!TnKBGVuIv;(cTWe99Dsd7BMkNw_N% z?>r_d=?@KB!ZuYW=;2vRls1*LQb*}q`DhpHQzyt_`>#YvJ8tL=y{y)ede$vj%{v!K zR;ne~=9vDAuA5XyUbS0Ebd|^bD{soWfz8(wi;s3hb1H~=jA#xI%531(k?mwzqx~c* zaTttBd-E?kw)u9lZQed|x_lzcn{EPKOOlDJDS)!B|I4Lx#+xlf!pllpImVS^S*fEe z7pra~1GXDL)wTVZl1@sf1Vzv1sOya$%e*ZQihJYig&_qRrYu+LH+>TXpBH{r4}E@^ zD(8e5h+F@dl&kL}ZdJ|+dY`SqpzQ^94&qkjobX@e-4M4RW~7Uwst$CR{Er~FJOlGb9U&?-6VUuW#q7ADbaYj3Gi z<3gDU;@0%ZOVp1Mw<^!xm9$c)*<(L;Jy}#2_CNox`wq(c5s6w?)@R5OwHRc~{;OPh zZzbtO86HDoMSaAi%KHlvCKWYp#SMr_mG>0BdYZ#4 z{qMRuH3<8!a^-!2+H|8@6=w)m_l7a${Sn9IIijs#PN-WH3-a1ddt5)EuAVg$-rMh@ z)hq3=i)%R(Ji7O1y;okeb-UaW-n?^Sct`we&#%0fp}c3Iyg#D6C(=tCp__13%Q8dji0dv4(0LSUS!WYNQHlMP7+-l- zquq5!z5kJxMNRbA>CZW?zWzYVyjJhgDbLd^Ts(C4g<2Thq=Bex7iHW1dE=sMa9Ilh zB@M+s#^=@h9%*4;$O@g+_`~Wh_qE_N>xAyKFIA6tsD=C{dv#w{-c&n1*1~F^={n`J zM#|@rl+P(S&a0~4J2jlede0^fNbf;fi}c^}IY@W^JzDM1Is)o;^(RRq2g4h)kGfX} z8-en9e&z21lsetwI>PfAJ9N``^kGW+^11djKmv;oGn!D7WHuPaiTDd+d*WBunF5s$uKq_6m zL*Y{(gxeblHW#y~|6~mqw6@JY-T9fASwjOIhFAz)4!jX#w|Rq&{TniGY5Bisr5)wE zuUtdp#!Q558K=m^HE~3_&MM2>O$vb2` z@K&e#uXCI5ZCYqNpuf1UdagP%R0|dtCy0IA>k45-8n7OhDNeoJP*CbP<34EP$5b)z z>?We5Yqc2*k6JyXMq{-^`JDgY>KZUKYbS1h@J{?)a~SLkJ5PPRuhVtMCP3K75^Av+ zetW*wt{=_~Cx%lc%Rr2qfcg%GT()KU8Luj?wVRdHQj zSE-})+4iCl1N^hWKNbEV57PfV<^RFHf|hiMEdM`!N#}3*Pkn26qi@YlAFq`8761Q$ ze_6*XSu1svHh-Z0JN)~2YelBAu2M(o&quWP1@&`|SISV-v=^%GIY z^v*ewhWg67N}U$(>s#Tqz;NKyjMb>$;*JYQ&)X^MZmYCBz5LG~ayxx2lddb-+`Hd` zDa*I`x6Y`He%`FmX^ehKI!gWj(oy=Ryspw8r5%Y@+W(se0o%S0{#oH)ji!2n-3I)f zP9JMFZuLfWx6fMEF}JVvCv2n7`1f)6CM#?!wy?z1O3FR{!SDTMyzJr7Eo91tMDqHQ zuT;(~n)J$$bd@?%&ZIm^|E{&Qg_#$+!}a~^GL&_tHk36gRr;T6{hv*xj?!mkEJ|AG zzw%m2ALhQAD~JYX?Vdzv+2fJRh0MZ1bdyCS`>%3o%-|nb4Q>7 zX+I8Q%&K)Z_bJAxyw)>}H=}S6k>XX-O8wEjx-h39ZwapGY|Db-?BJdTu>8l?%vo;+ z!-4WlGN}FeHM6xq;22rU$jY0p_L*CLR=>ISD^U9HOnu30YqW>ow zHeyfE|7477-<}360pn8YcR)WQ_Eskp{hWaQFO6SJOwfO&9VM;QDMA0cIz1+p(f|Lt z)>-uP+?+u~@>6*&r4I)RGqS%2780Kg(^$skWD?%6kW5_X$;8un*&Fs0(uk$g*v5=x zQtf0RJrv@}7B@73`gaQHuqT%6h}s0;!WFW+LC^mzA7SkR(XR@r+uRbWALatjHeDgr zE|$>94?ZyOT_HWywKW~yXA0b1bcOi%w5AlKpw)q28zl@}dPCZBu@iTy%P z*myLVbV@Cxt`VLvN))qKClt~XtEWNEuJmlTf!5cmS=p}xV=T>c!SoY^t=yiwxNjR z)^1H5QOD1v5c@@I`nkCaGoM~W8hVz{eIs1h=TU`p{JIj_p^FK-7gR{uJ4<%9feGu} zu83q^v1I>MZhtzN*1lLs+5~#CCxywh;gUl7CCZcapI?_s`Kf#+pD1IGdcAckYUvXV7 zT|h-FU$;K_UoqB0KeuA}tJC>Z>HobIdF0jB02nf0zW8!M9$B~}06ZJc7nEa4IgZGc zo#cCJ02sF*{~AX_02nOgi{o0O+4yL6rSx_N*PW`nLe+e@p$ZezNvv4*mTj0IHkJ z6O{d=%aa_cLH#TJ=ZVTbb8q<$`Wo#wsU!TW&m{etNk={nfUqwssIs4Q^QcUpTnm5) z21lr}Z%pbLYrCu<0Gx6}s+=3=Sm=>EM+0EdydzXOPp-}kC1P3tygaayD(Azr(w$^J zw#BCr9HS~4S~XQ7Vne`uvnp_2=2K>g1vO6YZ@H=+J>q%HKPz!5Bet-?7L=~GzVN!^;7 zBb|rkChFFtGtvcE{!P`Iyu-SFSe~;2=UAkJu{;~;=IBE|EI(dq3C)lmg5~UgXr<0x zjAbk8U|g^Z>D5>l;{vbtCYi2CA6PLB%&xS^9Emz}V- zgrd&5gY(446}0uic|vcjdj!ja*9b&OE8D$VZU|Y2Iz3b?iL%|#qo3JWKBfH;qHOD6 z|C*WWvHa~Ckto}D=*eU{8{7RD_5o+4=VQA|^vPBxECtKoV_(WgIu*~#QyAtbO)q2WB>O+x&_wVg!E6WYl-Cr zI7Z5l?ta&XEtGv;c`c<6%CWF*i;a3#_AFLo{&Lc|t=$>Sc? z#PTWl`$q>tW@K8>a4h$*pG4MK9T&b~d6i)u$hm?8!VE0GQxs1g4YVgCkxq;qL5421 zCLd5o+iAY=?8Zzo2Fnd*nUOg6Wn>)ERm>X;#R=BrJL;5mm@fum`9v&t=-gOzNByZt z?+P`e^Lic^D*HyU8Ll1ZBD6mR%WusYK@IV`l0W;4;;Cp^P5g>>COHxslWe0NisjW8 zET{D4EpZys1E0^QL6wc^Yt&ib{ap;qvY->N+_>)~x^lRN4n{gDu__&6Wl!Is&ayTs zR^=WEbUKz-TN5gd9+^NTpTpOL3dbrLQz`ag^{D;LI8w<0Lo`m#H%-in-Ybx1U)N#Ie z73*TVKm_J+%s_kUgLL!Q5i}I9^$T@s4eLPFrw)hx`DXMSR+=wxkA zo}kV*&8ti|ESG$KxH?oY8KxmpPL8gwN_wD8$^YJcCy~y!2}ENY#A>_wQ&Sg>5R3Fm z#|%18Zy%ND8Pk7?M{3*9Fr+ueZJ{f%JOt?uK|h6hb!=z^(!Oz9$gh4HAsXp?#|$zE zZA#^J-TcYI+DEzlpJmlD{%alluX$!;KaH4T90ac&GH7b=1iBOHE5rP0XT5zS0qN*~ zpJHS!8?q4TIp~`=md`~xGTVgBS`t)p}= z(xI*^tuqmmMl>v>5+<$Kk5LJ$_9@`_lqm2i`HN5M-YFy!K0S>1w9kbrRKll9TEb<2 zbt?N}DUtB$dKsV6{r})o@)w`FoW4ROeEM3(r$oZ1_J~jI z>J?H6pDJmkj-6(p=$ zflon!PkDZN&@r=Y;6JSP?S6#nAVzd5PEr%?0{KIJ*7z^9PkHPW7>!8ybRptXn-)b>!l(TZpLQ8jNQNRl zwLyGZZE6vHi}+MYD|P%3pEeqZ`&h)MYh`>&+af;wjM(#>Qz1Ew__QbD(@}ei=wE!= zXhRWYh)s*w00KJA3~^g&P|5fPuBlJP0cMSQBH zl{)q^KBWqLN)-4M6!?_KKD%NakHvf{;{x0RL}5N#AwE^cNO7Nlcprw~o)F=+)>WfE4cz^8mn zDaTO-K4lFn@af-iRDn;Kgin=Yrvjg{lNI>%@7Sp+<5PAzSR~5vVlU%UCgD?M|Ea*I ztSaJDWuNgud}{D5fH@;RRrZq#e9Gz|K2`P;3mKoX=N0($Z=bn@`1IYo09GIIsj|yB&@2; zn=(HY_!P0n|KU@flL{Ql{^HZWIZ>8Ztjnx6;?wFfK4o+N!Ke8CH&;@DNjWWH)xSBZ zz^6=sPkHPW_>@WbR2lC@8K1KEh)2svlp?)UPQxSW9#PRj&AACx_AT8lj3411D|93~aHP&5)^bf4tAIr0F zj7T`h5zDd9(@Ka*?UBBXV@;yFqmG16|Eqip#^Q}SIXGq$Wqe8%_>@WbR2h2>Twm}U zgZ0MsMHyoO;?vDoz8?FYGDc;2B@2#End%>W%KUMC>5XfObmnY^Yl@Oq#x)+VE9or5 z@uH07ri`PR6^=Wl{}uQY4r2Q%+sg)V;!$j0iuhF7UiA@U=3)6j>`TgaQI?-TOu7w2PjiGS+d|prmDf`G zP=QbRSg63HAYsyE8LL8d#8wsf6cqRrM*V|NL4i*}!lzFVKaN7IvGyN)3KBjok?|?i zL3|o7<5Q@H`1GcXPvH;Z(;yk2f)nDbQ8GS--H5H?5ufV$M#0Pqd@A8A1wI7{pJvPW z6s90P)ynu3Bz!8$_!K03I!(r>5cdy01qD6@1wMsDn)Vl;f&!nyY{aMeGClMVDOv0y8GCpMre9F52gHKuf zKlqfTVBX4Qe2V4&hfkRTpR#6%PlFMkmLa~bjri0~#;0r~<}h5wr%ZuQnF61(X8+(* zw&Nds%K9NbZGreygE(Enr$I74WwD4)on?H=)~1#G#i#5(;!{%@pE3nLWfDH^B;!-4 z^$$J;37^iD@hM37^dREXP{eTxdrrmv6O`>fir38;mQ*5dQ`rbP~VHqYI?ws^HAM z6Wrf3Plv(PrG}6ka4}Dkzcn5XLH!J&|8_&3pDW=Z(8GEQDQuCFBgy0AheCRvhVZVx zmniY0Q?>AH^f1Bw+M#TTAB?|;9Jc3#@M7G)EQue2yc_ZjD)@D4v`~NeG~xNOIkuAg zgIN^R8DdW!H+JCm5-b9t{e?US{@yek2GJ)Pz~M>9xc;nd zBcb%^E@FD-4$nu&$&O&;^O@Y4BJ-EVI6$JP2QdZbxZJe5Hy9rHO2W?Da(e@pd&A?^ zU&xHb89YC>vquRpzF5-9N1}NDOP%mT{BU50VCodZ`CWHY#7vDhtx^)s`J>Go;rshU z`XR@V=Rau8Q0RKo7|dMbx&2!GQ^dKS#?m_VBDjA4td+D{{c3b%vk=Zds(gbQ+;2qt znfq`)vX24Fh^j($??(I|pRVBFwr|C{n9o-)xZjVf3eVmkUEVA8>Fg^uhNF z-wt}&Tgq=y)hQ5=d6lFeGvV=1nc@#OGd5DEHyX~D>Sn^s(nRWfQ;+ilV%_0s@hKXZ zdY1E*>uI4l{Gjls&Jx~UKgT!F>^W}|se5&voCJ+b7YH|3;vNkBxjWVpI)yuvReQTLiFfcD0`F&82!7Q}IbRKbH#;t{R7li6 z!P{fRj7V5_<($gTVg#=rOGAJj-lO`V-NgAJSz++Y>|O5eJ@WXto8bnv-xueZyspRX zU7i;OUZhoCtE+_T=Q%~e`x?or#3BdIn{3uV)3vd=MK_AMziBxdSX`Kz*X!na&VP8T zfllTJg`Z0*bH2(+E%;hn2q(K<S#L)~v$Xu0vQ?Wi#e zxxO7f&-%UJ8&y4{z1&|{)PEqZ%^SWnl>6(2^4Tkn<&Lm^!spw4gFl zsDaCAr8yaGFLV9-H>X3ouP!gneeC zq8TMRKd(w4<-G6yM`Y!zG?m?1c|J0jIvw5*&8KrNbQGj`%3^UoD2@^Ky*$j@|30?Q#P!Ei zV=k`e?KL`9T7OrNeZ?6(KNC@IJghM9aVqfkdpIEs)=gMQd~QW^`TUk{(5q*RKuhHD zy8OKl?7rfp8&dX=$EO`J92RFS7iM0q&*O=2PuSJYM^zdhbMEiKay9F_eo3Bce;3Z5 z$#2fKn&*qR-0|Js=x+i{2gi=5$i`Lmcs@J1hQOna$z<<}R6btr`1r%ph%;p3$y(f> zug+8OYitilr7cBVU+i3!y&e@MrW%gn_Ga8Gri+g^qOSYo{FGsT^|kDi`}@yNJ|CPr zIt(sH8A7#1&A7e1k2&;pt$wtX+caLk%qojIzo#+xu*xIy%l{g`-g2CO zwPU~0w?XoJ)~TrvG_7%rru)w3`7q6m0*{VONZ)~%xc&FuK~P$dr8aGm$>s0*XkeP* zOH|k(c>R_ITG$_TSAC$fKIb2# z#y}VMN_2Vy7g;W70nW`6>7K5fPnxBHuny-%pNT|}^1ttEBx_%KoR@#;4Gx?)GY_)Ab4WDK6>!o(^g_5D& zsHVm_&Ul`|B}_9;A|^hpd0m4eCvPLd@zN z;{2<_A+X@;CTf?$c>Pzi{9($PGxW-K#;D}E^mE1mh@jb zn_aAZn&+qT!{cQ1yXnm8RydEx@ljpKJUpCLt96sxpW3VqxOH@5^Y(t``LVsw7TRVy zu+pqr-2Th1Q853s6WzoLd42~Uu!d+GOZIZnJuV-SVg#$>hp>+^RjAY+M^oxT+41Az zhVE`m;)foXM}}ARU`d_6b9v^}9i;l6`*hLrkzD@WE)*V&T~AAInsa|mUrmRS=f~;Q zVr%Zt;(p=KH!y+@-PWGV-OIbct*>2xzFN!k6?(}NzE|Eu#_TxD`LEO)u33DhUTwSa z_(tCJgLmhS(@q}0IA2`bj=AA;y_zM5xIe~J&Dw?4g^#UHay}@sFKepR14rE@&R1K| zg4KIdL}pob=KhX|j;GJ@H=kEjqc|TSX3+ab63E2QlR1AX*$uAMsL!S+7;%4p_KSoo zFWu?*C;2=cf5bb}5)#!%A70`4EB@ob4D+9m!Ts^P3GvW2Uu)L1)C^`CiTwJ<^`l_Q z!2Wde;v#OZB+v%l46|e_f0*)k?CsRB;z4J&x#I_J&oeZDMANa%WandEzo@9%sTXYvwxrq1g3tK0Gi{l--TD0Z*-R3m|t4v2` zF~o{U?Rn6v7nsfO$+nFy<^I%YznYBdHjCw%+4J~H8^)1re8+Y41#25g|J#fPP}s?p zm8Vwb_O>6vXN&{F*tO&ke*K_(SB1!9QS9WVMqIuu(Gos;*+93w>$$zycFquy&;rI~ zCUX9#@l3Gaw2=sH-|%=70-Rv-)8_E`PJLcKCJpg#<=!M(zX8wB%I*=cxcyjiJ$n=9 zx7N3Xf@)iJ+RO5Od2du-7}8>`aAK;w-W!E@gG+FCu^7H^doHOF&}OomZg}O1oF9;B z50CSg2){$y^Y*^IbvES3R~7f1ox|l8z8c6%UMCEBwU=M-OQIIO==q5koPY9sG+wEN zMco6%)vK-f{A>5957cknnDrmDkk>bx5d{}(^rkiXPT=tsghj((gCF9u;mojLU(cdqrIYGSn4a`Y-$rjv^<_EMjEh;_$kyMvW)ky!UwpNA^kN z{)`FNK;i(M*uXfL+dF3x4fFb0(u1eGxc-Jo8W>#bsW?8XANP0AR>T7~V}-NfY4Y`O zfBt02W-+3Rn%Cd?1K0bnOKeYAPv-jV58!$_*wpIh?m=AM4*5^WmsRlbXSDFTc}pRo zco_HR?pZCYIoVtYGjZnp<*6Z1aJz*%be_E5-RYx+v<2UDOd=Dwy)Jb_A+!Dh)wpHy z`VnQ~1j9r7imzU`1}Q)Hz7K)25tYO-Gfg<(Q3BV0lwoqLcfmn58GY*dc*NO z-&2f8M&h(Y-rmx?zNgwqUYt2}8rj$}g4KQgir1h2!U#4A z4s6wSd(+K26>q51v*P3cj5n){A7h+bTm?1;@#g z;dWf#_QEH!r*IEBe#n*c#of9>aw983jBGexV9^ym9d;pS)>?Dke`*g{b)_m1=g9o9 zw*#O&u!{PzM>AROHy8$QuOeJo+KBUR;{iOs_0OwQvoq)W{jhUD7&J)b zP`3l;^TXRf-RX^m+69iBKX}fO-P~ZzBBK{^d+8xtX-d5iw*2=h-k!g9m@*?9C$?-= zFqii!_N9mJ4PtxR%kfWq5G!65gW0+fDO~wC|dPf)ydF_`&WLoF>H9PQ+2sNkn>Lu zg^L%4Y1!*a?Rfp?C4pim8!h`1C+|mxmfL}ID^Y!i%HvZUi1^RUB=?hnJU*`#g+j9v zp1OdDHQYZf=6~oWL!DKrod0-X2&iB93*A4+mFm|KH$`pb*E?}T%e>R|g|y3KxP5a! zEwg*DNI1Uy1h;omThM z&BpbypmkF`IiFw@$;xAZc3Dx(uczmvVe?PF5)X7(!>_k5Mgzrl@`OJwL0sMh*TYf$ zdI&<9ydF-#`QKwr51scx6R!Uo&sWs8t9tjIU5WE|Fuxhg+u8=}4EXhyZq!2RnEL9m zm&fyXUn3sTJJ3W`?Uam1Ivt8+6JHtAxpDIT#trdJ>b7i^-rnB)`ss*odcJj5zv&_4 zo4j9I7#N=3d(!SUYAN0?*uJA9TIL0A?!m7==nwX_+evvH=BM*~d@0v5=jcl6?DFVb zNgvOP*bKY1D&J-0T>cd0BNP7Q8TI|n<;_t(wWLR0;qaB*{}W%eY|@5Bx&ito9IxLi z)v_hE&g-@xSjYK-Us~3EZ!_K7R;{?c-%l+}+NV~%Om*e{-MkgZ5_)7)OW$hTzuO-} zp|ZA6=FF*qg zPrT15k9*AZ9UNj{^$Pvo)}tD7{SbWr`l8VGHd9wM=X}@`EsI=oQ2oPh7x$-SjRZwj;cG*kC+_d{O)<=NqEXUBy?z<~Pld^BP>i_Kmx zw7Dwt-@JoZ@Tn~Io93BZfA8xUmf}&StG?nFxBo+wLb<`S&kputnYWQ?I3+dHsxS8s@Q=iX-3m;`Se9YgiM#I6-gl z2F|O_Xj%5qhw5I3fARdJ*=kt_$2hTSOLOk;(p9rr^1WfyBCIiwuXSz|OYP8v1P-{w zgzD(PQ! zp2GIx`BU6(89&{NzeYX>o6$}&K3qQ|qACQLXv7{5Msxnqt1R+hTXj16&~(m^xZ}fC z>OCTkk=M9C)wJ%cWa2maepWn>XYNmXR;#HQ6L!n%+09)(?1<%ka(_T7&tI+JYQpTM zUbN&v1h@D3-U{M-vL>D1G=%ddM~AUgJl|R}uNlu*OZ5NizGPLY<}n{{FY)}VlE#pY zcW=V&wZQpf&7O^U=lp8&{FUDghMM1((2;d*xj*kd4Obf(ZxX+#v>?UbGWWAE;jtc+ zKN!vV{4w){wHM7v$LsR_m{Z9??0xOS#4&#Xx4+<5G<#H%CH$H2oBOlZeKqZO_z@ku zN6t_GHs|QFVRr0Lf_%Q%ZTEDxKm9nFobSl>U)Jzue@X(WL9JWdAH#`Z%o5Lg&h+)5 zl0Q8!y0Pv)Pso(IhdBS>a0n~J^B(7|$9TNvzq_z{i0>D^TFd2MYffh&VW;T3X*Ie1 zY5l@kzZnrUeG{I%qP|R7&mc2(lFX;Qxmc=!1#4_*5@njbIv9l$|=>#8neEYasGvg0ttkGzBe6FiClFdwc zLOWO{OYyPg$!@Gw&HBt?oe_`cz*Y^*F-TPZo_9r*;;Ym@62If-PQBjcbN?^sN3r!T z{pqbm@_DMMMJVgGAK&x)qZzM{=L75+o)2uQ+=$1o-a3)Z>vxA*Q@MYnc=ckf5x+Z) zE#>;n=QU$35Z}*owc`06*lslqK|DXZi9NsGyO#^7^j>?zgoDT4ML{nN`qGpH2^8S`E$eBLaJceDk`;|!bLvI?e%59l=iOT2a zH5x{-Le`&t%d2fC$u}MA#q3*lXIGC@<^J5exr*-Gf#1NizRl~$TNI17>!X;RwkhX* zlM-lYhcNb($mh?EYE-9@o1&P{rz%`-sb8N3Iu2up2bS}Ec#MmsyY|dx36Ar5{J}*V z>Cf9C%+$%QZ4XA5^kTbiKjwU&XEmAO zSa-HCQEu;1c7v&AUnJYC(&N|bk?2o1;F>aFg^W+GyvF;f+kOZ&R<-2$dE34-gtU(q z4s0QuUv(o2b~&n4xo2#6{7GvgV3KFPYR%qBoPVIUgqcS>hkemq3%@|73UL& zb%FCgty%SJuDt!vPkl^$Ehn)Z7xg(Gd%FrOS~rqC^lQWUv(a10_{d;p++9Ae9sf9q z?Dq&|wWrDJtw(-a@CtaOtA5FW+fVYhg1EXfb1rR`@$OJE7TUCkQJp$liOZ*!`a{{N zDypBS3V8glOKoA}1f$$)WfojM2j9;>V8FJc{xjuxI@Pj+DwDS4RK6|C7mV)+E2phg zrCsa8^`|Uo2anoJRuAqgU;k$sut@wZf46oAxc^owS~H`n4Vj>)2U0%F^~SQ8kq_ya zo^!Z-)#P^U*yRT7sgW#SiTrWopH=XatyL^8sS0bfa^8v~%(_;r{G#+@9pZ6)b35zE z`!DHPi}rFbVQYsC;&Qd`dGcM~j;)WW$NAH^o_ECcy3d#Vg0f5-LR z7&WAA@1NQ!m{n z>)o6mq#X&9%B!%4x;C8e&|nb9B!YX>}}V=gu2*E4CWfq3#&oIYhX zpD%{i4k6#C^%e^K4%76DFbLbpbjV0Wc&m$7v6qEiXeVE!^?$2g{ z8_DX%0nDqa57)2sbr#r+Nf8T+Brzi4w-?{rh zX#OMebgO*cD!%mwQhOaO4`f{K8jrs*k3T|=O|H)E`(@RDy!u0-Mb&7|JM0?^Ena`2 zX+P_7zP#rMnC`hk>W|5*N=AoWIZ^3i5Y%rHi~6 z?=L>)QIHVXjC}j`j`K$NJi)K7>(m2P@_FX1i&}7e-c+#PQ<=9<-%rs{a_pSAZ|Dc! zKX2zmLPoS52|jd$^TutopzWTeD%`f4^Uvpx#rt1V)RvC&{dJ!z!KD8W4-n&jQYqhG z{*rwo?`pc3kg5`ZJ9JC(C&#PnguM+&)23%_<_s1&(4TPPywGh|an9Hj_ z>2j4aZ^^!9W4`c>6!JGr;m6c!v7nB;G6B{RVR<=5;CxV+KV%fgf{ ztzbxZCob>Q%1kIO)WVLuQM|tnjx?ao4$YuL73tmKbKpv!7xa*4OSrzHHRsctv=^$J z)_Og==e|OS8D|fNu zZY`U4^Ej7}KhhF*94)3@@m+9I{a@!Q!y|lePR5}!-u|D)c#2=PX<2xg6W711e~|c2 z^J1mfk8$}{;w@%w*0OIlPxyS{?r#GLokj6tl^)#Rrup??VC*vW!~*$#+pTQ;-r{0U z-J25m{!NQ^(fD4P$*Q@P@SZDP-*1OC+!#|!w`QUhuV1zx6lPz3b<}cA5^pc>L$kp< zOhZ0hkk7LR8hU|W`+D@znldh5`>jBo_FBuHktW<9W^tI@?CHk7iBGwG%kazi?qe<6 z>uAW^Tfb`q*kah11wYuy<-dE^fOg(?tkK|moL|1~jymKeKBG}-BX7SKcE-?dS&O`H zM_svpIj1^;ng6;x^JsZJ92?jd(oPK!=GKw-8xdWcV40^`Zts3=xPI*?p3o&?Sg-Dl zs&M|^xf$^8{&->LsxJlzo| zJl}be=i@y-ztyTNIY}WF z55NC#-CoE!Ykr2ykLu5aW#Sv#XHRxkq$_`>g;pK1^eq04?*JA20P`nGjuLt6as?z=4FIG=Zgz%|>N zDzaBzk4`NwBQc3Ksx#ll@%|cLyFL^*iPK$MBai2Wk3FGXYn3{)zTBTJ(B8X^7wyJZ z*h|mA_YbkH>QfJg@cJPQE5XbO9_k-k$8vsguMcF2!60?Q*$JGF!f$EKRS&VaiKRrae8mT<~uJPpeMVc{|DbIitF5Ah0NeWZ`$mr2cYz za}zk#ps~)N??BEk#_z5s#BQ>UJL$^#uAg_(^lRSCyflMI`mFEkUt7zvfS?fqBAc_%g#!CtWY{#ChU*+Yb)SaN_nqR&Nd2t8Ky4LOx$?ko<{U zvmQ>jd>F&y?d98rP3e?H;IVu^IO**MVfLQ=dHo&m92)KEdn}aZX?FS08a`ju2x&^I zObKUE`h9pjn`*71!w$?~b8ZsO7a1)&BUZsml>*VXZ452;?|1*QCdKl4@e*TEntTsn-~cUzH158avsqu(s% z^*c7ZFMh2R&Yo#HzTIyxX`W|=`QbcX^QiR)CEhydCXZ)z(*T`UiI&~ZP3P-nkxd8D z?W~qvI+vI$`MuB5T-4$HxGyy#`Fyo>XAYUTI*@%c+%LDMNmX*XD25FdNymHA)M+ZcI@R{wSZnnquxpT2xjR_2JpX7-;YOJNp}cBSVtocQK$!9plV5 zO%C(?x9%PeHO~y!T|E@ZdHg;G==JP&RQg_qq%XKcKp%Bzc6`ZH&f|A7;P<(yhfDCg z8Il~o-2rpcwpdHw@{stnn$EDG*9Tq8)h#%`7Qa85FyECvXn&AOa)a?M5U{usZ8^(~ z%a`JOD*ic>*S7SfAjw^hYGB_$wYULa$S&~>oW{e-z@9>A^bcM?e@O(J^~8fXJ8$Ir z_3t{fqPI;T^6G2OKOY;#NQyn#51o1b_6!-qmRxKIZfc=`0V%AG}eRHl9%)X}XqbrKTc>j6pj(guK z2UIS#S95#yCQX8UH9FFlhwt!w>qctX=kcqA+5J}Y@sJj)Wh1(3gk{a<@_2qZ;n?cF zL8$-HjE|=y85)RMY^8dcbdlS8nHd9bvb=R2ORIBxb+hq#-SLNW*KEANiM9Fu|c<2$z4$)Uy5C`wFk_+~n;UkfvoRRa}K1 zet$TBaOq6eesL15YA5Hj@2?oPWox1MyL@XNZ{OyAU~0ZxtXBB~ zk=pAiKJWK#_GI0U<}HA@n?{P#FVxRG6hEZr%euQkATjhh*t7aT{M zfmHuMjY=%+{9d7Dsuv$03kDgmtp{!hO?B>^Pi$657sRa-yF8o9`TP%esQ;lEy2kB% zIj^@ifIaY~G`ik4-v2j@TS2=KD!R=I<#G{!oBt!^AsrWM#@qAc@))+qsxobVegbcg ztoq~F`lR2qn`SYuZ;o?k!~NIP`tI`m$icrc{;5w@ee~b(e4Zd$wr=L`CV0KvZHkd=(-=<#rd(5`Y@Yj zO<2DT^7si#i=~sE)f3jl%;x@EwHrt^1-IzYIukixdrk|{407qCK7pJM9~n$zqtwEL zx#66D@Y;v@e?LT%+so^z#q$_ef65=R%C+a*-`S^Xv-cMq!MW#dD&@b+N>BDxD5ZZq zr*ru}Cru=it*P1cdfT}wD`{UwsQ->5<#jyB_b z^^K7%>d$B4?d(pRk1)})jpt_y8w+Ofd_Tkcjl{dVuCw1|-d}nlc8l(?KsBKKU@q6` z;o5k{fOg!nOpyFru`Gg(={b=c&;F{Gc-wBl@Mh3sTc3S0e)y0wnT6GTLY9qK&-ME! z`Lh%FEMcF~0+ICl?{R0lUe|_scT;%$dwo4vlvEtzTsk4+={wV3i!J8PCgv$&AlYkk_a;3SUzap#@5A|8zwXg3-+v0@mrUloFtru# zEh2R3_-z$Q|I?%9te$yiarsPV&NuHr9A0@p5sPi=F-d-=*#J0uz=YPgC9ez^}UA21a@o42jaIvKHu|nj$uFF8j%}I=J0%MZ8e&$W>sN9t8`KFr_$T5V%f3* zWb^Sz?r*)IuC!&JZDfgI5a;b4da~K(Ur7JDcD#Kj59r4ZojpdoHJ0(q_(zDH)9>mo zpPJ6?kLcNl?e+XfempLf^2=8BI!Nz*7)2(H_T%;n!iTWR{Y)Xc{~F%DIf2nkH>NW= zIcN-@Z(3zXGv|#Dg;KvaJl^NsCa_-GPo#NXW3FG|kf%#n_Kl?Jc}w|ZonlSt@-6wI z_$P|+B+>Ib(_89d{NyHwlQxjSyy`>zuwlz8rJFw6?~T$ zbG}z@Fq^(|4>7h}!TGXz!1^tI`F`zy=*n#Itx?dUWe2G~)bi73Q-6+tSK9`2`&Kh1v9?oRlHGJbVT`%JA z3EbAGjull!xAdl#6oe231fys6YakRR0yrk{792QSL!=_kJ6Hxs;4#0kX<`St2p+k@ZR zD$M@55Fme78%o zKFIS~$+BE`2+!koEsf&)Z^!T%^sDhmFd6uh`#WS&710XM=S(Mz*@DA-|uq!3|KG%^bG%q$D7ON8&zp2ga%HrTi$6cw>PqM7U+Ao5EtG};Jh9_ z|I)Z_WgF>RFH-)WT+zakBMrq4HtjgS);<(Q)qB|c?7;O@l1B`k1>MG071xKZ;<03*&Qz9ay*X{K5x^qql@}+`EUJ$)Em#^ zUR^)NlzY27zcpi79MN{5C>Ly>py`Yx0*qOk8Z|l~j0UKb{m(lw>xqe#D z8q9B^9a}N{9_MQ}y`?KdJeaj{6W^a5$?pj1E7q%C$H?bxzEQ^bdz_}KCX40sIK!a6 zka%H$m{MClf17vA5%$@&vvWKnkB@RAD-Q7bze=EB*9*Xe$8^?#s=WV~d zwNNj{N`L|{KEEyPfZsVC8zh#y%D;zei|1{#c577q@5$$F9tAVuTRY>t(}CN$|Eutu zHQko(Ir_t1-rtSD@76p_s&0$lrQz|PgVwN1bW^V_cjA1@R1mdCwJf#4dcHrsHzqmv z1LFP6kA{4``T99oii6E)9?Sca|49eI1o!m0SB7)>wcyq;&emBs;F@gj`jwe*=7wSJ zo9?ndDYdIXpC!ZCdF^Z? zcs|@FMZk(Hy558Bd^sOb!xuUtWnk50&>r zFFiDHsO!1^kE=I)(4r5a+w#8`jG^X>4wNpdQ5GtSDwZNXBJexc?u0 z-#}ZXd<(nY@=zcUC5hA8yK%m%Hx>xSvYt?f58?h17Y3g{Jng|QS{29Qw)YX%?~7PO zTk{UD-v!r(&b5uSkEf4d>;2uIL7b`6PiQ@2D=|K@dla&LFO*iS8-?xfB;fg^I`JJ% zuT2}f-)enq9kBWJu9Zs7DdG;F zX|}CY!RD8A-W$0d>;u5pIm~`%HgvHfz65a|O&!JR%XY7z%e)N&<|)P4e4HpY0L>@u zX%+$a{TP^o2UJR))O!VU@^HuJ01Pp|KPYF1#d9M`3e#KHnFsqjyPCqa6X$WMDEBW& z7XORoG~oATWBQ333bJo@1#!+hBw*)_WBro!l`Zg{PW1=4%(s=U&wss6G8Tx_wb$1P#Ns^(ra}qO$FXxQIrV8^hp^QqV0hF zQ97fr@=H$J*vpH9z!hI!Oy2ioCA$*dA1fSqg!OO!$N(gmS+R5@aQ*EW z3}(;OwT0-d+%tfhq=5P7$Du~l(a0Gr5yJ0xd`^&LFNeS3PnT$5@flg8r^~g2phXI1 zkEuKA>?LqLjSG&(^cfNxL(3hUK#VmDv#SH!0CiYiOV_4fegTUHN8!`Rf{&J-2 zqy+)9w?DRiITHzrQfrABpVu*a1|s#IbUB za151wun+iL#rJ>m2jfwut`kTzzW9gHp}t)Gj0k;4799Y;7qy~;@E_N{T=~bMR%Dcre?$2bUXES=3(B8ic`y9;U;Ur3 zyq~DgE&l?`xOK2{n45;1f9N&LRm7FKd1$z~gDMI6JFNEuUNc2p-v|E=L3xt69_BFO zOu=iuzmLJLhdGe2_Si5F64u_L0~|O$z+6dKd~n<2<~N#w zd6Br+55c-nXAbu-SDt{^eS`8iaXoju-2691M1TL~Jz~K;N!-8$qpE!s3jfK< zVlRr^?iOJ88>G76_xqI7P!>%Pt1Ag*ZVsRrL$m+y`s^2lMfbe(u=^$4Hs;*Bic5c8t;WxT%-8t&vHO@0W_P{V3{2m}(W{?u>sO9hV)ePXWw>(C!`+w+b1z{z zfbI(MVg79g+p~o2WfAQW^*JjQ46ydrGqya1*K-mA_F(eQMk#K8oS>C9|F?b4hqbRT zIoSIz&CY!bi1WbDpD^A~=-*(Lum_A4Zv1hejWGMecmdoTM$s#Wu3qi#o8lcAK{LRYZsz_EQb?U=FShy<-{@xO~K}eJAVty`Pufw{QdD-jrsk< z`ODaNJuR!~7SMj#udiY4`9YbmCnm$ZPJo+pDY*6`Hc$WASNcmErq3SdF>ZUDtf~Y| zhU)?x+X3*0u#da!7^^KJ3M=AND;-<=XRha~`%I z)7PYO^t={x6wh{Iqlenqd_tLbHkqM2ha(0~(>v9hf)jW#>h3)MYzXpPNSt=92=MtLHF%xccjREe0Ej`oE!mcf~W% z|MaVcCr|Gv-KB01$)t}dAU{~J%XX?+Q|yaDE);_A0<-DYgOl~CsDZ@Kji=Ks&a zFQTQ;K3mUrV)H?P-@o|oRKzN`m*eigI6Iv^fF~`A+VJl&cYGW&EH{%aW{F8)`*Dsi zEdQPv#pIjE%lmyzz}3`nI={Izcm6mjXG}n-SU7u~6E5eW2uH3YoPP5g_PjIaU=zZL z+YrwF^8uGtN_jbtrTbVE5_W%zW6|>uUHd(lWf_A#AHvaL(9qmxHLTWam$>?J_SPz+ zn^!zwUGehAi&^$si>3fv0 z{W<*hP#0TYc{y^l1-IX_$pPx?%tW@&ZoK^R{#g3{Qb)9Q3ErN+YdFHhLUMH~=`akXd5-r#DupFrT3}*W>!Bt`SEh zTzZjF>oizbHUg2zGd)yzz{Y-%Izi>KrA1=pMA)F5DaQ3Z1e7;+rA{^-(_pSH6#(FPd->T~$cEO$J^Rhno_r2z9bA+L&2 zMmB;>mhXAI{JRGYu{>VG`ga|-ukJ$<;G^_V^Y&xUFLAW8NZ{s{Zf4g3Tuww0Fy$Cd zfASq4k535#-yjWVKmU!(i``6sMOZky#SZt!d~XxL+Z#?FJc!GF=iI@e>Q+`>2F4>X zdlja~vlO>t_X{}Pic6?_-aSM26aIxvuR#aW?KpKAxPN79W>JAa7CNGW&!1{i0J=?! z%GrlMp8@Z?PE$VyIHER$f62yqq9cDM(X9ozf32xlLOXdmlf9epFXNzYHgolI^k*}! zzv`kvYEpJ0{Qem3U#4fCZVE2PL@4K#0-?$hfH4=Ea zUXm#iqeKQ@Q}OYs=#8^dER&H`+4GoxC~2HP)-VA0Ft84jgW^um&UL_V>ArWzD-!J7uC(&dvD+bAMsw?bp=Hn_(UTZaxC8zg=9roXS2@ge%T&8(x3Y-x2D^wGr$Pcf4HoXe`~K(gE$0z~`@6 zzLdq7F+(|77qRgl-ffB)`w4Qsiek_Eas1cafZv|FiFT-XW95rvPaqSrfMf22&)?eg z`>djzVl?g|uHWoNaYR_co?|G1`=^lyd5aOu9d`XWZl9BTOmv-LzKR()!am0;Xch-b z&|ypb`i|r^=oyY3Cv7W!{jGom*6x=#(avRf|AT7-(9^+Gj{iw~{T#7Wq}#JB(ePFH z_+w9aqJ||?=(rzlpQUg;ztT`dTWKkat?yhp;&~Cx?}#k6z6Txm03SlHGOq~~V(Za0 zC_lM!m1;uBYrqY56uMJTgq{>-kJ*!nYNEBr1*j#&dNlt?8LeYKpji{Ymu{#gQY0n7tR%{d zf@#Q?h#Hy>u|ByRn?Xd7FSO5UczgXhBw+oxi(0x5U!Tr#5O6;toW6}1A6L$Z2xtE% zS3rFZ!}2z3d_CgoX9LUslS80A9t2-y1`8Bo{u&D9(%`F9e?ndY?OFSxh-P)@fA%eh z^1Z{jeczfME9QO=9_BE^^xd&y3Dpg*XS;~?tbBP>@elYt{cZ3Y;M{oG)vyM&O0wgW zaq#)yW1dC*yC@5tCf2vl`T?lbW-3Rh7N7t5*&Hh8rURN#i~IAdo{i|VffxtLGsXH_ zX30XmuY|FW`QiRo_}dxXWmQdM9m4A`vE)Z=8}HM$GzVbyB`jHp&6O~^BT;{rWP=@QqH2^iA#Gukga^UKKG&hW(~x^fA)L1tP;Jg4==-G&Tf%9WV*pp5A#qya;Lgm!) z@#R7L^&JA7mxTQWW|e5(f1jd{J8=EBs)-{l3ig~-!hUNL50}7i)}!3qYFv916v}Lc z_TwBT>{F}f36|Q%)3$HK_a6=3?qF+QD^34qF~Y4s5B)t9`u`;&o_Wrhfa}ozFA#DC zjOP?6j}!Y3t_;iR|H)fmd>`Ncj_OFnw?B;Ue6k2ThluaJKAX{{;5Svk0N-C2vsBSI z2OZYq{kZ&@t%)pA5nxsk@x21Z_oeU}8bZXkY{5Lz4%;w?2g_N6Tnz2;y}y-q|0cfwD1r9kh4zZx zi0?m=7A>Lr!~LxZ5wD#u)}Y?dzm5?8W#N=XT_=!*j1%#xq!)m`g8r3XL+o!?zvh z#@Cr^iL@~yzD!_z-B9+X-y`Z5doh{ll~KRWt=ZyIyvC0BhFj2>MX*6{NzrH&mgz3CVfxY=9Uj9^kH_Mk9LO{*aY}LxYj@)ueV8v0 z>)#ELVn#`vL{^@_*V}5bL#+FT!pLw0zTO6Xac8Mm=u*q4@bOx05u<)9zeJx5#pSZQ zKd3Q>LfP(we*G2G%zoAsdsG5%pQZbb>UVo78kd5%m$}-wQo$KPl!)<0S7qy&!trh= z#w%N)#>$1`r4r+v?55DXo<<^dgud<@*04S|&C&ab@h22)WlA?IA@2x#9b<8*MPY{# zJ;GichdpVhp?zNv_SF;E&6@c?^Ks&34mBzLfAjJ6ehBm8|Czr_VYVy}{V28vG2bR% z_Evhp`A#S1yKQ#>>jw0X9>PDEw_=!S(4UkDf0|03uM9sKi8c`a6fT@mSp@x+kI?tU z%=>bd9fDpV>~TE9mdb3uf|6I`^EFc8M`M_}pz(yi3M5W5HLIrBp9%XW9(YF$N?VF1 z6ZW0Y`9al#^Wj0vhsP&4e^gy+1u=iSRmG?yWtZqv#QbS19b(NI2qQm<`L5Y4#e4w$ zVFlq2jNTm9wkkKotPel$1gt96H+xu&uo-wfYhG)sydJ&?v3rfr@0bglr6+wKxt)NY z7gwuzGIyo%p?tk~`PrrCSkGT(pwpZ2_3Yv8S*CJlG5Re4Z_jv-0yFuzH>z?K?=R6j zpJiOc&)PhO`&-A32G;1G2zKfbT=o{or7`TI=)=VMEq7-FYkoX}ew!#?#h*)KJ4CU6 z5aq`&VniVrZ$F{hfi+v}ft+f>+n=`1XKnaD z`WQoAq)LloHsZVuh{65t52qqpCC=jj!QW^raQ+5_VEyjQC@R6XoUd^mpt zT>cg&7EYJO`5WN!wwoK^e&Peh3qTI!aVty0+41=AH{kNOr_y~iF`T~vYslZEzX#I@ z{s#0Qe=B%aLwkesH(&z!o9>DSG=jeYCgg8Fg)(Ube*;|pcBigiG=Wk#P@-}C+a5}-;Kq%DLG%B23 zf%7CF*OuLKoH^Aj@4!4VFPB?!9Zrd^5#!1F` z8yMZXmCNJMNBDjj@Q-2q4JG&+$cOwbG}ewY{|P%k02|2PSn&M7kMlQBjPp0n7|!2- z2jp*d{*EZY-#{zmZ<>&gIN|&aEW-I4o8WJtAM!W4@^X~mZ(w|4fZCdwNGJFk2!;I3 zywnk?!}%LvK>oHJ@)3f+0WN>L^GXnG#`zlnkCXMK;Q8SSzCQsYkiR7!0AL2^Z{Q~6 zZwm1I5Qpziz$VDwR?FK1g1>=9exfCdVa|Gjzkz9EjK2YbzX2|Pi;IY-5&R8s`P;2! zZ)gO6109gReew#Yo8bHntbqKD{x6)Zhx0e^8uB*fzHqh~&fCBZ$m0gA!|93mei#%% z{)W8#!b%|gB?R)f+qogEvp9bP`yqe(AS1ve_!}64{B5LCfSQKycYze-Z$==KM({T< z4*8qo@fsSz-+(^kZ_6k>%v_wm0UgNSY_+?o?{WSH^W7j|)G?f0g!4Dx5BZxpC!Ah` z^EXfkdE4Jl;p~2#w*djj96gixxcS~%ip$Fx6&Tr{0%ffdp%8$rxE-O_(T4- z8}5Gz{swbzVEhf#X5jwSuYvJ5WE9{3f&-Ah(X^<*oOnM^EcoD`CIYo<;YkwwjTnwA%DA*oyaEm8{qpIOQ*6NQE{BV zftQxy)US~5a&Z0zY#@IVYZc@K(ig{H@vwa29a>20q_^Ss?=V zzXX2+T>fUOWY00i`5Oo|a;WsZcY{svHn0=&xJ6m9bb`l$Xvp8}Z!Jd%{sv4Se+ywc zp#*;eKXCqr68sHt`CGISnbU{!H?RTcZz#dv;IqmnkhKiJd5`lq(1-Ikl;Cf`2lBTV zEqe|J=Wn32T(kVSCmSXB8`!j6y}U8pg+uT+5G1vn$~;npisSqZ^y2)D(}(jnpo#N0 zl;Ce*2jp*0y7f7)asCGEAb+#;--ZU^{0-DY{?@!@68(YmH}Dwpw-J>)Y=XZ5eaPQl z7Koz+e*^y}N2q;kBj~|6e*+sKe>+y`fDrr*v_bynKVyav{0$s{{B5tFAn3>W8wkSr z8`6&RH?R!yw<%cw_T&5ws6qZ#l2eS_#Q7VT!TB2?_#1EMBw}l5c~}x z_#5Ezw$SHAtZO)L16*Dd+)%_?hx0hVV|M(jqc-(*d4S2!x`BQj)CiokugXi-df+B2!zX2|P`+Hn~N$@u? z2l*R^{eVUAH*gm6w?ZiaY6Y=g6~puSr-&LB!QTLvzpX^Run7JJzC!*M@VJXf@Has4 zxBqw>@Pg;_RLBpu6Tj~SZ~KqG0WOa_3VA~Zem)0W{>Fy9jo@#9%imfdk0baSX3u9Y zidg12f5Yqz`5P+(=Wk#)3~aR|ZV!0h%9T>b_OasCGOKz?Km&-Vm> z12&Mq{f76i2>u3oasCDf{szV%f2+FbfF$DQd(aH|(bWI=5fFy_%@dyQo$&KIcmnyG zIXvGJ{0(sV+u_FhEP}rQE`PIyypG^+pce8r8+e{4cpI37JWdgwpH*;v0L&nNTMEzj z3}Subh5U#Yp6?0%29%N-E0q3s{|Xr6{EhPnKi>l7H>Fx*a6dutH(-;{&*g8N12{hd z(Tmn_c^ik|ZNT#;|JD-7n_%8Y?Dr!V=Wi&%-@rbczj5+#J^&IRe?w>D(FB~ofdHJp zaR~kf%prgKV`POA{0%(B`P+Z|64XOJkPXk%QTTZu_(1;l^UG5j!QTLvzkR%sNF(?g z;PSU$ir#dBzrj3E8<9RZANvS?f{0-DWp0sczo&^Cam$!kJkT)&sYh_V!{swp< zZ;SgMZ^PufFg|>6{st-`Z@cwB{)Wl-{>R_ICK%tMkgq%8d<i1Rnl1^HW`iU5`1Z$J>n_v!E&mce!W_jeWKZ#Q83u0;E1 zAb(?+gwPyu{sy?bt>S;Y4U`QfRL^ zXs>HHe*oJ->r+-Tex3(sVSM>rOJt4U{0$hx_&TWU z&3-`CPlx&@LVNxo^zBc2z*_pt3?+CR(CT2)v{`ZJU!1>zW01e;!u2VH(BI?y1D3$c zVwB)--~i6wI5vd-zi|G>cEb4@`0HIoQ-S>xybWYQ{uT-OJi+5YALMUeq5NNYG0xi% zg0}&ni19c?3g;UjcJs&bd0PY__#3E#{7qx83zALfpN;c3gy3&L$zi@y;8Y|+@He0Y z`P+=u5#$}tSHLdF-}IFySGvsd3;A0gYl=?rH_(IgH-zACz_dDB z&nzMuC3qVMg*;Bt89^0s{scDS{0$}e8~6+PoA=X5l;CgREY9E91b+i2IDbP4{syi> z{`NHNFsh65H_#3Fn>(~G!QX%eqpTE z{syG`_Ex&X`6l=qc!Tpdgy3(00r^|HzcNDbH^6}WE$n0@Lhv`>E`;$ngrD%wlBxIQ zOgjW2_!~F{`CDcC6=Vs{-@r%6-@;8@keh_RP9;n;b*iT51b+jekiP|{Eky|a209-8 zplZVTAb2RShy0C3)nyX=4Y)x5_O0v^o8WK2NbwMB(m)s`_#2Q@lVaY7{;(Y9Z@>@d zZz#dvfVxDf{=SFBD8b)gE{3+s8{vykg1><;kiSu-@1tore*?QAe=|wrLkRu`LUI0v zOyT?uyn_5qzOxt^#Q7Vz0QpMJMI<8r>%gFH1g%88* z_mA_B_^i{e)Z;kkm!!V!x%4W(GAFnErO)RZ);AVkU$J%{Q8NKbLAb3lk^LFr6q?%#0ranFP9;>OT%C6O`KbcJJpqG?}lZl=AI&)n6d zp7y4_TjWGFB4xBlxfVkF9=;CF#}$oyYYn`&`^qf2rfM2SpYLUVtv`iX`N4TbT(ozN-RBk>#hk2WeUvL zW>s2mYQM&iyVq2to?V(hZadVJX8wv|Xf*2P9A;u9{n@hTvQhW)*yI@bqqKoNRzOlx zeX$XVBz8Ez&uyuMX%R_CCyGpxEF0|kQPoZ&Ek2!pVOk|O#mjl6h|)cqtNpa}3`%RD zvlnNto~(nbzEgp>Po9LX+0EpL+|aFOTU3vBw%a7{8q{yTU-8&7%5SUKWrliGu%E3? zRA0eaQmd-bi|(Fl$vr)f#rrh#=CZMSKMImsdY`P{a_((M%fcj=E;MF}Vm zmag_$JCQWtLOs*k+tEXfKavp@Vw}VDlOxNHGR-2F-53kA`MWKI*|Y4C$E!Z)GV2M~ z%xhb8&iY=63aj^gs(JiN&qeYt{Z*G^ipkZb?z3(#1B}_Z_oUA{K?}YLIwozAXR_~F zo?<@NVA$`~pBbz{EY?WVdxAcQJL(b`FpG16_lH`cO_p3@Zc_0vN1r=YQ+!F^_d zWBlmvuPuvXsHD%dWg|~lxm4B2c581jmANb^o4l4n(IU0k)Lt{{Hy0V+QtG0yMa;7MI`@6%<7u8h@irnNTa1;QjM_94D`XsZzkjquC+Bpns;D?cj;c#C zAQ=qbGB+YQ8L2DXEBx_>EN&c@y7KKqv%Sj$Nn^@9?}1+|>Pf+uiEG?07#0iI+EAe)Z(oBEeqrrz7^; z9_2cQGZ@yp8}w3FFQr6US>)CFu=UY)ZK*f&*Mk|(J~?mO+RuGDl7B*aJt6B5ws`~x8`LrUq=&SRNJ&jE%o_(yEd>Ee-aS5Szo~Brl8pzP)5H7j*Ul-f4%aB+ zuW>G_2pBV~71sG}yznPOQd;_Hj#@f^~>_9%_mYm z&D10=CcTb%qdP)&0b1Uc(Wkm>_e_81{8Y==*)CN&###7Cb1R#EHK*e?na9U?SI}bK zwa2Z}?a7gh>$L(QGogI@Z(FQtTtPY)_qDaP4}RZluc(=PT%5MB*84}9D?2}&4=^Y! z%*olHm7S$G}#!i^p4=sb-f$a-Ut@^C`Z$GJY}7R7##*ObpiKJ2@A zEX$-ni!5&{sM>g9UpF~~@8JeH-mnLUo*&KMY^onLdE^<}UOLllmju6ct+(Vkr8-lU zfzLuoDQ#Q*audjED^fgb9_CusI;KC5pUpbU;EU~%WmWQ>JEid|k`ZYXCdV7eIOQ8S zFj_Hk&dK=lX@ljI`!xT$s036pY(3Y#NL8R_z}7>}lQe zcnxX2;2Pd~yZR1KBQt|#0*1=LhJ}DvCOCY}3aJoY1G(G>E2~V~ukxKDdymuv0HGZ# zgZD=%jRl_eJ1<|cI@P zag-i%swgb<*jA%yI%>AuL`dKTnIzvfFfly*ug5*WW4{0P<2g2GeCa}iTF~d}+s5av z+bp|rQ7A;+AZ?GMQG==L5s!7HscprkU5mmKwwa`@@fc??3`insZ*_(F#73?k=<bkPDGls!1=_n`{h zH@`J9isO$d-kUWcDZP`wh-{>@^sQ%E6zThig0quVV>1tvT4_~}j;fZdEINs7l6fsV zNw>Rb&3I@LD|6ZC=gZ6`MGQtEV~*eMRN%oKa@!u2*ac|H$^9DmL*d`_jzjG| zSDx*q94P7VjL&K~Dnk1FYL|p^f#@QV+_pOH(QwD*&hl<+JO#DN80yD9+iW=2U)mM= z!!s= zI?8ypn>!ygm0M=e1*)n#3Z)z!BJ-DbKANWq?IkIYnd zZPF@|Fi{yVeE(;$#)*~h&-#SeosKvEba5yo7a7`e|3|lWq;B%GZF^gjWXQ~k78O|o zm6Eev_qH^ppk0VxSX~P}-dOa&Tb}`n!?nFNHcJeg9OcDh$v%_xhiTcr{}mhQIwc-7 z2ul^bkt(d28J}zU_*rqA)3uchlQ*SNqYk@5%&fzCBGXfM`5N<6D6s}!7LGR(P4%7} zTDr`lM8Bma;E++$kDghP;SX&iBENt2=q!wL{ypwt2IU=nG?DOCe2JWFL5oh~j;@JD z7fI6oq$|(5Kcq!<`IPNS>-Jxxbnb+rbMo%Pn-U@-B1G1K?sRvVFY{gQr&TOQhWq=M zx^t4xEzB-_8jIdy^ZChgGC+{|@t{$q`krfd(ozl&+ExB7obR}_uKfLPhl;M@nSvt) zmc7-zIWD_ZzNOE;%GKPHl)2f{A-{xw;_@?E)N)@hgUeM8yZ2gmuQH;xhm{M)I~4G* zekLngQ&Z`Dpx8mC{Bp8R#f@=Yx7lveQv)H2vFW*jfxAmzYF!jK9vn+*T3NSbf3S>g zv)E03CnvH9-(Q>DNcoo)XF9t#o7~x+E*n>S2W`@%ygsy|_fBIwpWNODiv`Joi#Gnhl62&5TJo4}%UveAS6$3=i}2~NY96xBGm#I=LwMG_;N|DH%;V#6x*1oI z>yj0wyy9x`^1P*YotDYjwNq9v?%q$9T27KQl2MJ}S2+}V>hZgc0xKuOE6T;xo!V@q zlpRf6N%^{D60c}XxK>Q4z9^rBQ=6*fo0IcOPi9U~H$)nQ@ugU-loOP>;ZgF?RW)8TL{IK~$_6by^0^#^{cAqgm49pw zoB!7O{q~Uv!@bw?kIN_3-}ZD3b}grpczDP+cea_E=z2PRag-!Un!MV#Z>+oWE06Tb zkepoyZlx%?TIi6y7@p~i_j|j|UfC#At8Pkl(c<@bIq5E?@ykup$XvH1YO~?Lju+$Nqtw5XS!e)VE3tqxQ4zTeJ5a8uFIm zF=%YBIn;Q_tMhKB;-FtQdttPX=`MNgLpR%7cevwohvMD3vu-<%r!?L>d+~05C2vcn zm)xY%b)DxR6X9q>$pbN$ZT-;{2zWmqm z>&Nw=zo5<0RJEs-{b|a6e&ey#**Rxt$Z7}kdm{uJo2TF9SMFagv#9-EeZ6tlh(J}8 zYv-T%-{pE=yG>qtugR)V?JD3uyon*fL-{zFbBJ}xf6s@3sh_$Z+M^e`IVjcszHZ{o zIs3VP>mL0&^C;PH{e<9tUMacmoAPC=N$YFYyKPFOw!6G37;8HwEg*lqAy+HA&g9bb zsh3%?4;+hRjiz*a`+4Qo3wNFK56=lQl)JY}l1D&@?7D(-HjUz`bK`<=3q2s@2R9aLp#yOsw%u`8R;XGf$RTrjKTx`$MOUG{|LJMGb(OTo$+Y-?tJdki|e*h z)2qZ+u9vGR*}G8vX)2?!SSwG*uHkz33;4g2qyav$?16=8`-P=u!ZHCrmUX3H-25K(&wu*zB6>Mca3$7qI%lv&^?i|UuHjyl*=qbZ&CzEq~E@)v~IGp zHY|Lr9SvLg6aO<<*c=J00)in^xu7Nhu24k_F43YtF-CEz# zI^Q%Sv02`dXsNwZMs46%A$?uxAY;{*l0W*<7dHt6KNja>c*q6%Fc=Iusk$9+Q&WX! zT&C1ttBFjSZg5lVS1|sgb%^I@^4(1n9{;Kn1M8Y6ns*`zV-+HoSrgj5L)YqiEJ|`+ z^Rp^jR?NKn68KBp$~|aa$D=~Yes+D&q2}c^i$i`spA8&UrrjEQaf=_NhnMh?f%Sv^nJY*PlfCw{g7$AU=f4Ea zmNk}Zy1^JEBxC)dA}e!-uQ6hf~EL&m9NaSsp}?te{1BRYk1Qs=PP<$hsv94wf~;I#J;tFlJCS{eqq%k zL7|XZ_I;$&Q2QYnmG4Ej6~J+6N|kVo`-{g`F|wjMb-j5f>tzFbl?2tUKP!KKzEMFe zz})`J_MV!kQv(X0|Ejp&KY8ZJ@K}a!;P~~Ti0FdU?#8j6vbX*=#ojKNBnl(u)H;rl z(KV5`myE(l{1k@gU&j`W2x+_B?-Q!V$D1!+SDB^>8dxmaubA)pD9csC?)0KN28=?z zmJmjrskvq038YO5a`pMOpH?c49%O-D-$<6JsX|x^4X*x)zx>mWq;#qv=5N0zlyInu-&9!*UK=dZzL}!!B@>XZ)R+kxSaihPi=CiE$dHZK%mXV zr}p*Px0Ki23rhcb>an|`e*R8N?)Irnl zUhq6x;AE9}xihvQZ-e;c_Unl;>(qq!`Mz8!?7UU#cd^)BbA^?m`eeBQc@;-f%i?-( zz=bB>iOv7+8(>zW~n4E^#m7>r5;L~ouBRA zG_Go7u#?|;4N3Y&$gE|%+k|Sq$D+)>TY02?d?6Wzt0ol&zPeh~M;P>uY1kL)(HEgS z@j(|o9bHqVq%}{G)rWnW{v9U$03Q29)r=)S3A^7P6UlO6Sb2z{etY@x4n|F% z%K4~l-G96?<@VER!9P`a--KT=oYoO0P7hl`Ry!NBO;`h|w>2?LDmIy-<_*IMDVJBg6J@ zeZ*Y7F(q~CPjW`y)W0rpdN@`tc=qtCnBa zf_^PY6St}uq^yCyxR)HamUL?Njhe{o4{jBjR-GT5W78_L_UzI<+RY>SV}-TrQPnP& z;L?#DVVlp%@lIU*QS-Q4Iqzroz61*+NE<${ksm6<4${`Faq zSm~cpZNsqQp0rWDn6;$*FvI;Kp>T_#v@=OaE2={p-m!a_T~{ zyYtJtDB?H6V*Jj|tXJG`aoji0piRBy%7EY0t%aG#<6j*7W+&!!KFy>q%-Oqp&0Z07 zKT|en^QX7t4UfL;ak1}v@>L@*^Es@kcS$i)R@XV2!Mt(sWM-3hl*)aRPYgbpr|;bY z0-tYF_ABd2p$ueJ>rZF|yBssjYhO|=+ECqgXwdc8zjpiib?BeoUf;l3-@w18qoo0D zHY#X7>cHviDU~PQ=XaGhRJ7X+dj26Ry3J%Bw#Zvql{QiK^Da4xL@E+BNJ{RM*CP#9 zIPi;CKO140#4VmoVM{yJp=Kh}tB=u1*aJ-Ay%va($>myg%bz;$BsQMP=Y%83_eqZ#_qMoo;Ptw?*w7rBREOyt(dP~itH5Wu>#3tvQQUnCl&k1h2 z+2JCXw@m(kp&Wnkh_mKKW8*#DpSCv&F&L7w8?Q`yB{v%IuPW=v&gu}8xF$q$6Ob_C z4VG}AlpLZse~ucu(=+L)(d{m9PbMKt#oO&ef*K{CDSpstV(#y)_HNe;QNeNMt9KfU zicvH?)SmB}sE`>&>+_^TNXrvahk0yvF&GuQ&fau57Hm|ONV7PyWie0jayiEYSBw10 zyXx6#2i;zpW$8QrDL6gQ@X^0-Ufu236B?E3;1#?Eoue)pbCYNYQ%BoBD)a0gC&hF3(846@FBaVfoh9ooj>e5$~5B#&gcxK;U zx}m7XCEYJu_Kn-@|LXFhzw-XN3sMiBXHuuqLN4hCXD^xEaAxHyOTP4vf@m~K7p}4s zuvt%zR4(8xOZ42fO-_#W(<6O+#p9%FQ3FB}ml752gu{RNnaLGgdfjr9Ke33nGbzc- zGkf{G%H#R!u{GZ=RyR&v`1k(nQ`^~%+sOacYw6k5DSZl=GXBd49ntROI=1wrk7x3@ z@vEQ0Z42n1t?6$LsPX(|Frq(A_Z<;IgMT$t%%=Xx+&3V{(Vok=5;U}Kj$_&xegxi< zo6?zo^=al-P_*8Y{#D~zcH3`L>r9YQB{dKf-sKoOtuL=euhO z<7Zmxj?Uqi+G!$}+q~JSS&C{_g0(&e2XYI>ZKIdn5dGEL(K?eV(iM7zAtT1m`qi<@ z%uG5x4MA)s3jbE*T1FR|pZ{ojwrgN(ORZV+OzCZ(wX&^+Nr%FMS%x{!pg-J8sh%IT z5DYGDDB3nqXh0JEc~n?NTX1>I9o}WIeMf_~2hVFwj#GtJYseOpE5>BchiLcnuQ9)R z`1sYj!+fy^mq_e!*_G0Lw&}=ozAC+gZ!}LCyehJM*dec&n6{(G@K)uCy?o|6_i|@1 z>L?EQcDywVdR=xsVx^N-vrrZiq2$Q_!f5nC*d`@~MfJ$rI~&5zHd=Ta4U<>IbgQV> z)!wOG`u0%*L#T=;>|pSsdnE7W;xC_#KDANRB+0*H>h4$?+*W1rR^R|h{*d4`4@{+d6_q>IqA@(A*u=QxnBdseGV(bWx12V*YIq>g=$mzuoLo_{ zDRbWoaYw~q2J)oR%E)j_^kv(@r?#qj?d|t&uShDi(GEBgK2qI!Ip!*r+(On)R25d# z`{b4yuebi7*INU*s|9DnjH=o3;Rm*VP@L>Z-D>6Vz{CJ~)Y;>eGrr$B5#Dmp-;z%@ zWgbX5ZnOJIxAs`T&ymNhU+c58v%S+=!au+Ip{}sHlq;)i?98;pa1@7#}T>tU+bo?CZ@c-*Hm&D z3A~_rwsY=_$NRFq#wMze+%L=f`m*VlO;VH$V^NO=uUa3E#AixW`>$%RU)$^b==;)` z?x0($cn-{;4ElHd(@e>y?nkrTMy^2<_S1U?COpbgbLFBeGTTm6*OB6UhZgJc4ySU) zMSN}+lnvJVj;3W~NcOO)=^2}5+n=5k@t!1oON`1(&|BqCp<7M;+&lH>YRkpLZzIY* z=v9xEqQ#!{7aW$HgOQe5OxwzM{hdkiDe$gKJQy^!xT!unS>W%*wuSnoB>y!UB-S7D zfd>}1brqP`cx;`u>mulFrq8+>FSj<<_BjR!T+pJbMNVC=|1r@s($E+6;P**(-Gzkh z6}#7FXRlrzxY{Xt@bYHSkl;ckz>wsn=*KOp@wk!!dA3;}m|EQ%}PUHHq$Wp$CFHG%xj&>#7z2==> z?{#5p)ND2_vMX!b^x&t_)4s)dx`|FJ$srB{DNIGxnt=4Be9anP9?7q+aQtEurNATd zWuUiklTDV(&T6%{KJ-^dkLZZ3>!G6T{3M&zTTjB{vyv8Mb6ENAE-**j{_*UP=f1i+8)h@fvbfl6<7ddNCXo-AN2!`HN(Any z&*mlb`kr()i!^$a;E}}MDp#i>Cu-O};F*xdkO?Nyni!0OUcN%-eZ3Wogie`#X zwd)!kNH>~T@?=cENT4V0mb$N&*0bT7hNj4hu~m*dg^$Y?m&wShDFlbgRZ&`b4mvp; zR-LJTOCpCpNpE5PID3;bSAA1wtVb@aAy}{Z#4z*u_5qidM|GN0Go~YFIWr>YuW{fv zbYv{;BXe@P%e`Cg(o;LBb-qUjPkemT;>+A5lb-PyOiqa8)OSG>{^&Jf%$&$ry^ikB zl8R^n7aT~vuaCb!J#UlMV=GbEk(=e-%{;lRvA{EUavdV+)92c1GHRAVbJGOK;XIdA zF|z6Q?=#Pih>YF_dIyu4Cl)66eKSUXxAQqgotpVdyAgLpuAxHVp7WFao0^>}tffiJQ8urEDgo<#}w}nNn%C=c5Iu$KvyZ%Oh3K;x0F;^2} z6t*{VF~1~P^UbLpv$aRc*Q$Iqk|0}b+7%~#WmoM>ZJupEnCcr>n#NTelGXGsBpJm> znpNKz4l!Uj@CesiOLf=uNKQ~3KMwtllFQ1Ae_}Q8^=OOArGT2zm*4u3xyFpV(3;Ne zW1T%$^AxRGq9-gWj&`aG4^MwDPiPPKi1hka@p61f#6Q`4O8di~yYG|27=^~WFC~yN zczsw2t7p5#>86j@U$l85h-PeHHH{A?HtH{1cVl5PL(8or$KGFr{ARB6Hn=$U?PKWJ zqV++sk0g@19*zqe{|gv&HTctL@owYIqiW++l`6M^A#dBVeOJUPDoF;X+0uuVe-sPSFF!EI$Gh} z+Ea$#R@{gd@!sl`KJcdhMr?{(wdRhg>FHM`MnC%|*XbJ^I1%fTWS%y2H*7WUXsf@`HC1?+#+I1SPc|D$ z+%z48mJ+L+Th(n*Ty#g7OVO!TXxq_&-J;AnFcMd@8rncJOv6!s;8vhthL%7Az}0eD z&2lNin1wVlm^J|6KtegFLgdR(Zc!Jf3Lq#&3%LhNseW;zI&$VP6{3CeMhFQY2wyNO zL_Qf%MAIaY*1Zalg;h0m2QxPSFv=L_j7&sMHaIN^yjCD$cLNHB1^A>jr5tFEXn_f$ zT0zNyjtC5tGLA}yLC6@I8UghYJOd042`vj#yKn%Thc_SGpNntSkA(%y+kUBaq@b`O z#E2L{QyBrBgc!&vJe&Zk**#KXa%6)Fz2XCa9ksw;y*&Uv5a#EHVf0T99F zKt|W8O>HR!AxybpAw&xZ8|Jx4+n{h`p%#e7A`V_l%|vD@n24|N2$y+K0R$ujLMij? zI(A*pjPq=gG36YsAtH0@xopR^Fcs5AlBbfIZd$L8Zr`5DeDD5)-DWpWwa&Z4Ws6zZ znxo@v0cRgPRMUByQ`3~m)@SD)e(ToZ!9iz;Cue7?gO!<<5=3!u>!@mJA?*uW#&NUC z$E(BR^`nQA>4Uc(AmicD>YZW?0t|L*U9>(M)ZQr`XTahf6J?Pk|3mY5d+_7DI5|3N_0 zH07LvMdxyG(9L71S`Q9yZ-+IRc8jB7njbxW^rJuaQ|t4S`=5LJ?EUu-@7_XS0s^q} zv-R>|F&C?PzB)W?7K!7XZf)ncX69_wD#qdbMy7p5kjmMT0g zG=I_jT$S_#xW3Sbn1~2iBqfoA;_NQWM3)&z&s{-(L5U+obRwS)x&3jd|BoF2_#`oa zwk^|i6$3y-AUuEa?!m45BF%F#fDg@z#%a52my7Ej4#bO9OY!}I1;3}+4dKqIF)b1C zdQ#J1oiq1) z)f^x&s9J7?J;w3;5B})AKdAFB{QOT>^LeT%cd5<8`AO5YBniS0ND>1u0!8fEfAR=& zjerWlgd&ZD5mQ_Q2ErqV7>Tr$-FDqA7C;n$QA;=@?k{mcA`D`PP*qnoQvyJsaF040 zGq?}C9px-U$jFG{1|kN5jBW;o=78X}6mU;XP5_9!T&;jps2OMwSDkgYWl11Jh5(_a z27xTyqP3!B+|^pa?dafOtk@qM=G?l^?l6zTG!N3Y0=^jra5>1?3lMQFg^)1N@go1a z)?#J|w&<4=fLcWWBt`_kDAVSBl?0lHI}*7&5fflT>=0J!o}#M7$7x4QEeaFGz9kF* zdSIZW

3yC-HPVi81?n2{yI+%W*Q>$7&TI#_i;7y)hy#3Ik$u;&ghv@)!7Nlo5| ze%uQa1>#(*5Nj!bA^9@s;}MVQg@5BO{p|ns>%aGNZxhsc+79z>oym7+ zkeO6%9M;?QE~lpGY+nE54>q6s!k0Rc!{!aEe%PmJ3IQuq!LV<ZYV&SOO_S?9?$&yCw%%@s<#N&V?Sp&wPESvN>ucZmyT9@6 z&mT2k{jo3q=$9X~O)r_pVW{(zyLKA3)3B{&Tr7?xr`&b~Obp%P$jqm4sODf^hmnNJ zxGiEJPh>XN6l)A&dmRf7EeQz?C2rs({TZ`gCV$)cO z*JmgF^5F3H-C@{;S!x+8g*N-0RthwvM2mn2Rwj+>_G zYAsD_QzupwspCv~&i%552nFu?JeDF^$~2TIntoqPMqy@UI$5s+(zj2_PyEy24)m#AfiKo&5kjFj6RB1$QYXj)3C2ow}`-l~?i@7+x6Oq>z1 z?fPp-^0FJkbFmLZ02p^$`bh2@QETNrvii=dAg*d2!M;0Zl zPfv2&+;q75UOQqR-8S=PNnSVF)%J^Nn!igG0N2w0n>{ZSt~w8Y@vr{P-}s+?N%9g| zK6baReSP-kMB4QAcfR%IFMjdp_|^ySJ?xt{2&4LLw@EqQIzA#yIVaN+>Z&D4Z&<+* z16U}xO<)M6um9m6j0J{LGDyx%bp>}xjR?)d@DIQCn?L%MKRZW=d(N4lw@nqH+_trp z)Gbn)++uZfxZCXdrW@9p8!GPNFqOG!8v;RcE2J|XX-(7@A^ zj68t%KrYZK002dp&sr^IN<`}J1dRnra`OOCU;(cXu9`BLgCv-ZBtR%QC?W{ZQkx?z z*y@%5+`Vga#F7)J77Xl{2fN+QUF%#1!j-!s5CfaMarf3{oY&ipASQ;haXx5+QpT_V z@<8BFkCtdMmqbAv7K(TXxYjBj%GeOMi{2yX=wLcI?{2>#!o#>mqD*jj`~EoYY8l6A z&TThN>qJz8$fJOhxkDrocQ-^W-ZY(q3mG_tAQ6C&7bxgi1xN!~H~`(UIY>y&3ETrj$o6#);H5$q8i~cNB18ZoFo*(V!AUg$2tY(E4BRx> zTwBDxUnZb!oz%QkYoHzHDUd?7ZTqS07~1uEy;vR06|rk|{P^e?g!Zj> zCAUJf+wG7r;clWi0JAb)^-^xx~W$klRxwMA6j<) z@ZtHv@$zW-0JIz~4?fsED#MTumZ_6>zV!hKJpAC%TMzF4|LncVuPs@6-S>5S?}#|f z?O&T&S(TYpMY2?^5=F|C+{hLn1D*)5Inp0sO+EAf;IStL1P^S(fb5BE1BMM7_P~ZE z6M{%l6j^OnlbNr*_ucL^5wZ8zcyL};Wfe)0lt@7^bjBC=UYv;7vG@Ac`mOzLvlv#j z)p^#wuPGA|mok)u=Dge75SFehl;k_#`PPRYe&zb|Rqlre@4kC~f1SAOce}>PA(cP_ zxV?V8>=wWHwQv0RM<2cW^oy@AUkzQ~+9biB+{|`g(n|%w?hTEd2l&HXk^vWoq+sxdbEwYC%5kPtGr%zkGRn zd-L$Yg$LZ|R7XWNA*yZOPPZR@^zAQw@SzBINSm8YzvygiXBTHVcW@dZW<@8 zt<}sWFj|eSPYzg8`s9;muKL0IA6{QyN$Hnex83jCG(|+@P}9(Z-4PI@Io{vi?{P~x zSNCx{aYnL;j?uk4Uev3*-S)n8OVEa#B5b`n)z;>D&N-J->QqUHz^e!V2|?pb(4^1z zuQv~$oWFT}d2s(SQv``fN-1|eEmn);Q>09+JdMlMYG}4KWH2*>fWzeSpsG^J#4#!* zXrFm#{+a0AKU3-d?Ev7X@$)~A8GzXzoBxitMh6L;;OBVPUCTlddk zcRz)if6gBsf8hW6JbC4_AIF~y(Z3yDxg#PYzBLFV1|oBMdwmH#w2py<9rHo>U?%2d z9;$l`;)KZP9@FlAv0N^X79M78W*Gp%&4M|na`^Lv2W`+1QKxy_Z&FIB^byc%6&3;~ zVj_lc#HiCA2_?|cOYaUi-=G+(AJoMD3!j~T8RjV4tTq+ z@6CLkXGtjnTdTqhKnGWHxLRuyz;eiJ_4Tu7=TDws0DwgxqHx9mQLQm{^!VNT>(>xY zM91e3+=GM}JP=FYhkKh~p7k>_M}i1*hj{|Ps_L#?=>f1LaY*iJT2+;Z0y8)sPU(k- zVjg!SOe93+X5;o=Bm;P0U^HzF!QWQXs+PV-B3BjSFf$BhYPIIFn0H$eMkEMr^B6(7 z>vQQ3)a=88P`&E34+kz8kxRc&_bC9u>$sKDmAnuUW@+<`L;*k?4iZxZ0)Yejg-$LW z?C!3|{n!--CQeBLQsMi3&4>(QDT6f#bQEPNF&fj@{{myCDI{(lA@cUo-$_HWU5Nw1b-O%H# z1|h+-y8}p)2)CxW6Lk%gu)5#1R4z(lB$?-t5mVn)Gm%QFHg8`2_+C6naOhXo^!4kP zB*-MYalgH_Wxv*WzuS)^QCEuE#KHR*Z!e#@M=oi<-M)Nv_4>t&e#nG!wCr2N^XIo` zs{sI9$J?9nd*8cSEC#I&NxH6c019sVF=v^^DQ77uSF->7fBa5i{K|W)FF)zO^o95D z@At!cu~>^~VBqTL3=!vf)H+9m=s^-Y3X5cE2)dCURt&Vd}jP7;Z0)j)7QmRI{vEa??7gCCp zVn~VT_VVTZo7>Z;Un)Z;LJbq-2zOIQwAK#LMMUsgm+RvQ!<2;3o0)335;3M6V1a~g z&007dzN@lW*)-t+FlEk3+yh;qH4zDvB#c2wG%VP2CL)VK!U#O*O{{9BIVA@YVM(kW zsp~c@2Ms^$U}BC#^avmr(Eum{h<*-8K|~;j&_x{3K2w1}1?BBpUZSo#)gQN&MYUF9l$^EOGnsZ+{Q}@-IIv5>1;MxhoU5@VTjE@hQ5# zT;IMtS`5++Z|)M%t}mL7 z`+1urb4t@R&hvD*9Gs-qaT>RYaB8jO(x!1^m&9p(e4^&AEr?P|O%(_|9EgZSYdxH1 zr5n1Ey)}zH3>};Um$)E;h@vsOMz=%NPvOdd# z?mXKV1ndL$L-z4qsMK(tzOAHA#;sk z7@9U_MNGiKZYUYRT@Ruy0|pp0ts;VegUEKAfq(>~0T6%z3t~VxIC?<=^l)1a%L=#) z#d*#pZJ7JAFpQhsT_^dd@2|JpE+qg5jfKd~G>HgAl+?8_fzaB#OHwtMWf-P$#&9xA zl7cy=(O1hl?X%ld_l!vrbLMtGXQZv$0wEDKhlON_Y7hlv4rPU^I;1j=_kqlu0uxb) z&}LtkeK7^o5HUa}qO7ih>W&CisY6g^bY}n#QlC*W5|Ey_4mHV`Hb5(G1Y zNW#QA-|<`^1Vrv?5t76K z)B@cZkr9K#!3h9>93T`3K+Q=Yt5k6|3iBFa;p_~k0nl+VtBEDxV9-Pq2DO9JD40l{ zk<0-Z)xl;1G9prS79qq{ctvJ%GN_0Kumso!CJ|L2atBQ!Ad-M)eS0)|v%5#ht6T`9 z0f3~8A$jrU_O9!O2w1O=+dM;#R&mjFJ8gxex-XW?&2}RqL}IE=P*o*mVgZD^s~4rq zQu?Zz7mL<3=fle2AwVJIK_$&KhOSgoR)6;k?|=I7kFM`;81eXcInU!PyLaAwubE$5 zoV|KBMYH3RlcQn1+mFXbOEq1sj>dT(Q>cys%M_UqOD}gfS5KdO;d|fv!o0Q=SI^3}_}>raj@YMr|E^7isF(9X`ztJyFtSF05Xloj&^Er@!{iZ?y1v z+I_x$gn)C`|F3`NKdbZnb6~@#Pu{(J^=Y>{4n%h?%i+GZ*xwF|<2vsH+U?!_7v4R4 ze*Jn_9uvv(bhW?RC+V)7@R43yk%Z|*JXfXk|F=vUwW==Z+-;V*sn+uwTUi(hm- zSY~5tN*J?ZCUFR#+v6|3vl}Qq0x!>L2hr`kN zlSf05Qrb9HvuWIwoJ+q5pw0EGKKp>75dYL4jecER!1DnkkbvwApp9(oG_qGSf72oH>dSv7YZqPQk= zXXe^wghSg9A&G&Jqa;zaFi(l+{RC(L%!2c@Y0U$i5#7<K%@Xf3R6|BGa!Hn5s(N4hO4_H;$n3)P5YdOKqP?uemC#7{c4#~pK|YJ zNMvTK)hg3FS1+HZKH4;nyB#66HXffpl3W0oLe(^te01>;0RWjI06;|MI&Zg|QgX?i z8;D@2fd~+|24c8F&Wwm|1c;1i=0Lr&Jr-?@Z5tG2dSu7%Qp=8Pgoi`C|CEC*?l zND>E;ySn-D>U7pd2^P}N>K3-h9hjwD=GG3Cyg3O3pvO2j78o~k&N(Hta8(_5o79zP zmAD79{Zvm*m#x}7O*)T}7SSS!Fp5(!7n&8B87b75n95M+J(wL<&(v|N>Xb>aOP+JqEE|+UM`A5I|$@4q^wQuHs_4S^w>-(EG*D0mF5&|x|v^+a``RSFA z14>vmn|qeYLqz_<`{%#;+do2@*O^Z*PF}pc|LO-%zVp#@1pl>Pc)V5rt>69emp^>m zcm3Vnq;T`{)jbh?;~VcUyMoA5o5tNNiB`*DuG=E~AN=}z5tT^{1dtX-Lzd*`(j^LT z_s^0w63{^11Nm(SsxwK19ma>&8UP_1BWP`oBqEa1p>+$~(UFrJ_HE|KDOs%|2_&Og z(?%rB5FXkZAOfR@hW;dQs>vq*M`aO;=r zakn98%#ta4m>?sXx`kRDcfME5X}{f)X?7%;nANX|M{Jmj5_ND>MsAafnM0V1L*AQ*b6 z0!eNAeps4nAUPqt<(C}_6yURPh5&*CFlVAf<^WKNcsPJT5F@%9m=hnW=TJnfHFpPU z=w7E8!p)I`QYwfH5kUa{Svt}I6Cgsga6I%81R=VaRlvmKeisP2^u!6GW#RK-=!M3q zz1}xa4FsF(H13$CTP&B0RRS;oK%Ri_b`X?T%i-144Kbb^E$;5;h&qC zce~aXx6t#m^EPcH$??f~>4;KqHJG8!(@`gPBK=X>@9T1zfb;9St-QP{rSDRH_Uh6B z&resYg*-a#t~cHnxVgIrk1w7r*Xzag?f%0rzaNYNoKye&<*Rp}_U>&#`G?P+KYILd zx$L1%(Wbk*?IzuKi@EFb>FF^Mn&H{m!}0!RNNJoW&{UlktM$uIo)61hXIvbe-Ctip zt6V6htg4~229_*l9%kd+&75SpSYN++le*5veIO7M3Dw;u5Sb)*eOMqvl5F8&EtLg; zXdRKH^gRGgn>$1#;lA%Fbwq^o{^s?IIxCa7TT@TsCHE29W+jShwe;O^v<6Hc|ITlH z_-lVf6`F1m^~kW49^B`uZJy`*JqZ9LW~pi^iMEKq^?GgK%^(ef)-l3!DL`zsfl(@Q ze0F+h69^0ua1TW6O0U)gIRr)3LBPGLVSu?Z$!4?fbILgZa73isO?9uTLoOQbrd=60 zCqz(-Qu?_yP9(W&^Q^AmiUdZ8PVN8&T_cx7z^ygL2;@L#WE2bwqCcqiA^KqoBh3K>O(<&gAVV#m3lEna^T0>EY0vIBQ*pq?+$idaY`5^8`0ANlW zh}uR3@T#0x5yGo@Ii!;S6jMUrpTblb=Q{1Kug)I48w`N~NXyl6SuH($zuPcj?t3-$ z{X{6Y;-ZX*jrR9=fJ&nr6nR zb8R!OmM1X8cK-C@XxRfCb@KGMd{SfI<}mHMF6GP)Pzn+v@b&B0{bH3fN5o=rbbo(~ z=8$CQ@?KjO@$f@|+&oRDnz|fjYC7+>?tby~os>$-c^-FeF^}7n%Fy-baCP_)3{3q4)`B^Ac_d#^k+CB_>=Uw3n%|$%whkU z|MPR-n*YlhTl`C#6(JG*L8$$oQvS#7TvvVf|9fuiA8Y?d0777*?|%BaU#$MdfBJX+ zum9pd5n__`r$T!j%z9kt=;-L`>dlXzy&C!jC(4p(!0k9^k!c?HyWPvn>t%;2B}wJ@ z^tevbTx)<9&ck9+t7gFMX732gFw=p(;$@0u|qOR%dW3! z{otMB*Ux@9zIZk5cIOw5Kx=h7S)Y#kJ+rL349v&?L0W5;qyeo>;HCy$UpQDb5=6KY zBT9&~2IQudl61MbV_*=g8<-MCJb^1vhkV*t7b@(_4$;ikMwlx!_EGF)i9Vez;|~77D02Z=1wUsOJa0OsSt8iZ>?Ld zKN7_hv2#4Me1ci`k^n5uzY^jPqm>B888U<=G6Gz1U=g$e-*iouDP0cJNs40i%BZR)5_B4nm5Fd-77nrBIXFe4lI zk^+Dy&>k4TXMllVY??`&$kbgx9Pan`i+-_dV;|6Ui#p9U`5Fs=j)yvmMA9wx`&$4^ zIpsV^;WoD@1hr0Bg``1b$spv~h?ovqIDuQGlAkl1Ro4pT1s{dj)<;C{1x^ymRfCWPCYYY<4%4~yl4r|;;jt&C=&tGP zG<1v7-QL_D9UuMH@BQ9i{N~r4`RM53INp5x@sCc=Pp_}8FJHa-m0$hUeo=n^yZ>a- zuX2|~^5x~#>S+D^_4CX^Li>Gv{Pey3X19UO(}z!Ay?EU%OC43Rk8`X0&C%I0NJPaK z&pv(m@>&SK{>#7oPk;A!-v98!*5*>O&)UKQtpR~Gjj*P}(V~rWU&^biS4ZpP`#Do1UvF;ilw#iPNo2Vk zTC;h(%_)nN{j?VjuNG$e-3B>x&LU}=>Qw7?+9ytEw@%vk1stnZH{^i*4?o(EdqH-J za{YsL{pt8m|DWIeyVIku{+o{9be&C8OqOWEFCdq4&N#P#uswRW(q3t~_lU>G-!-6 zYn`So5(+1++FHw5DG4H_)R~#JIg$fmYqOh4DjpEt-n@K%eDSnjtbk%1_oeR{*}Uzy z+kUY`A{3#+Y!v|jR5j6OoMj?&G&3S*W;0{rY24{t^Dq!6A{e)$ik4hT--~qS^?*k; zSDULxES5Y@)xy_DN2zp&-H)l(I)a1U-Q;fQhQ*;nvev22 zBOr3hhYcAKuTLHvfOEcBxmIv!b3;ZV3I}EmIiTSP0RcTs-NW1vqP4kS9GMxX{FbkU zsH$oXz>-9@u1`+^;Qsd39n!Ekedj$Pns%G6>vp$SH#gTO=a0ZmRpad=1*IFz)O98x z(+at4?{1dsH3xVAFhhWYeb&MrszHFYDlw<7JB*Qp(J|^g67kS?$o&B)5{>{0K!FyA zu?!-o)TZfR*hd2d@Ni_v(s#oE;nTPa4^Fud)o}#iW)*a*ZC)Zv$w)NxM10TkvUNK>>hb4tW$ zW>k8BXy!yw!&O^4C?L^lQ}@7<3Z=l9R6U59-7E=PtLmnqfYM1etBFDc%%tn0suB}2 zGE*8ltD16WrV+F*`O&)neIQ5KY-J1uGkALNZ zr$C_Yr{}AiW!rD}!_c!(oo7NYg^T^9-~7c#!dPqbTL1E2 zd=E*8H@irTSr2qsIw7q5>yMVbA*TlfP;sCxrdp%B5|M- z(X6vTs5TF0ivSB#Ny**8!#ojGEB3#xem(| z<{%#Eb)I#eB^Lk-Vgz<1U=Zf85R%qfkGYh^fo>FlT5GplZePDReei&hJg1V=v+sXv zadf&kdC(=!Io&?{!pSgn$aN0`pmS{W7xOm#%K8i3a}kNa)TnTc8( zT@{!BP*UIZee-5>1qH}J0Or8Vh|!vwDWoLKL~L$eYf1%~iNTSn85cGH3UUKV?1%?i z4vDB*gd~3xte55d&w?yUl>+*ciWsI zm97`Lx!Y!jI_;6T?Z@Z08?!c0Iz2gdox>UgRaIf`mMbP6H+P&%w_IDRt+j4JfDnN` zk4h|Emac26h!ReHmZq@3zlZSUY86NT&==NfW)lF+t?7OX09|^R%3u*+`juaA&8tpz zu9C@t2>?lG#TQ;*>fBU@V-Q8POOaCTO!UMb2qo>p-M+fs`;|>NqT1V|#zUS|4jT zbWRX;tbNxHi{&)VP3LhluZ~w7(Dz-PW>q(64lx@N6(S%2VnWPa!fBprolD<)m^BI{ zCI|zf9bVmPetHE zm;fkqH110T3WSLe5de6zs#8}wcRP420wDlXTC6Y9XGEe@TV0%-0D#Ul_gzlqfD@V; zjN@J1kL&Zth*Ddf=h_Xc@$MEx#@+V#>@1l8(OerwAQ&~-=4syz3)dEjfPBB-V+1F5 zb2B4m2m{2Fv#EnOZ;E}Nhcu0Q2jJ2Pky&fInSdhf?V6nPs_$>!ykbsWS9W)A)FYQ< z7OUf9Rn>420c1%?A^;w7;8LP$o5u|@u_SE`e@;#RTwlUZQn#t=!~D-g_QgLtGz=o_ zH+TOUIPA#ogV_*@JTne0B5Y$r^RA5F#CCYQHLI5bjXr|zx=s>8d2*jK~fmo8(8KAI( zV;5}h0LUOfU;$M29YLGr+HN}A>Qpr0cS)*KpUq3VkyMU96T%u6AfL* z1~Y=N0GNXtCUDIx?k?<%>ts1a|EQs$h>RH4vNaTSQwCWPJ7T>lY$WuhVIC3 z91=Mo=9Ej-55E_Wqok4U9=^}Y*mL&jR$^_$DFPRr7F!@@Xsp^@acTdYqW-n@DJ z=K5tx`QvAwK78;rs3F4SxRs8_&DCyywCuaC?}r|O`e6|OIbs{}`tsE({L!)-+pNu2 z!xAVD(Y#ygG@0wPxpN|zC&Z-MFk*}VP*b3k8aNX9Jga-xF(+!K;*v=#kyLQ@LnZ)` zgqTGrkPQN)xe0(HpaO* z%w5CLfka%DNK}|2kg$|q!8?aqN=&sII&dFD9XuhJhiU^1p+ro5*B>~yxuj{DBzK_d zNC^Q6=5a1vb|L^ER7$x{lXy^@MgB#ZO~D2my;M;^*U}xLfGxLB4WYb zTng>S`J*5F=&%0zUmB;a*M47 z<~9+JlO`^6%#=!>5+OiD!faSUL2ErdIk|gt^Xlr=dbxi1=+v~%`|0BRd>ltctY+(B zu^nyP-+%QN-*>HH_;br3IGAd91jOg7na&ue)Iz2tR z+q~JmxjuX63#*e=&i(fGwnV?XyE!>~wBK$CWxIJJIe+6DUn{Bq*0+D>>)-t5o69$) zFSpk>xy#*Z8CJpKZo3HyAWA7Qr`K1n7sC<+2N@#Nm6ylIZ8rjdA*h+EF(0@v#GJ5& zt1cFUsz$_OSeOS@nQWZzM@rdRJv%>{=4z@z9|d9_3Y zO47@6-Ge&i{Ob8-K@#a^S97lx&YlVOihai=^^(hr@BQZM@BM?n{eS%3b>DsYul>y* z{O13*+3YbvULN;JKK}jx_mkiI`~N%2dtdvj4=&b!^EZCuqnCH3UoO@%FdbFhRNu}M zxCL>HQ`M%spU=aY#$t)OjKTeC)pjvYlCPBnh zWWU*7zxr5G4-iRcd9)VEByxXylT!)MyW6{*gg8seKoVghi~z{&=0rkFW|2~2M76fx zO{MQ7CC)jeghXL(tvQ5F^IS*bw;*hY$T=f10qkyXSI0+yFwa$6Wg-i&)6_4P^jSLc z(6?r_88`qEGZC3qSC6m=Mq*K0Zfq2rx5ngG0X~ z2?WFeT;Tu^^E8LGoQs8%2n1@K-6Gt=+}-#9{b6PRHC?Wbx?!l}Y^KC$+T7g(0nAz> z7G?&3)*2B)AYrf&5fiY7Tb<2ZgqfK|az8L~;3292Zm#p3OD8EIF?g6e3nQWj5ECJ_ zR*A_~NrXr+fS6LrDfjN0yWTxqtGT)d6SFW79nOk`sLhzkRGF#k2T2_uSTobci2`Zf z?S-W*R;BCvqtoNF3w3DY*jn3f@9Tad1eU}^5kSnU&IFPKh*<=}+cY9GAFf@q0B3r8 zq-PN%YOO_tnupEk5r~pAG6SNyBN!tRi#5}_M?gddL}t!8rP7DFgW~}b1)g##!-84x zKniBzln+QZBI)`rFP4kd5iye_Bm(yX^_a7WBw}U~04I`Eaw?shnVG4pX_r_d+B7p$ z;xyN4>M1h@Su-k0BpnRIhcqrh7=kbxiZ`QN5XsC~Sct9aJWnMF09nAY9|BZF)FQ%j zlDSrOV`hU$6hw&vTbt`Vhbz+CbYxg?Am!BenE_HRhOBcfgFIaKYx2hrmg9c>!AIX; zoj*7}I>vBw4Frb>b1*|}EF?%s5r#k^B}2HmL4cV`Vsk%~GXinqvN}CO=A-o)aZ-!N z=SLzq4Bf@);_UqNop;U`%T>QTGDnd-Zbu+Y!$Jshml4T;R;!g+08=hq?sLhDRD@9a zZkbEpFPB8A^xf&%qrM+b&d#!=+Ny^1i^VYXtMz)j8%?ov9RcLh_v^(tR%9-@@A^_i z`sE_j=+L%{9ueRc0EEcI#Axnst&PZTA)La!&SQilQh>V|6AKX_AHr4P79LtF2AZjB zYpo#?GqYp_G_B^2hf`E*W|m4h+(jOM20%ao;cgLx>_`!B13g?A0Felgeu6|hNG+|l zBoc%qcsg`PeVH5)LYqky@6`Vg^&Y0aTMj#NtL4q7KdNa?KvXw4!tWjW*`1S0|+A(5E7ngcT-&GW>ZFsB9C@laNY zMj!@J(?b+JB}tM>*9E8~wz(0xBq2lw$O$ti5sGkOIq;d1Bn?}1eQP_N+c=L_D|1Ln zNf^LG?d_@!)^vsl0ZJsLllRXSea>Hh@8XNciBS(zy6>k0%GbDUM#w! zUV6qp!Pm})eQkvPOAl5@M@J=z_`G26g!G`6Dx@M8gB>Z5P|^)G+$Q~*no+vm@|_u_8a&nN5d+dsJarT5>tyWf5Lhp&G1>mOd<>;huH z+umK@zj*x;Tg^<>q03^RHo2BJ|~d0ZL!SJjhAFjR+RY#mBF2 zSA8lH&28CtA3wWVW|*}-czCXA*LS=7`w;>Hbh$oSua?`rofoxReYYYHgfr8%N2x%L6jpyu6HP z0iKc&VCp-<GS(|C~uJ5$9 zX4NeKBWDh?S*^CZ?EC+ZyEpr_ExXS9MmOhN&E999=AK*k-nvyq7AcYPdMATGb6NJ?r3}OhTAWUkN*v)_(4NyepoZV3f%QO)` zZ?4J1Ak8$2l1;@_j1n z5_cp{NQTHCpNoj-3Wmr8;EpVUrf%Rto-e28JhC)Pl*mWKM2A|hpFD_7>)>9L0~3F= z%yvg0WY+3xWz}|q)EsTV5lo3utC{IIO@UKrJ3tw7K?C>72%2p%KGwM!SctKVbE#P{ zNDQlP%^?vP8szDaeEgTc`CF@1dvd&Pj#qAqKt#qd5|X3kX&~a*v}#_|5h=zP0<*|4 z<%KA*c%2x~j9h3wjOI19?L6ifql9EyiA2kM`RK#cbm|omS4SI(4Iu4qE<;MBK8*(? zLJCb2b5(Ma7|np6yQxTGtW}8+QM8tM$|)vf4jecJL~>m~qgL}g&jS*Jo0<_5kq|SO z5Br;Tbp(J`i>a{)AXu#u;>W*%1>dQv&qH9D0MWF%`A6VZ*o_(lpYIr!!me8_1pp{W zkmrfzOUetFF8XQ_e?`vKkWtlE>{zqI^ zTi%H=nwhEAS`aWc4IzEpjlT4kEaxxF_~$_j?!-j!$5Nm_+H#gsDiI-)2z{K&4ems= z#E-HBB69aytB5RL4-kl0>+`BEee}eA^w0SBT^%1kSZ?mlBn!HCA$(~qZbn2B0wEz0 zAi9~Vx)~EKK0DL;Z`=_RF)^cqYBhHzHq}~6(=?7$bBTe~G*5@ruD>75_WU|jx5`YW zN<)2W-7u+?C$yz3l{-H48*+TZi$GRfx86J zs`EU>Ab-NbfQTYtxd+PyF;xI2B1B(2-ODeH2vz-0Ulm6T%paAVu;z?}%xq?E>ZYbn zxR{7ZB!(0b(4P|;@nfE@NKjR9!;k#z%dMeLBq1%_+*)dg0g2R{VEH@x@%=KhZngRt ze6dvjzwxy{3@I!R5hIDv%`oxvoJjcMFa0O)e(j&e)CmVB{s9jnW}=*H*R4Ky@2%s_ z@zbXlO`8a?Yg;u7L|wmP4DPzy<)h8&^!PZJ*$oY#Y96Oy)wjYNQwq*0g?TOkV4g-0 zzrNl!UDt%DX1o39USGcZ;#8)yTQ4{m0oXW<({LE~>-E|Zw%hAAgnn~mUPUmg69ut4 zPJ=UBu8tf7po1YXA%Zh=H3$p_q@aR0*Fwx-SgRp3F}bU&AtM-Iz<^?4Y_`B-_ioXx zZQ7w0Zj!L9m?;D&7PAUas#24%7UK|`nAMcLVM#2L2ts8JT1pecVF@!u*yYKQj#9cg z?6u^+P2dhlKo&xXv8$#MgS&{~MlXRFSlCsy5V-@YLuBsO zM=zY5r=w$64=JX;O%P`!1n*bvtEI4Gc-Fsu@hK!MI{&L@;wR4uOcsts-dFK&V6t4i1XYi8!F4 z*Eu6mASOfy25@jQNU=w95Qf?0JUN6ZFl%0vdF2rLZhmAUNp7!#_oFacCEHFri< zMSvJmj1keHRQqUvU<66YESq}>AvK9On46cX4qA&puSpVFg%Ia?00Sfgpjzft*Gu50 zYe^kKv|LixJJ2|d9HN6$(`2ny>Wla9j@xS_J~=+Uc=QN}j#ejK*FJdkWUjf5&DG6i zim~a}hnvG{btLHTz5Bj10o%RXw}fyYIby=k~pr(!1}!b@}Y_#g|^Wc>3_x*&S00 zQSRP*Wt=lWN_zP-G-CaQwXG)>4@aL&VA ztH&6@D>rG_&+f}i0$tavHf_^3ZeFG#NH{({Ch}>Vt<*BBkhDhv4r)5*S!*ro(~!IM zIyQ-7{NSxOn5ddl2vZ)_ykDP~IS>rbK78+uKm4`-^?&-kfBsJ&y!l7p{noeP_*F!_ zeR_Phift5D*yYSb93vrWnWy1^BG2;!eyD@L@Hc*@l+rZKvi|$?$^d^Z4IqS2YsIA` zgph|_?A8v3h{))Gro|0%HAZLyGo!>%YSm(0-%CiQhQy{|p6786LL5_wv0a}6FcX+T zRW?H)Os=|W(Wpp6ZqE>-uVMhRvYGnixiKz`K z0YJ@j$+ONg5}Dh$KQvuy21_)6nE_I*6&=h~wIVYT5n>3@tP)XbSE*?ci4c$o2nZON z+&#}3m&zSW+qI!-(0Q82k}W1eCt{Ky%)v|%V4f#JGF3ue`1OdG+D6qrQaaoL4%___ z_Y1D(CK8Ysz)iJ+MUEVqNEXn4EpwT&2%`uQtJYcy5wWnks%nscL?VHRkr2#EvDh?3 zU{y&(SV&~qFg0D*uQzSqYb~`*=zxTT2!NnUOdJA>JZ~`rcda3XdCn;&U<@HHn}{V# z8IcKm8Yc%c_nOPi)kW8@%rV3`90t~G$P$*>5|Aj0h>(Gs6N1;Ofrv;<70jv{A|SDq zJWr!(3TN>Bt~IDBwo<(?$15*rA%{ewfsLZ9*TxvyNBm^&@uGNOaKEwcy z!lI5biq3f&2C(W&ig7Lsc9?3Zy6*e!exG7fW(5RwW5JxOgM~n*s#8u)Gwf%#Y=~eu zms+);+BgpmN*DkP+~=yaAb^WDkl(u=zxme1)%DfS{q#>fy`EQ_HK3JZu4bypq-FN1 z4&+2RXLsiq14Tq9M>lhakdjCor|GogFP`^%GlzssLY(K3&`hUxwVuX#wOKdq>g>+F z_0dU?5K?Ma>mbq{ty1dRrU^}I+CGF}PF>e7gQZ~N$b`TWNuX(3L?&iO4-`WZN6fRX zH|wTpYO$tGZaz;lG1pRREvq&*eb>Zx9H*vDwH76DaEDro3K9l3RR?r)L?_}UiVHa| zbq6CX^Jr!bFC&n%12UR}xzh7pmYSQpio0n=RWvg&4gt_fgqhHQ2$9gMA|f+O5C>$$ zMkIBDM$CdtjQ}Gu;b}|vH}U1;G|!OHK#|xGT-cpx(O{63B?5ZWtS5tvxDLDxp8V3(P}aG7y^<5GP=8Y2z0o3(l#Narfu79)w0m~^!DoH)XG%n zsp-42-<2}AeOt!duQn+KL}!E$LkJWkAaRIk)x{>J^L41|xfIaa_RT_C!yrv+C3X_v zDDiPan>K9PxM}e;@k^U@)>G32qGSZO+wkJ1y?e~;I#pOjcx8<*_I&>ck0Pv&S3h;P zU0b<-(gVY%j??FE#e2OxxE`(IJ0Dy;cyzTNrgam3@AtlY7)Gr+&6aC<{mlm-KDvsL zUwi$%%~4ZwdGpN&T`#Y{`S8i(%V!riPoD0^Vfx;CPa@iGKi=%}+i!jN?BeF#_nvIl z=?}jC_GXpVUH8u0k0s)Rhfl7yyF>9`|JvLC%kRAPYrp^gumAqL|KhcWi2lYq5C6~K z`Cg3it8YBo?ry&J^>=^!>u>+jn~&dp=fOMgUp;)f`_}tczwx{8RFwbgwRb+XiNE{p z_j{;~z;A!;jd$LD__Hs!zxuDfBX#=C-+yNs#z^woyN`bR58wah+fN1jTfg?dw>=2M zXMXzcef^F1+a%Y!U1+*e?e1BBbu-<$y$(UTb$I38+4Xh=u;b(YD6zSI>QgW8cO#gt zZk?&4o4s&;T66JoFqXFOS=Ot@4%as>F@><%B$l{ZuK?_NJLGJix_kEY(Ob2Y!0GCG zx8B6lqfOhjA`)WQtlG2Vu4~1d(A>$*)ilrJR83PGktDPsrLI~X_d}gWt;Mv?YJ#C{ zL?pVIFzvVd(6le!zoS;?d2YLo8B$6jbhx?R-P|-HscTU}-?#0mvuU^)4uEuedNNIW zMp6h2klL8qo<(BYHcgB%9roE64u@i5~$kWkzkZ^f@ z1=aT3n^LNo9^bl~x>d<@)1>TN&6vPU!M!LdAR;Ol0fNJ<7E_bjcFfAm4zyI7z(C#I zGzN-I+phXN?9cAp8xOM~bRiX21WavvxV{Q0NeGAtgb3_thwUK>BOrl~|e1H9H`{?oUo%^TvUUpMNaB@U6@S|HVfO`=B zge}0m~7NYJLgO| zUEhSRU9zB%ktNhzNVsNgnh=v9u$nJKO#-hu69SP8!{Cd^6Bv^0}P<{F~J)YMwf z&(FU1y>~zNxzF4_K3g*Rf^ap>xvbWkw(SUE%5#i@&WHW3Y5P^*IC95~T>?S^V`10& zam$TCo2{IhE2B=oYL#7Z2>1eY_sYPNy2ZvmWJpX|Q zKnpR}k`cLT1qX7k4sI5Lm@Oz#tc&8fq#H1~n;IZ^3{usQ5RlN+nF2DPJ3xy#yC;cA zXbT>q<^qU}xfFUHdJmDvM98#Fq6((w!e|{+a_V{@LX!RV zT1`PjiPkYjPEYoitweJJgK6IGx4W2{KqyGg5D~k+Uw2(h9k`_!yVSU=nRzyiW-3Q9y!VOi+_5}B*3w=ohRI#e|bSPUpv z3Pb@x-71btfLDF!r0LwonV z4`K*?+p0qdQcHHTPaJBdh@Q(_N-i~*noG&K&LMRSzG~X!gCeez^=d=w=dt&fM@)|kASG~&wBFatr7hy>lbyLoz3 z=ej?PO}`$e0|OF9jxtU|5JaS|Yb7>};${$VKb91@*jz>(=Mp%?rpa0*3USDFKI{i` zFY~N!hnx){bv@K_{p5phfAyce_FMnQ7P%S~)pfsi)SRmXpXURpHT@a@gmJ$g&ez8PG#++Mx0-V;CFeX7^WiX^ z-M*XJbl6@mw1-?2Oxw0`fI1IoN`%M}9de$hJn;nm>ImJLQHuqU#WBFkdfD9-9MsW) zNg{!9b<5-E0MaodIB;kiBJw{T&a7Ghz|{=A7BDOB?gn|9LX!d_fH6_2l{t_|o+i^W z><=-YwDTF%DRdZ}Q!lg4GgG3_YkD}@f5rKq>B5JJ* z$yeQ|6abUhmdR2l%!ny42QxD@KxD#Y&<-&G5tykK^vWTH7{Ji1s9BH((7++2P)o5o zg%}BiLojs-f%+8+htND2icOMTsA^~@G6L^jl2QvpGYGMl zA|W!IwGa_Wu&TKfck-phjG5fkN-d_fAUGnGoH<0dJrOSCI3h3rRW&sUfkSjKAVg$x zDm9ZCA;zY$CA!c6&^Si)MIeEy8L^QNiNv%b(RA2_Ze7fUWS$QI5GfF*(D67-<1{0Y zV3pAJeW!|MwGcwZT|OW($H?yEJUecUlezU6jjQ9SuRHO*S)nb;3JmN26lw z`@?P@B{cyMqq$p(ERYzBwwCuq%Y>BC0f3Dl22z`a6FQJ2UmUZ}V@=~Ubr^v)1g_Q0 zR0I)VR+FX!DB#8 ztm0c+1rb{4Q)VSkb(~_?L5!>rg8;F*QKY)vsvAeaspxcYW`3Sf4-B9Hp-X_^)w>jx z)wD7*atO3Eq&s7C)=@QECFukn?$k+JgLXyPc$|w9y}Aw=`TEA6?Zy}Yj1Y{V)?9Nf zch})E13TneqaeqiSp~ELRKh5%wH$W40QTf!&xqsh>cy8|$t>?ZxcZUL-hKG^YRDxW z-;bQX___NJp6*VMns@%_TXi@{zxvVjNu6`(*ROr+o#R#ao!8#_(r53z`}k6gZr|Em zUk$hKtQsam4AB0;YwurPUH#OTUisDE_(mV`T7$aZTetuD-~X}y_E)|pZTsp=C*S_| z2mj?S|M>5|zy0T5{cal|3O(EB|M=hi(!cz@chvCHFW>qfzxU+Tv$m>N%dfn6E05Dp zeD3}~{-6K#7e96OW1l+zm9Ks)JAV3B9B2RXXYTygH{KbQzVi9I^KN^7`|O>^*PBT9 z&iXgM{lV??qpKmOZp}j9dFzpzfAL4|{?0evdHL?i<;4NXUw`-6z^^D@DKY z=EHyICtkhW<AFld!Xxk{Od!cKNx+hO>$ZZ&>lcRoD^xp0Dqlee;zWLg4 z7*0-)3GMV`Jyf_Uc9NQls{<3faJG4Rb<;P=0GObSDD$wd z=>74=Y6S-jg6^qnhU=@QO}Fmd;gqJ!t<^jp#*jjaX_&@hg&CilA49BVt~npZk%8M@ zt{y$mIV(@+w~oiTf`@Ue$H(1a7z4ZX?aApH+>L>Oi0o!JrWmJ^kGfttYtdmh8;n@@ zBFt&scfFc*X??l9UT;nWH-~Z7QXz!?DQY+WHX??w4pPf8@c2nlsw2f*hSt-!|>goFA z*452?a<(FKLL>?#$-M4%qX<(-Z3Hl6hsV#Z_v75Q>3FpohH0GUsbHHRM9#a>LwCI! z`?l3mG>940T8K%6yv*~gUDr)hj**)Xfuper;Io^XNC~XAtJt>9)zz>$?zj7as#?W) z8mnO2^~J%}Ifj!LUTpfa?x>p%Q;39!=*T1~pqepa&K4UP$Ks@Qn9-F5rWq+P2VnME z6&Lvb_whdBj+#r&Gcf_nG|wqEL@-Yi)QTah76}mJGcH=A1f&BB_yK%&69NX__W2)zuG&!}Zlo({xRL91|hJFwK46-dsFQ zDFCL_HG)t9nyyD8Hj@}aLsL#Mkk)E7UtV3O)UJ=#RV_B6q5a99`0Uqz1=hD-YA75I z<5ylhc|Z3c!5woh>gr(bY+1+cwXIeO(qXsn*PEKBYTl&iuH!JkI7o~oXNj?tBE$-& z(-=a`^K4aPTD!SfHKG`k6Vx&zqN~ATqhvDEZha=P*sYhnFplN7Fcx z69xr5P>LVwk+kAL*~H)bwyuEOkUW>Y7f$ zYSsNX#wLhb;-rL?v1No(Z>nA&hOX_Rh&i9%IZsi#uKn=CM*#4t`?rz#a2Sj@hNkP9 z{r+$$d*Qh1J0?0D24n-o04yQ|a&dXJUiafL_T7q+nTb&{kXr$@xzJ`Ci&1Pyq zEOVZP5-1GAuxgqu*b12)LCah!GZ8W}hL}p71sNUDfx9j{f;kfr$Y3=RhSY$W=4`QX ztHo_rU5V6^!O;o4dPqr4qX+|C4%>#XL1AV>AW0%}C`HQ*1hdsdK?JK+QxC$$QNf6S zjZL7|Y6^@PnCH1hfM<_CJT&bKFTV25TW?gW=H=e)m!>>lTs?zq2D3}^j0i#12#&^S zKbRXhR8SH**_>G&U16MNKpGBPL?Dv$(-RK~s|B?noE=2kX*`I7yN=>dKX@Cf^}>i= zl@SUEZOt110A75PEaU>@H08noje|J@f+4Dz86+Ze5J%%c4(Q-+RSnQY1f7wrR)`@O zxD}x4AOvU&_?5w#Vu8|7qXd9x-~eKEA|e1K6A>R=Bv&G;R*j?=RM!dwVC0?=BfxAB zL;#$?5I}1oAT{kJ6-3lpiy}c$)j9WVJDLsPEr%1ro7Aifa;>3>n5$I_3__@ptJnQ7 zOr-<~1asGR1ZGPdfEyqas&Wf;unIs#jwX=vU~Xs-gdDJ%wN2Ngh(Z_dKieD~JMcJc zW1En;m>n@+xkf}#%N3i{Y`1$eJ6bi7BuZ@B&K#axJUQE(tyb$&rg7fgyYu31dsVBt zY7)8L??IhJ5dCmCc;7Tl^XTc*^}4^h*&iRT9YBD)zKgKl?O$(VQ&5Ru8YZMaIVh6* zf*bkx{bfmdx;m<^+wH~6FTdKPkmou3`0&B|7njdc>R-Hn=e_qIY&J(_nhqi{#+>Ir z{G-=i`Si=K;TzxhgZ1W^n0AK&F+6?pScIDF)XY>)(2Vg~~ix2#8XO#;!4_+slb$ULUQ1oq<*B?&dOW`e{43+4c2yweB2I7238v zY!6c|!nIoMo3=tN6~Ix)Io&;}vkk*=`~IEx-hTg_O;SK&QLTiS(l{Kf6cn!N1~4Bc zk@)E^e%Wi@ZMWASeEZE0A1c^afAxRZY)-!PZ~dKVE?@rnpWh8*-?jQt)5H%q+sem{ z{zUl0$pAl~20%ns3VmM#5Vwj*^LUu^9AnJ6K8NAdJQbR+bk(;(0w9}X2tMZwPVKrU zk`UWlx9@!T@WJl-Novogn?eA?|K#WIcnC_zfDUEh~n9gv|q@pgM7EV1hhOhU|g z@XDoBH{0)Sf~3^1)M}|lgeflDKH|jlJeir7nK|f!Yd|7IBhpe3`IEO{q0%EDI2^Xu zhyBgTtrt*8)ro+Jka;>3vucGv1b~c?%$7zO065&-jMFG`B94H7B!OkQj9RiVtk)YN z7^k`EJJ$$AOk@sPa&<>Uj**|^LY{Zcz{08qGxLxz02d+zP_G`jYE7{v_NB=O0U>Kf zL}3SKj!SNeY9S-61wq_((HIpA5(!Jwb~B7xDsmJF0FLMYL@_WjAh($hhfV!ruP)mV%tler=N=c-6Z zdDu-Uwc{|eu$FqY9b$^5Odmdc);99S>({^VGe0`bGZGLHftON%Q75Z;ZWm zPDD!(K}@BT6nM<}n$HBHIz@aFpbq<{G2*{!p)O$^_9;{lR=`@O4I&yRlWm0REZ z@cJ`%kH7Kmv&giGw9Dn^f8^fRzx$AZGt_S?y>$EN+11U5k1y_?pFO!6-hQ(C(O1uZ z{4;lc_s#dT>i3>ZbJidK{M~mxcz77~mww?3zx}V?-ZZcq=R50oXD!!<^5|yQuTBs_ zd3Bg_XzBjl6L7rs@@Iu(b(KiJ|IH6xy4yc`yt{S#-u^H)QNH?nuOA(y)vR}po6DPP zg8ae5CokQ-6NTS>d_9#qTu++(!^ao*UwGkk6F&3eORwHaKmMQo8~||$pFV9K4#w{P z@Rxtm++SD+_?i3v`n`R-?*4Lnb>h2hCI$q*Z)T^o{PY%$8BqQJLwB&YpWU1KYetEDZCOQ z3Ngvg{*6~-2@*)HCjNUrzb3-J^9x@9gkfKSAT|N3 zfB8%IA#2w)U-^OesVuwI2*Pe}Hy1d>gQ=PME$<>;+ z%ejoXdGze&i{~=u@^r6H_J`E;4o6-zSMNHVUrOepE%x)FkB4b<9(J|IyV8r~R;-Zr?e5FYg;C4&iVZ z?wp;sZWLotyR+_dsfRhAo*Z9Y-vESN&Ry!49$E@<)vevM?zZz`*YrJD4oOf}dZkD* z9Bzo1DOS)Wa!2P{C!OQSL=sbK+t>zEFXM>ZG)=5|diLbmy6G@RB8*MTh|@5PRwbm8 zbDl?sC^332rOY*#&_|uiG)xjHr7-8YR^6=ITGb4nUhQt3Y%J7qx8FW{Vu*PhU-{hU zFD@?KZPkUdb*#tru8vx$a5If9Vn`IwfmKW04O<_xoUTtc{cgJr z6b|FO-FYK4%@uriezt!0Z1=+LqbHY#)U4ZxfuQZ#-8Nlk<{=QHv`xIcn%LpH-+jAF z-L2ajVlmLU?82zAOGCv@zyQbHxH}Z9_5AE8b!jd>S6Cmdu6Bn2(00vu*j3j&jjmA5 zgYbSkQ4BHJus`%oGg+Rd8jdywc6qf6RGU>cGXPx0#=Y#e*D2n*DI+76QX}JjKgJL^ z#MFhGo5N<)4cqH(y$(&=uDads(5B#S^IQxxGE`UbMO*eVk3qzMDxo?EhN)D>3Ulq( z&0KPWIORNNJ6;fgxYq^&CS%bA#$8mrHU!!JkRsocTLm1 z2tdM2Oo58yE)kmyMYlf zq161&BmMH<{6+UlAiwmLm$&Uw?a7O9{-mj#%Ej~4!d3GkB(wv)j<5?N<93(lt)FRs{SR_WK-MPU(SdBwSHNte=f!4`L5A^$lCqK zNTc2Ey6e_|K@H%qEV%#wgJ_NAQ$7&@@TckjgvgA{i$@3CUDb=~PyWa&`|Ham+cK4h zsarGA55iVn9?H$;xLd7>Q59Y1^?LLEhmVe$zM3&IbC8%q2vG3q^6KsjcRb+1Akre$S_#Fn0$4SW09vX@G^+p*17$NO4`!R_mH(KTiZe6v>Q)1f*ysz+oPvq#a=O;zpe_`GY{i_2$ClsQi~ z7ZcAz1rDklNi7E<~J*&88~r^r~uA_97fkSN{bLU))0g#l4=Q772W=H`_t!74q#sQ#ORS^*c zB&jt^lsaV>L1u9^tPvo)hXsO$)VjG400d4sPZJ8NEi+^Mzo~nZUhCH5zOSmDZgsmk z?c3h|@`~goDN1srIIs*iG6H0fAVG`_g3OXhhWQ5h2pMN)Ajl}lDDc1z5G#%iC^BS9 zB*pIXUf%9~Prtjh*3(s02K&7fDLN5F$uKfGgL8m=fVJ1&tDdTV{eIpnfQZy%OqIwI zk*8GnaM+!$*8)Ubo$^>!oGCHRDUtQo08a@PtIc8ZL+3#YNRGuLu~bV9C=wYEXuJnz z@(tBg0Xz|=ir$E-1r;ELN4ZNGUlmDGRCDe zr#UW%ZkorTSsdcNbs^68(-^Jy-da|eYJC3s^Km;l>%H@~85*;9ZrOx(yL~V&Y`52| z#p=lPo^!R<8l>e(@ZR6t-XoBAp>MnOVpVI=!mIV!x4!$wh}?8uVzEs}CN)j>=bj6y z+Bo-%4~vrH!*<&bi(2EJSwvjuhZQZ?r&22mNRFGkG%VNF+En=Er$0Wwd@_xBJlr1k zlWY9;VaqF+=c(_yIihiP=dv}mrcK3=R&t#yh*N(Qyo`la{YjcIBZ!(z3v&R#yg zT&_-PDO&2VUZ;3iE>1%0S$W=!7iVW#1VpSCmg1>Zgk>_wLSdcovuN(TkB zU4sIf-3Aby3#H_MxZiHbf(v1_=zY`OzPw$XEI`o>VdYm+%gxnY|Lz(};Z&wrm#5w4 zdTWe*?TzOzuU|ZRv@*uA0;hxq$#w+XHf=#uYc&Q5OcnY3>KZIDmpJ7&-h941J$wB8 z$q&Exy_EQ0{O|t@a{2v#{Er$R{>I<`&n>Ws{K{2;{rRZ+uQ&$yOY8w0X8>)RVl26~ z!=hqW)0OuIFW(8md-wmZC<9zU* zk;-@|DwVUd4xA-IGS0ieQpj3REjbx-3PNBI0Et-2Zu@{oND>j^D`=WB6Oj*12n`tG zl$6k}0vA`uP2aTQfXG-xaykv=HF+j&aXq6LH1FQ4iS}*Pu z)CK_1S^!W`V=YQ4S%Ad*z_}PSwPvvXXnav6vYtyMvIJ0-L({$5Vpcr@*HbN)jUkK1 zAfPgfsx^cFWQ+J8P|o00EJyrNlXU z&$V#n9GYN^o2D5N`eAv*A1MM^i%69#zSV<=cRjr&GKh0`<{Yml&Ct;gLqbp7#t0mQCpZf|cI zgBrT7AHcZEHODE6fK=DCgw{G2+D;V!2|y5xG3Gd4CIv!N#4mFCTp=E1Hb~@L5apaw zoaV}99uH01p)p*l6^Dk5a|nhQ$Xh{H1*u%MqN1j(AcUku2tevWKN!&_TG78|D#;UOKSaxiTX**wY5$4-XByU0S1^o|*7K6~%k`L{o~P6ddlu>9uRXaD+x-QWD$@?ZYornMx(zxNwY|M4Gu z%$)w-*WWhI{cd+xBsVq{+(}r>Cu$p|M}_eAAIxacYd<@&9@id`8uaB?axoTo9*H4 zN2@C3V(2r-i_GU2C$ZE8U=w^se)jzF#j44+zr0+&|L%piYK-~que{L)^Ir_%(_PJJ zI$JlZ<>Dg9+3)_^8BO24nVYuTAL4Ss=TFar3y1kos%^b*oZlYyAf|76>%gKH<@erN zyT*krAEx`uM;DUH*S_>L#yRDh(%d%g$>S$Y+xoWg-u%X+Q!S+kNaf{X@%rT|wCzVP zUVLyhE*o6;;V|BR|3z3XR*gjB@#Vw#L*vD^1;C2FzJy)EPxjNghnu@OS6vvqXIOX5 zr<=G-dYJYzo4QNB?Jk0T{b}3w{Z&+NaWC{IpWU5Ui)b{~AIzog-HWSDu4OzNnzqd) zbhB+ zoiWB8cKfCs1#q5r!>|TYgHE8fZToQdkXDO$m`lx$a2)sj;_P&A?>*{%@M8Dmwb!KN zM~(P8S<@22!^5s?`Y|Ui$+{4=JUKnR+m0`;?!C2S+SL+V6V>@rC6`fI_ln@pnkLlUd=V0je<%^v6huysmgI5i0N5;i* zTK4^6o`??t zs{^8dWCGx7Rg*Ee?3RLfKObtY#aqKvOL@3^I6YZ$mF2~G+YQ#4>2PQ4k}P#T9LCvu zuX;q^>tQ$B6U?b#;mR<_xeFa?w$>cRRPr<)c8a)Ku0DTx|K!oYrQF^foVTITi;Km_ zpWbIvhCWE;=`iPPQcPSkGoP+n&2`T4u$?%UInHZ@pS;*SI_VAR;l8x4-i>;BcAg~x zT6Au+pNHO65TbB;ei~y9P?RW_>?1$yGFcNsKV^R7`Qs_ZoNJ76^RRKj%>}6vu&x*V z%d62jXhUe1ZLJk5SkxkXw~0u|2-9{`MW zVG;Va0f1?o_fxz$TgAg6=h&?l%rQ>cTjv|Jh_$jY)^)xyUYPG5_6>*CqQAf2HBGbZ zh^vC~v2Kfby5^*mZr3vkh2dM&*R1)&!uzS~7-61!}BieSR^|W!3ka z&9q+i`#Sq}h%pJ%e!I_ebk5AXh*Up+d3$!Uu%&!*ednA>;~0kJIM*@Fr^_MdT8gHe z+Qx0?tPlWE0H-PXCX9!e;o+fKantk+mDrWaQYr#S$-9S} z(6zyZZs>E)L?*>(2z?V=vmgZPz3#S^1qgl990M9T#!@N~ka5Pjni4e)fHlrbO_>Wv z>H7BQ;xX1AsRCrIg4SFN83i$5^i};|w|5T;YQU1WQYEyW5cQaTG7hb?*5sTGA`&@c zkg)BWn)+_FPN@{GP!Y(A01Ji3;x$)!#)bpyKec*Eu8#? z`!GMZ0q}G2|0Dh1&<8K>?ePGs$}G9^H{N?K&NI9AzyC-7^nd*C{?mSaX087vXFRGP zlF1rixx2kOJ3HHMADYI7#xk1}V+H8@u4&qFx)Whz{psl$jt9o=Zol)x!uAU&Y09Ex z8iXB%k`nbj5e&mH@2Ai1KK;h8e{Frb-W{%tae_q)+o2h^_v7A%rupCx|K!;l&mKOx zKRI3Z{eq}E*Opq-Jf&I}ZC}_~=M7@4f@oB#S|Tv$Fo-p#Q7Br)TU%5Rje)8H9tlM< z0KpOZL`;CH-rCHfwPqkfG5{5@BiO|3nx+DIAQ83#QPm=$F*)Zff&d;}v8I>$z-2J* z%$VJ2s+qplU7Fs>V9unpM3Jd74v6rHBzCV+d{St-)HA8qf#{E2dZhkdOc?RInb8XZ$O?n5!^=)@rS-BHoZ5L1T)jY5~OB1yQX608_3@ zW9;e_44|mDMjd%9-n+`R5jB>AwUJB}0Z)>v8mh4vgG4AoIVUFaD3!r@ySBZed5G2L zBHkSVwZSzNDiMu`Lt~r|MY3| z=f02;VISkaVSt^pl7F~=V1V^%RZz`Mn>o*9=n$vV(~EJxOJ%-%{2CEX(*#6^X>6JXKx<(%IF9?1)3eI8 z?^jo!zZ}QyYj3?3r^D6D7t6&GX#Mh&pM3fKZ^l~FZqKZ~@z39Sd!9#7=A6fQzg(_j zo*VDUAdo}k-C=a#jWtKwAd3*H2v{3(u0Tp;t+5QSeK;U$8=PsvI8T>PF2DEP?>&9? zwCp$Iv^B;!Yf8;!9=o*pA2skJ7l1r&VHoFZB0$(kmVY*Mbyc^86OZ;)!KXgz{dMF6zUtBL`cY9b^7 zi*W*GP@PLwRYfH*WD%`1hE!F!C?X=gN_Zm*2&bw5QYAD_5zik#Hw3D1^q`9f9Z`wC zfujW$k%?+a7Cj&tBIC{J#Uo}eDUmU%3arK;pcSqniU_XpN2yV*Y{(t$vdjgQfV9+t zX+{ET9TIV^EKGn$lTX+9TGbd}Ru_DZF_&an2@QiHfa`pT3d#V2X!N+bpvtw@oaSlI ztn0ILvUG%X3Wxz4ry0qLaL!o~n-Euc~cUDRES0F$k&xP*bul7;CJxM;vC? zwbOogwmvOY3|8fuQX&9C$|;9{as(L}BC=JAwcc2#$`z0$D=qKIUu#Ka}F%Qb-tD5-kq8Xvf@@s49k zsn#4F!gMI>wNHgz6H2ZVX0k+3=P?rzsPSZT5#L&;f(}b59H$tgbD{H&tcfW)13Avd z^ueQTx@EAX)@d3IIwaL9b{NQoGRG=ljrNPa=BkL51wqpcCNzx*7bXH^Qlv+xL)}kr zKYuj9>T(^v`|-}(fM^UUs2=9H?7DyTCqI7rxc~g~&6nPP@7q7PQIgX|hr0ipUw--r z-~Zeg55TR3KlszS+1JyP;bA|2`N{B4et(zB^n1Va{{QeVepstEeSgv5w_jR^|L|}B+W+=1e|WiUPnU}y-%ZFcr`!xDf9JioH;4Fl{?>1Q^vT`VzWQbB zY%2WT*T1q@^a%X*Z@QN+Z{Pp=TdT8^hy4LW3KJXXOfa2U1mAVx%{QOUsh;=d>G^84 z?wYTihVb6IPYmMyejca!Z~x}g!r&UO#{Or&_gg)c|LX65SrHl+{-fV{ zw?X~QcOU)pAKktFtaxX z?(Nqutbb?wu$iXx#FFag^h*%3-Zs8dtuJ1@_{r_Y z5*esGO{O10KYV&~@2x}Cp=-b(k=bsOG5W#bw#IR}UguJPOVcl5x<|wo%eNBRrkS?8 zSPIAK8eN>yJUyhyt97rS=`aP-{eDZ%*PNU|-?b0hc`idSm5IPJRf#_XPxpq;YkQD^Ej$h&d7QYczL(!`^NeKEpn`BK5(gdzu#2; zXwe6_f9LUPFXn@n+dR!V&V(4p={}{|6t6 z&n_-+@2=8*0;S-sMQFX7=dp@tuC{A)oO8_H&@|RII1qKgkx?RBB||~uEY&h@x6T;K zYI_&A`~5sB;{I?j)=+35&PA1gntqw$B*KQpx7`pL*8~GL=A+jT-!B-Fi&x}xxaOCb-mvl`1#vkijhCPnNAY_2d_W=(@$@QCOAi-n0D2R8YpF+ z({V#+%5w-N1UK%+)6@0U?cO^|mGz=6bBsLpu)LWjXZ^f; z*xcVRqebpB2%$VY9J;>k`?hr$Q$Z{#Nf*q%P#41PFzr))EzU7?#eXr&gI21i_@jQ<{Z&vx|1OIeYSaSe@0FKYnpH3`5NE;-ni7 zeqZV0?9uIRK3z0-_wvU1dOuB{zr1<<`9+>*g4DY9<^6W(1`$0w>4V1?*AI^_*UXIQ z?rv|TR#NU;->()iF&HzZ6t7a(hiNLyMcD0X=$e#f>$>H-Ka6p;9J)3f<_U~_{@Sy| zTxQNWEf)*pDA%%DtznAeIPW%_=dV2>02K-dGS(1+*x&)-re9a=BR43TcjHbg>BY zIJJw#VYdt3g2HAq2k*(yW_vGMPS)p}-E2^AcAKH^$1wuw%a^yRaCW(#$9Xw42J$F5 zrs5$PwdgsB&+tH&U*k<8V$*ZBm&hN(2I`@O0Twi_u@#o+AKVENpPl^hk3S=+ z=NG3p*ZX-YSGQNMJvrMQrWaRtZ@&5b<;Pd&=j*3WPJuKfo#(@1(ZDo8Eq8Z2GPWCR zO7ZS?ynJ%9x!trwJ09ZM<>Tv{J4bwSw(yPL?M>78?IBv*knxBJ%G>R}^;VTRDUxkM zGtGIq8kD(~Tq;gcpFdiuN-4?s)@U)-)+%HT8ZyQliIWIWN&$eHvtrFTw!w*NPE15( ztf(-TStt~E3b5uH4G+_WL4On}CLa6ucG0gZRTIqT-aN1g_~l6#Q} zc75?gmB+)x!pfQox4{GXnhR6~g#yNV8yc5OGR7P03dbt-6_~zM(HRZc<5ps=RT&fw z*`I41tCF>8jy2D|X^2RbRK+=$(`?ihRdYOmys})sf}z4MZk_8Z)7uxn*H?A^U!tY` zXHJ4IC@`;n{MiBG3kSd#*1MnShW`>B;lD;mP3RWKO8YO}xhMJ=xYNJmw*6ndbB}8 z3gv>34tk-~Z&r z)!EtUr=NZD{`=oR2={l_ZQGK=!8e9TnOVsgY@9cQMQqL096f|K7!m}dMbsb>*2>;m zIiARgP(%@?EXHCuIwL_r#W~A}rB)VcLdXJL(;b;G1(W~+fdEwy3m_r}VA1z670ZyU zC&`syJ15t8+jvp1B2fhq0;uz?*Lq;KNTO^^!>UktSErNJimmb1AvrXG=Ls6ixw7D3 zZ7G>kQtMIJTM|IYETxijP2)Ias#!zNH5%u$NEZl1ST!SZ6{{enTGFJ#RHX>0I^)m) zFds*&3J3xWAOc87CkwX}ij>yaOvWIJ5v?kyT%&?fsL>8T%=r6)vT-;5?H{Z%8CZFRI3K6df#MWZ)|-f1_2OIsHG}mQ6NOj zmC*vQC{XLLLM5T9096!}(Q1trEg+yk0UY?c~~5rIg`ToH{^+2z=v1+f;P0xAG0 z04!BeW2mr7$+m0aG(my3@2gf48LJ>ls^S z&pxeM7OTOv&Exgyi<`S#sv<*aYUMF!B!dQDT;IePyRKO;R}Xg^D)RKnlihx+KR?n( z#9a6nX=XkIAAIm02p;Zlmy0z3y!OT$%8DR4&CBkz)_Q&SP*OTMxj;uHNi8*{!YZp( z4+`)$tEd&jI+wd=YVqqPPtk;-DZ1_f_@$!S;*ecy4>hr8R= z*=cJVOXkV*w|@NN9}%gdJ?ytnpS{i{E9>3O_2XyH=Q*C7G^UuoUvMoVmB4u$f(yIt zE_mAnj|60mwW6TLI25j;q@Wd?!C~Ed+r&Jb_vd9U=a0^R@S~63cz%&{Mo$7B0M@5# zR7o)z5pW?mZI%rIB$-ah%nbG1W2&i z-wulF}lZ-udD8e*D#MeC6ZaM;A{XovU!s*Pp)elg~c7 zJbC=+{89JTyWjbvZ~5Mos?osXSko^I=xjVIc1vQde`XH67)j0Ge|mG|J3XDu_p;WPsHMKi+@VpFcN< z2*kz8Z-v=SbPg0)KXd4xJI}bLKXl*;R+%QfW?qC zCFi3E3!#Fsp=|&Nk$h+Ye}+9}Oiq&s7;DH{WhNvS99ip}XD&HTVzTds5|fmQhGMBH zmBwHZc4Vh1S_`>kN7fRdDv|-J!n&JN6AS_6EX@#r1r?{=jsUDh0hLr**CH1{Feb$e zi^Zbx#&RLTX&$wxO5AQt*EWFGIq)_Bs&P<+)0~`hZ5IrhDaIzaX&MiQdAVrDST7bm zTZb8zr{~}Lziz)|r*VY)X?pE){qlDF$~((!y3Zfv;@M-U^}qfH@33fSo0{_s&2N3} zdFy>^X^!=`l=m#JU7UP$y(vZCdFN57O3wW!f9LDIp_B!M7s1VhPhNlg-@N^3u?VjX z<{NLW9_|k>4)L3h^oNIzqpnXEo6WAZu-!adocA$JDUZQ4gcfSaBJ+N14B3S{95zOU zj5Wc8Ca8$(tR+)w1~6Ll=XZQJ&QeM&5Sk!bgKugct?{Z7r^y+-e%O<;4o0}^|Tk0~8vuJkYQk(#cf|NMt!^8Bj zHQp(@X*#sld~~~8EZUN5-w!!Pwd!muDOr;FE;d8ouht^*=H-+H5zAw(Yy&X15tym*xXkMQ^-!`*GfF$Fq}l&8ac2Fz3W4XD2y}A=>R{aQI?Z z<8-$iLPNUWWlLx*tyV*v)5GpM_~y~siS-RpNz=@#uE-4holkb&dG8$!Er}FWYe^X5 zyj36y{c_dDeQf(6A;cO{VXo=o^lVNkr=$R2jW>3;+vFHS;}6r^HXSJY;8U98T!^qv z)wqg8iUtktcC&ThfX`M-HLf6X%Dy8H2+N_&2N%rd>WZbd{g9{m^z5YMno4Qgh2#lE zVw^#-R`!iAMI#n$JO*ne1>a}qNO7z&G+oKjw{0#3R8iHpp$gl!UoMw#Uxb&padViS zzxRz*kRNMM^7l7)&(2R{W#K|bU)+v>Y!PzIjSJSJu{Ne+Ag7x4lOae(+-6MYPaX$j zSPNDi=jyyyuDi`HPg8%gU=fh&hv8BG^zQD)kem(6{XCCjtZKKn_lvGeQqL})9CnlS z#TlDoTrU>2mhq5nXKTa=T1u*uAY!*z8Do6gy3ph_ACpt$eXZ=;KF+D6xLT}|VmXYt zB&gu~wqKlZ&7cel);O~y>%viKm{Rhs3(mH~NxNM8IfvjxU_VChm03<#rwTM3%4*%K zaL$D+61tR9=o&(kSR1c*cl*<`)r;$cCESlG7j$haXcy}cbJ=XiM;9yaP0STVwqv|} zbQb4X60qvgg0??Qi{2xa?RH+R2Npp>faB)mTnclOeXvt>ru8l~w-5WSX=+M2CnG+z z_SwZMWnT2YX1KaNZ1?rzY{h^>(^RNeH~Z6*KE*iC6V>wZXZxq;ryqZQ*IFIC-E2o| zVZV7WmfEIiJJUDK!+ykrvf}N{cD-8c#zQmoou_F^);dl+muWQ&J@_%^<+2~=JSHAi z12dEG{oO;`_sfM1zHv>%Q;}L@EOW|z+a9J0Bqj0b$*PnZf^9nQjG1CGMAP9gtlE>I zW#(7hMJ^USQB}kc96AKF%jL34DUl83Vb$JTJ)E5M6$#Pqx0`<9SEn5z3By3DL`0!X zbJMhb*^P6tgaF_SYB1Z~e&V`3IZY`q7JW%+oO5VwFjz$MxZ_;)^mMgq=R>@_Ja5|& zW3mPN^To~W&RW}b4I*B>-1n>QV(F(Wi`9^F&2yf{5`z2e<->Z}E{Eo@JKP@*q3>OU zF|(=;oqgEsDg#;MQk}PL>jrYx+U0sNjbk2XEPH2+*3>qg3yWM>m<6zJ``w&d2Os~l z|M|E7;eTt|(|`Ky>%aT{WoyN^eVXH(D;j$3+4(q*UFXPmx#;Th$;tWh+u!@iTd!S$ z*6Zts^*gUW-0fSK_J^_YT_3v5-JK8ZXP?|SYwvIOk1rP2xA$kuel9SNld(Rd5=g3}!HeB?7y+uEP}TGwX^vt= zYfXJ0QmS*#1V9Ayl$*92$J{!qsT{`Wy=_~VbE&y5hIWi;=z?%X@`zG$-ril0yX{+F z`8p$6?@-BGZ!KM2KUnf-=eDGHNGTW_3k-eO+)k?8Gz}3neX9y&F^;)$t}sq{auwBE zVI(rKM2nWCu&DMn_=ckjgn1W7LWF4G?HnA{AwW_Rlp+t#|aQ?f%NQ zg$SYT1k{2tgq5qR5@L*V$+_(p##m5N)mjQ58go=BJFXQGtB8@G*8ixi=#QesKdb)* zw2E45eefb&as~h-ONhpMM6k{nG{#yW(o~EwG0)C8Lx@Brr6bmu2vj(y*!D|BLDGdU2JT1%SmH(Bwv=@xX<8vhb+DmwG%;?Zu})mpvth;@$Hx)!yb z^!-S&d9;j`Z|?31>Ev|XLYdOuksiif%xh(C8e%2^XN+02?O~jnF1+~sg%~RgA+&AZ zwM_>ABJ3A|&@dX{YQPq%n&UJcmaE0rzxK@^|L9LoFCRN=gY!h4^AzV;a<$Gx#lEo> zNd%mML&}aR7;A`>p?W;R%sde&RApl<0tf)qYQY*pJ$AiOz}hTeqymt)6l?W_LWC@h zwZvQjMv*{3Kvk-74n-2P_dr4g)F85gYn?$;YB9zLLSbpGt0Ea$1S~3Zou{ek1|_Ps zG>y+OAwb5`qUCvlWuFoULyD#<5TR*@nloC-Ab?tr3tcE6PDqecs^}3fLqvv^Q2`hbC`zoL)`K1gP1S%E6flMub&OLe zi3kd-2-eC(=nYjC>i`9^h_{B7v633{U_4@B$v_qX3>ko0vM~gXEK=rb$+1dC_Cz9T z4Afc>q(ZTlED-}G5Ks+(1x3X>D~#BPunHPr<(Vt8fHi0>0TiuZkVw7tmZ(w%f+Z3lQlktArZBcv)pUpnM2M`lDURrT%*8n?V70O#W30)QrB*f+ zLSW`pYpvC>VxZo+xfUW65fi*JIT1yw%C2hTy|AR5+Tan836a^i_ORJuu#X-+e);+5 zzHJZVu5UUYTvdrFS~OZPV^YGV35VUrx$yMSrS<;y{&szK@%;5SKK$^5%hS`zRb!}a z+ji*4SPyJ$(}v)I5R$P=vHtm+&%XDA@6FS}HO;VCIb*ujYMi!S!+x5E;17rGayi`G zyga$MT%DZ$?04gF6>z)R6XDN2HB?!uQ5~o8*68hn9mo($;qiP&b7{xkMS^#hsRHzT5F#@eww+YX=?hmFDq6(JvkEu z?|rS6S$xyPI5{Hk-N|~51Vp&ojHu$ffT*fsjpKTBig44J&Fx`%O2|M&w!`gqdivzt zgjO;WHQU>V%cqY;#5k*lyS^C@JGD5Dx$8W0ynOadmG|2_j!BHgf_GOB!?Meq#{Hg| z2qjxrYKb}5Dsf*#a?|yoQR z&d;u|uD<`>?>&F>`8#jD)ioW9eE8w_+jVo&pQIJfhy6z%eE3&+dYiBQ=I{J$Oyg%J z0r=CvMJYMw+%(Pc@3k^B+oNFi7pf3zsPYkcqasYkN~y-#TuN|G5v?)Za#>TUwGg2p zm{LYA#u^2%#`tFN!A()x&Nod!YwW>_rbkkP=v-54kuuj(MMP>fzVpGCQv3B; z(>C2=%{hgpL86qB)`Vmcts$Ip7OsY zcHScrs3HKr$~YhZSZjb#g^eLZ1eGryP=s`hO{l6OsxTX4@Qc?cG_Q6cL5+3CchFj@ zl`9t_g9!7O$l9ZKrPdt0N1|M669SMS1Yu?_wPqv}+P1_9ph)I;j~M5PjH;k2BKgoX zT}MR5xuZLe$Q%ELMfE6_r=vxUjHy+S5V#@&lGdD% z2mz*Xb`}N65|mQAt}k&`c%`^5B`x23U;>6U<>;#xLMkVN5WFFkr}p0W!KmsLAHN%$KjZ_jJ39ZZ+=CAa1@)N)lLQ zZCiu0Ct=6diXGwZUx#L)@nY;;EGmxq>E+gUL2_kBwTh2^=o%xEEuOXH-=w4fA``&6 zt}zDhy>p%sc}uD_F1ePJop;Ct3d~ehiO4b4QfkUMuK>uzMnnJz1Y~X31EAJwpr&A2 zYf6CD#GU|=u-59BYb`2@1nfM1pA*Mys)P=iop+^VMj|4P0TCo;tHzF){pJ&e2!Iik_O_RqA+~)Fd>aX(O15A`_H(CL#{VB54}H8|PrrVDetJ3G z#`%{o*AFk_SMN{Xd^lgG`T072_i~k*fByB;bi3v>)hzS8zCJyV*O$xr22yUzXf@@%;Q! zN(Muf0?OmG5P{aZ=2}&9wP{%$qXWow(RD2)6T=r5x=~= zIJPP_&C@zfm!}W8WGQ97yp*Ez?WU&fZl^gty_~7m<@!o4xWFX~GTc8reEIWV&+~e` z8wk{p(y}lT_}E2PQeJZ@xvr@m_njl0*MbIJ+s^ZP_plodM=)%6oeLBLdlxR_s(?$X zZ;t&^!9fjL6^vt7!TZR-zHi$(m)-8rHcUvqX&=w?@!=lPov%wERlsR3O~bd_vcEeN z!y;BHx!_At@5AoU10n+T!%j+K;=XNPE|*;Dao0=L5W|`zdbg(h`DdTBO;o8S78<^d zvk`VpbaxU$DDC;_}>oQJ=7MfpCw! zdJ!pW8JES1#Kr@1&AI6UAe1E|1CmD~QCQ}Ay}73kKXBiza!wLi{3|B*Z=va zPoEt-(e=}zAs0Bt|L7+VfB84xw0(GdJ_RyDVL&7oeJE8_Am{3RK-FB!JT3da1H!He zS)dpO?@JMt(s$jORw7hH=UXNZHMcR`ZnL2S4sG8dXg_qP>jez@!|?d@+IDf8=EFXY zYt>@0_j9=}Us z>nbU&jQaF^jhykx+ZcevTIxgemL}m;>Z=N9w~TQ*6gD%)x>ldqJW)WW+KW(cY_DywAP_* znn>d{5ktyrs&E@q>q1dX>w37~dFCbMuO3gIKkP%`=jZGFaj#-3vaaj>{eD?%*R@}L z^Qd6n$6epPyj*Lo!_blFG>$Ltzq^e~@XhHu<}65by-f~@eUu7K3?BowOt%7xoO6sW zbWBuLz*JSbJ_0c!fP(krn2CHp#9Ecf-KKTFYnO3x&aX-K$9_q99+zPluH#adl-Aex zUw;=I4Tob0PO<^kWt?N%c70DSKwVVrlRx;O3M}&+qrXk_G^bK)tz{aQ&;+b10#nLw z?hk2QZ zIn(>+D|`3p!@i1CvEcd3Uw-(5AKkaRePo!YscnL)UM}-tM{5$%`h2?m(T_gAOmiw) z1?~<9KpKYFMt-^6?(g=esjh26fY-}>JPxJIt#?Qe1H0IV5Z5Jt`lBD@To1>GQd84* z`@`;hx>(Kc-rcR$4*T}y^>*B~%Q6F)2V)1wSc)DF?KrJn8(&Yi`@_z8f4j^+xUOqb zm1RxG<8V69Myc<-6kl%Ai@s3qI5(YG$u4= z&B)dyA%yEVvO&%{c(<%MuPd?(!Ko>N0T3vd86oj+y0(u+_|~YQiGH+)1T`?-{Lu-( zg+S~G%tWfxS_>1o*wnOc!`h8o&Fr`OU(E=~#n5&=kz?-&Xrth5J>~cHKN98ndVPLo zA5^TQIj4dKQmYzlgQ>E)_$r80sk%;y8Q3|k6^Q^qq@;EA-j`BMjeSh(Oq(^gS;;9j ztr;MqnVK1s1B8#ehbXn!R<3(bNJzBdvLa%tyoGlYsnqZLTmy@3_wg?itzuiY8Zk1V zfk;&|CRUMJO4BrkRCDo;RmHIrm0`F4-KM+NYFe2|MTp3NM5N^G8IgGtF9MqC7BlN> zts!_V+4-Sdw0dSW@QmL}HW1PMCe32o zkdI_vBE+qOq2KuFqsSJBZK_(UImg>Y{5CE(Fo2pf5;F4^dTlByMreSD#NG$rLYnnSRWx^I@xJj6hXQL=aI`+ok~`L}a26!}Et{ z@4aJk%wN2JWnx6o|M&F&qv8aCkpALd{#Sqb-~ZRK>z(t&{Qtd}n3+$PXH^T#v5BYa zZ3sO&B9MK*D=KQ}I84j+_2ncWZ;$tY`2P86UFOsI^ycB+ezzlXf`rcPoqzxGI&__5 z_tn>5=QVx$gHL|==_gIQYhwGwFMsvpAOA_ywk6G;Sp*1bNomP)TNhAe=c?G@c-J(( z<_cEDAch#47=kARavlL);F^nxddCGc7gGXKbB=*2t1uHGc~BJ~1Rw%J0@6+WfrzF6 z5D*p2fSTaZfPvIN0gcch11JG0Vlg4Z&buszRS`g#9pVs(1Xi=gJ5fadHA}Tt)sNVN z^NfhVNN8vTXaLT!f?3fu%UYJ;LSC1qiAD^nj$ILD#|#u41{Vb#g94}#F@ZT}LQq80BRtF2nJ?qfCdO^230j8 z7gMPUph&d+gsTFBsaXUVr5-32D4+lg00=}Nngvl+&=3&7>YBYLFhD>+Lq+e9yd$-$ z;)oF)16LCwtEz;cwN@a%CCxGsp)*(=fthX*5r|;s8Hs@ife1{qAOMk7G*VPmBW5jG zOdWzLP;7!{0|QeuLLg+^ybTOW2#pd+kr+IynIf2?b8O(eH!*Z1B{O?dRV|LafI4C$ zLfdiycuWaU*)cGKs3AmV0V}0QDdGqPz)=hVw!jBb^t>!X3Us5Wdwr$(*dZ>DQcq3}p^K;XL|NF0hemL}{=sZs*MT+{y=QVQ(X`KiO zh^BEGhHhQw-L3~P$9}EJG3UCfYSZ*p&1wlDT(0Nfy>kr$tn<{gU5wtham`s(mSsNP z-K&;4%_-&R{PW9WO3Tm|s>nrqF=IxUM7Jsuvemr+$!t!-QO(Nx>EWA95TyWQ^P{ZoHGthWh(HZ48@ zO4hm**FecdsstCV*O#FX!ui@4?aO@!IcuU&%5LCkN@P4y`v9LkGIoHH#Cy#kAM7=_a8od z{lyo{Tz>Lre|EiHrB>%7fO#LBch39YWAT6bU;NAc@!|aP;kU{={I`Vx{vHOvT7-kM zT2o4lb~|0?<(8J@yjKH8o0j!>JchQZ#hMt^Ff=R`oO7U9C0{SsyL~^7BN|jyLL%pw zIV-Yn2ql#&D$aLk1pxZtpe3n`giZ|G#yM`5EZzgVh8>kGF?w(g4VQU#&c(*3G%sU{ z!56h$5)paN0AyQ8kO2`GsMV?lM3j~ph($6Qs2P|cqVu6?``z(~NHr&Nj*wK<5ZJMb z=5!MCnL{WdT58iZ+YOLQt|`}&!61Zy z9 zH)0X9ib!1%jETh1jEGUxa?YOcI*x7E&*zuJ{W}-ERxvUr0tM9^yB%yX#OPuhLky1G zvP?~gVw9I9S987{_Pt|Lg<5M2z6$sd@MEl-833DYWJ%dJmly%PXCRI-A{Z!$3NjHg zu~Vseoehi-m?*Su2=Sw2uu9FPN+o9RBO=tC4Pe+Goev^K%}i8Geeld|YQ)ZJEhU+X zRN2a-rsz$PpG8;(RNQE0)Rs%G<6(&(`+~u5XR6b2^p4Jg6A}6_G~Huh(MtY z#34o&mA-9D(HLA6a%dc#R3HRG&b6%Jfv~hl} z1%%WxAxTLdnSJX#JI7#@)*C4L&^qtSJd5eFjECJWi@n>&b;%!2>km8o@|4mtEz?9~ zjCHwPPtWK3H~aJJWm)ELzxql=)_E*y=Vaf0xa2kMhEQwH^PKYvp!2enWzsZ{OEz6g zE(&7i(z2}M54!@Km-=MW@zH&a`TRhV)QNqZki#)0L~M~WnDuP z@88@P5kP2yOC4&7+Xa=bg^whfA_`{R+U;= z&BiHpyMA7>R!z%t=(|!g7E#1$F89YBnDt$|lq$7O<9zq<@O)biEuAkb_@FA6(^W+_ z$#72T2S50P&>o*&J?ZV1`i`GYSpcRfH_q?-X2}{O*Hmt|n-YWX?%uo!O?SGj(SfJ( zdb)7{9# z82xUyXGB9)WXO4ccem^MQlxF#QYuKc;G59gZkOBbB1x81#%XS13{7+ntEi|FL9WI` zZPR9vhFp;hfcyQv?VI=Kg~KYsi8a{i;w-+VpVAHChZf4vleCUyv#QklkaoR+Tf zIg>JXU2xHR$EWkOzdLrppUyW?y^Ygxw?hIzOUY^}A5Pby@wpTgYxe_zI2VzTOq}bxmp69z-jko5yiKbmWKq zanO>D-8iSKvU<#;r{M=o0qkCSzceyQzApB z0Kvt6=w4pu-L7kz=wfh9JFjb5ZV2w}y9Xkxxuhap8>@mCjElT|dyIju=PQTs=G|T2 zv`??2V-Lh)P*drfV2rQlNlNwJxe)FSol5qOx!XNH-<)Gd*tYG{`PTRCy4DY;>)ZR` z^)x@7=iq5v^3c1x-2mhe`1zY(G^}mQR@Z5fah>13y(e-xuhWu(??3(I0BUU?r+GQ< zcjL5N=X8JU9uC8Y$IF*re)aaQVd8ndHG#c%@1Mrq(9dfQoE6-@>r_f;<6+-2^EdCG zyDr2wq-9EJ2~GR%{_uP{zd7#uzL}P_YdxqDGpHgUGCO7jAcw@9Q*!J8wN{*_spgq| zUGHA2+i}$`FI%S z@pgZI|McBsB+0-YQEHi&v@AvI^u_=5-~IFd{J)HC|IhyD;ZNSi|Kk@gpT9dIlhh0% zU;XmeheQ82KmFe4M_}9}d1b-Uq4}b7(Tytz1VpmeBKt-U` z0xFMBuYvLOa{2U=yXa_M>kohUE+t`h)o8qosmRcUY7`^Q<0|OqX^f#2ppt9f4N7k4 zn&5a%T1tI>y~Y^cy?yiH>AcQ!-?cvY)9E5ra;bPxn!dhF z$7A1kVxsG9TF0pr2>}s#ye)@a$4tzge7w7Vcsz~kG_F|)X<3%H5Buw!-aZUzn%O}N zP20Dx=iBS^`1b8kss`_;MSk%4+h2YC{6{}}^Rq9$b4Vc&lY9H_I1JtU_h(}K(GTC8 zFY~bP`ZmVkiwISn)_l3%PN(a`u`gBozP;Vjyq0AyV5#leCFPvz>t#6}`i*wFO>(6a zF|9dq@I=lCYF>#sr|d%j12tIJd7fraS=a2_$jrCX3o<(LY9=)!l4{+Y_Yr{DxzGS2 z8JGz%1E?7gk^QFrC+4ObV4IvH)|7n=glqsCCuy7cG81m|dbL``d)`<|w3$$=s!E7K zRh?sIUveU5WF+Fe%&}?A@OuEju?NHr006{VvZ)f{Zvg-zGZU$Q4*>Y+bWiBFW@gKq z`!@vu*m+g`=Ih6YH}~HQ=zl)|01?@RjRybw0RWEK3>1;^9|HjRUk3p2?*Ra?`RwEO z06=gK2muU%YR-VjM4|#BrlM+ufJDSDgeEkR0F6*sj+e2z5jNc)1Uq1PpXK41tc=Nj-w0VaM-0~EK5pSYbrnb?6c;u z4;0Wb01CNzUQ$_O+tjLe4-eP#`QgpGU5tDVP+V;RR zsF_3DINgTm5sN81M*yNi=oLiqW7lk^3^5qW}Q0^c zS_%<4P*rP!&uUIo3Be2vfyj_h)quevDgr85olTTFo4@19S-H904#W0JCTYRIoKwheX~Z>RPQOXJm?m z1O#A$YE=}Gz(~em1OzAmzACX(gFwWN3&Q47mBk1Yw!i|$l9OXc2;^KF zqY-)UylSoDy$iv41Jde3sJWCP4vi5^Z7EXHTB=1-{0SV@{3>m^s^s)o|kk!kAL=) zKYl$udkR1Kr+>5W6b7cP6mtU4* z!(sRNC!ge8+9qbLAq4)Nk8{pBx6ad+c8=dGwoIGYn^-e+gq-p+US6ASAm>99v}(@l zJfGQjTo z_vC2f42vj%%S&q77-N@8jv*4eT5~(>N|F6=Bqjx|HEXSX-@iOPQ4{*u0$CLaE>mpV zWFD8>_4!hy{)@l(7eD{`&r_O1h_pq`I!F9_F8;HB?>`JN?2iw-5Dxs=6-4G5Fv;aR^QfP|e4Psv^at0=klBDPpEfTOO~eDk35C#x?k;4-gqI z=ka#w`u)d>f*c_cyR96pqQr<`s=!QJsq35Odyh^;Gy_mI00boZScjPjf+0IZWOgcI zS`8|@09x5O@=isG2n|AvF17%&PIHLf`;bybLNVFGQ%kA7X$aXf85tTiZ7TvLRgo%1 z%p|XqnmQ(CkB+?a-QnPUG}C3Ca!O5XH`f{kbv`)faih|x)>=$#t0_QDRDLU{MCyhi z_CsFM<@D6`I|M9w4Iz?q-h0)JRX|{%B1r69#56%a4Y$B#$pfzVe+X`n!gpJ$qQI0?+iUi&T-n@ok!%>i;CnFakG9iknkZ12h zDaF7%F){|PL}X^j&VM95V4kjd zS*%neGGpgCg!p>7SQTPe=S6B6Zx;l+jjLlOA8J_%Av(@tT8bGJS!xkb;~3fy{_wtk zI!`s9eY3xv&TSVMkl2Y(<)|v!kv!vQKff-X;73|I1H$`N(-#=g1H*eltE|-VnfT+j2!{zm5Dc1LWRqeZ> zs4%nE(jN{0qKFQBx7(4U4HR?~YN=qUR9V*)gHz{IDypIivD-NpL9A^WHJF!mf7s2_ z656(J8WnPZe*LSj4t-n7N{DUrua6(*+bCrc^raR=uBBA1TJr1TV?h1-oA>9_s9MvS z&A_VqE-Y)!IlrDJGWz!Ys|xLQoz&b#S5@2C^g~BJ_WQ%-R!Xg>%W}7G0U?IK!Hr41 zqhEdf5}W4ke*fV#9}htVB_-!@&SYwG?e5^>PPw^Vm#+1(q3B}~T(flhexApa;pzOWRobSR=B#Rjn5#5xH_dAmL6CJE z*DY6({Dj5vKJ1&;2#g@- zvODfl(UR(6zbiS-bGdtSxZc(^mHmDwYYH*;eRsah-aFSc>%54nR((F5q!i!yWvxvN zHOuKX-tYUA>QWK|#lEep80xg7b(#C7We(%AG%+mW%{xkKKHePzGZB;X)0FP-dqge< z!37{isUoJ5=IN#iMGQ;^0hc(VD~@IwT?l-?m8H zv`ya+w57PnCX>VC{ysEOvYM8m@u?Ow^o%h!ZPU#uee><*yUVm|@Y6&4*B|Pietz5q zvluT+Ue-LczKWEpKF00MXoQ!`ZP&+Cm54+X5yYTv8Z#y1X--W!Q^R!MQI}YC8 z#*rPUN=jvacXyj|T9=$taBkQiyl)zBc`o;F?rzuf^)lYw?QipXIP}Z1jF+mpZ}u^|%XPesb1BGR_xHP(%bY9h`XG{1)>@@$n&ZAb z?DtRSYZ02~34tm)WvYQ}5%Z|G(^XA?y(p9{ z=W(%W&G|8wh4H5 zx4T@|wh4r^KgKVi&KoLhKqhFS&2qz`UgOe7a~&`-l5n zt>3k`ac!Jakd$f_Q^BRKC08a(%edsitjoB(zC5$kl$UpCxH()Ce{PnY%WefRSIL$f>d`{Apv9}h!U3S^9>q~Q6m z-)UWM*QruhMf%`XZ8tQh+sc^4Fa}?0z1`MsXl~Q(*T4Mw^2NXU!~ftvyFd0n{q=Jy z>LUNm&%P-swT(|}?)uI}diSvZ`rFsf-W}%kHZQ{Lj(5jt9QSQl$6L<1^Y-$5F~B*) zn|H@U-#ni#!SgyTcZW_zhW*gCU2NK4ee=|HO^BflAv6I^e77Ix`u5HJhYuG++YjC8 z_4e@g?&;;)Ha?Y{Rv~ha&ldxDxZA0~IHk{j_{rP1cYyfKw@-|8JoGu0`}^I8$J3|p z9;(!3Eq&L2czit!4VuN^*Ln1w37{Xkem|s~uh-?_u2+MX^VoLn^UHPDH%~8@hU@io z`uy|Ho?mW1`q4wG8e=S}y6Cj%%j;=3^mlhXkqtxt?c>FJzP~%(rg>V@>uLPaXK%-} zo=(&KeZQ{de4W}h&bj7!?YpRI*IU|j)hXx8b-KUX69O}q3Tc)7q0y@SzHOR5*P5mg z(Czo_>+57_^Rfibrluy&M@Md(2&h18np(BgqSZ_ktxnS%qX)vKZMG(*-yPWpGudPW z>^$IaZLtxFou_Tojs`?X+cyF;=8u|H1X!1OYcp#p^Vfe;OikpFD}0NoDfcK`tI zgCQWowv8%^$jF4G>==Q!enyC%_fDX;H z@y*NglL-LO;c)mTfB0i4t07>F)9vzdy_o3zFwn<2I2zh;yxZ-1FaiXR7|31cOJ0)Z zTGifv`}O;$)7`GmwX*lW{Pj1g^5=j4?_92@yZxP!>liQBvziu>&@=$-J)d7rT@zBC zK`eL@w2uzJM8RVfWdI|zER3L1y=TV+o()Mw8Boy-z&ZLpnL&;9H#@aS%!`7j?dVYq z0jmKTkb)>6A)vsDY6htYA-2p501>lD7Taj&p=nLEcTR{p9~BG z5IM(WRteC65tdT>u8~sAz_+oCbLfXsB*tJ!ma>R!V1;7<1$5|~lTw|FN>B_WFW&p2 z22u^xIlmcFDJUuc7y%fOsyVY<>k8@+(GdbvQ-bZsNNC1HMX?%~fdhx+(9l#ov8h%7 z1w%wNWJ6;!0|GPj2 zF2ZIBh1mG`;rS`&q-wi+Z;KN$VIM09jhd(;DeL+*^=$fbV>&x@=ySH!tufO`6^yN! zbzYYt_Uv4(f}kHwPz(^v2YmeQIkYVzl)9K{w`*%ofHee{vUukZt!bhmlHv2^Ok}~) z`SlikEIIf6{`7h|9Q&LlgeI_mJ-u!keD-l(R;i)}p$(n`sSLYgU`nE(>v&7M{Q*FI z3{uNFu6fN{rg#$0pd22kA{-|UYM=a)zOP14iv2m<~MU;z9c0{|v4ioOfJ>>Wt5)m#mb@oNc}bwc%-8e96J5_2W_H0N z`KsE+Kx*Ud*7ieM*Ty$KcEC8^rY5kOt2O%&L<|j3#Z1YC-~$-2<3KKW7u!&BW`dM! zE)@+z8$d0k>OugOw61AgnR!D=2no=b-9||uawV;%T5B~>CTCiJ*gLNxIj@eLApnr~ z4iHUE)f_u8Ffzw(LkqT@)LLs5L@haiDLW4YVCaG;BvCD;Fp-pu#LhE2$IgSA3$A2A zLg#&26S0pW0%KlQQwx4eyEQN@B8-RtRnQC_shJ@{m9pFI3{*b~D#-^2A6;l1BW=k@ zO>Em?C#AR$2sh>p>u;Tl6cJU#01yn2REw(Ab*WMrsnlvxrDWf9%XHg#H|(N;7@(9| zWM%SZM#SvBX+LP@<)-nMr|&Sd(|A@jB9EvhB{(ca**j#{G@U~-0MVLL^4=3UGxbfw z$Ur2yn2Hg37em`1ld3YgkGlb&wIGsj8XqGep`n(N(?TEVHd`I$ybn@xPPyhx#2YJW zdvYVQSp~CNs`tS;m)8|kh{-^~KqYUP)ILTcPtH}Tj8?=Dm=M-E=k*FENWMrG0Wx6c zHVjK8BS1AVLnsB9te7$0u5-z$l*|;FL6ywF6Xl{laIJz4OiWdg;dWi^{~_(YcBSpo z^{gk1^oB}v&M*C`+p95_Wedp&WFgR!Wk8$+oB}6=*#mYEI|#uMn79MB9J;lq)GcHVVa1VL+)-Ns+8v-ReupT8V-NweQ3E za;+6=EjcG(oTk`yem9J1o|@3Rw-1kxPlnN3RzhIooT;&z&N<(Uh;eQ@ofMt>KhyvF z$48Vz4pB~pMW4ty=Y$-3XL1M=W5iI*A?HI*NlqbzIm{tBv&mtGIV74GQ?UFq? z^wwXa`&J0dUO{~bxw6CF5A}z{cqe^b?ky{IAmdy~Ck|I!J)QIckF2TuY%Iz1WTcaR z${pG?&HuWXC~_L^?lYLh+Dt;&m0S(z_+BB8Pa;-2&&NKC>ul`#FOj<dzOaR&a9>g{^LYyz!w_Gs)fKC>Nfy@Cz%1rE_l$%9_v&d~$9> ziZAnN;f305<1(LiAafurvubjpIiY>P?Ihae*6dHUCP&Wbk^-ouU9R&W-=GV#u4)`?LEGy5AYwlg+Q?j=gaz# z?}u~j-S>j@>eM;%Se|3dvIN3(CQ3)S0?0*-JU_6dt^*rdzej%lCDbt-_a)Tr=6Nd3 z=psc!l%6@%Aax#h9HjfEnY-)u+KNNQGWlBz+hoDWd(i}~cUt(uoFL2L@FP~-M0hb; zQ>bosOdHiKUXUG>H|HO$Q#LeaIH)}IDwu0x%FTJUW3}KYjE8WbU}No5CkmQg(U4NC!W87h+aEQ;iWwjAuZFU(!X`-2;IXWGykI_J%>>q6Z4O(SC`l~I;g7B`p9>ERbbParC8f`uZZidr0+|%IS z{C^L*`PQQ_>tC+ga=8_fC`>LRKQSs2WM@iMY_oS_%CAx%ZBJ62!dy4m{wM^V}MEql8FwV|CXP+uCm5am%9_yt4)WSc{}bkxy-F(m!B2j zQm5f0E;!w-%B6+q_z)d`ZEpHZEsT?9Zn;n+i-@yF{SgMrB$PKA9};u2z4di3*2Q+= z3|KI}`x})}m~nJKBJlefY!5MJcBJ=}K4~B(a(T8$q&mL4(;MNi-ygeweV50k3u-Yh z$ItB!8QrU+vW!D?WOX5!0y@+S#vXeZ_nw}_Qu%a*0PvG4I{eH{u|yzbwDdX@{9QRc??u(*fAnn&v77zIy|wg z?dc8ACi3CMr2ce!{#-}T`s0gc-6%JH20>qhe;&y<_Ybt_{1v-R2+@$IiGhFZU>B?$ zcZ+!i^(AWpFA%BA2df8BQNUcgr{Pm|zoVfkbKQg98N_K4LfLKV3>5`C9j#-5xwlYE zmI`q(75z;h9PDpV3;s0VVibA#6<4>^c4AyPL1@j85;s(+L=WHbK}24C)g;6z`!3JS zuPDbtuum7V>BHiCaXWM8mAS=o?pm=XY8A+q6%Saldbr3)-Xnf_KfPVrL;{12mC4da;tTc7zrqNl`u%^uZa!ExaAc<|WG zoH*vj27=F3?u~VKel* zEIri`=7*3I*qn>KkPs8qnf~ITwNQz>-j$k1yiT!4@0kZjwsn5E%Rw2EvB&D^M@yvT zXsC;UL{k6J->r^?z4DIPOpf)fW!+sDNaV??!bI%O5pA!`s_FcIWbDb-810r33qJj? z*dX$muCl?=Upq26)W7d?>FeP1oeh<+64**0O;u%cE|N_uRmHCXlaS|brv7nVJAETXoz2^EOeMWj{e=+1OjtZV__Poj z!C)XBdtLWNb$+vl)Fl+ah=B*&46BNrijIzAp zZ%nid{=u9lW|1 zI^U-kyFWlb9`+BP>Wf;69wM{bpcGMC%OvGF6*VWrFOXp3=t^}|4YKD*>n5O4_-lcf z5${{v?d8cCJNXNkxM6_Qz@RHH;OLS#Kx^U1o}*6`Fv!Dg(JMcZ@(bDX2?eo*uPMIq zX!HgLS;n~me(>rf43gDrBQ2#ASL!t;?HBD=-+T3}PI2&OfCRjWT?Ou$I#oamkwOKZmqp@gVRIic?{H+JJoBnCEDN%5 z-^K&29v!n2B-@YftH2|%p$T$PO2}JVYqfmd6N3|~0aw4yP~35D`Zc3}gl};GLm8Q+ ze<#NVCw#=4PJ2yAzmC-<3nxWSNd7^zybVG_W0KWMJlpxh1~^w(vTWs=X>k0P5UbVu zjJY1#>EloCjD)~%n=7w)+u8Q$NEQtaJdSc9LzVK@N>zuhx}%=MWx&?8&6O0dy6 z0Iw73W8%fc;R`tlcJVoBDjLG4@0h?G;5UGkwK@;I*}prH#pTa@7L^~AGP+0ZK-z0o z(~bP9(#~fF5MEh))2+weHIO!Za~fYjR%?A=3R~ypJ)KhjfhSSsi#1n4rI0bcVzlnL zCXoBHFn~WDs5+6MSpDQhLw)-CwNE$d+jPYwO-0L}f1!+>VgnKq>o+yNCDd1>b8y|O z0MDYr*i%FrRNkaXy-fj3P#i+4VDaL9W7;(+0X5+Fi+5AMikJYb!cfzWHvpI2O*dJ@T~qP+*6#oay!0OU z22fR}V)o~`=YrNI*3XlENW20x;M=s@;|BpUIRX;wZ|9GRymHsi$z9cMNxROT$bSDz z(N<=FTanYFH=otmU>T15pJ%Qaa?J;UWjJko<#}_bwBe)>*w zpB28`Gpj^v+{{_mW1B1jSBWRF0)Z{5Fv#C8uLtJlJ2SKLJ%<^-8MBgMWd{06vR9vo zu=D3FFYDH5;2#Fe$G6eCeZ!fAt$!P=bd_Y_WW2h{#eOm7@e=b#3D(kymOSR)da!!L zT=zHd$A0eB(6A#(uu4k=r6)2x09j0}t1d8a)S3LdlUw9t7Bdwk-n|p2*YD(7d8MqZ zq?H&-E-?7FSmu{J7OH!~;>DD?STc|F6O~xklu+z!%)x%YF5E(@LjEJZOUcl$DpfEY zc7iitHk(~ZLdi!^g@ag*9MyhN^|TZjya+sUYRwJ<#*mM;7fEw-`slBYZzy(m8bg5z zPmDy&M|@TGS##fsk%ps~^slE&n}W4Ml15dwtL)tGhV|}oKSG7iS9NPs%>15kZEDh_ z(?0mxnHz-7@78CLtH{3h|NG!!;qst$K0hVW84p!tF2KkvyIg|LSR*$!+I6@eTpVHrwgA~GOQ|4%w$6I>f>i*LM(?x zhsYvQIpQndCqfF54;rOxnkc3wymI%7(YC1qg-dFe!xDMMacDK7Z z81Po38Q)0w4$&CIYMzl|bvEJi;R9X-vcMhq`bv4bJt`0=%;E3HmVGzGT>W2g!{w9- z2E{G@wx&yl9V0@Z~%3dmKsXefFTViQNsKl#sf&iNM}8P=6_NXhqJ|>O#PEB*J!t? z9PD5X!tIJ-Exv4?g|FhJ?kUMWq5HZm9dRP8P*=5p@E7cwZ_(!vENuauKLL{c$S0|PYrHJ>K&Se<4k(Zq%6si?r?S5(&?P{abi#*SqV_La#%nZ!UBZ4{;qObw+$UpFFlKhEgpnBl3mg>>#6`M1n=0wL8B;S7pCN z-(17l47bc};Jqz@3BHZ3AarYWopa5nGl=~5U(UgyN#n|wjJplioKVHIAjsedIBK&@V}E}o$iC;1;67%Ehc6dK~2r*aq+TS`>)2Z{>z>|;^Pw( zRRa_IbOIu$u|3z`nm7THS51B-5CMgOUU}k_xnP)^(?qpJQVY(t zIxIO$2Hi)kY-}Fx(6GeL?}JXxWbeXivWZ&KkGAK$N-W9^XEyx)Y@n9^p{EjYNeuow z;d=EBBzRgfj7sCFIL%f_wp%LFO~%Sj&?M-4#R&5@UrASVe@?z<@6uv(P-L;v>WTNN~Q@TV_(;j>$l4N%3Xp2pI@UHKCuE%->6n1xecMLsG% zS$c7)Cq_5Ma;Ij`RWpXdw@4r?hxGpYf3H@l7L3}B=|5iNt2yd@HuYK=0l(kL(C2uD zy$nkybph4HXIXUCBbEFaeSIs~d#Y#8LVDug?daZxuqFP|OhQwiL8V5xbH?6it#=_} zQmnmXxC)Ax;w#~M`z=VvYT!5T?3ma7_Uf809BDyIt4)50n-421%M5f$%DDPtZczzw z7@?bOL=45P6UWbqU%4BuuPjG7@-IN-25sTR@TAZ#+$<&O!?lp5_p@S4xcM`W#~Etd z{t_QoyE$IzxRg&Gxy|yd_SLk&Qo$YO93$ z6Y6+nch)UfWKUe6{~{u^F#r4BJN`T%Ln7F6;E~gSTS!UZJjrV|BPP5PO^zIwI4$0N zTVmJBwX_Gj@Yjy5?>TYptYF&Pk&5E49o&=hte%_@BO;Gb? za&K&GoHv0f#00!nR%R?8ZiSyvwBl$6vwKjuV#JA7Y|P&59#xA4oeH1TsD?;aX>e#J zNrqhpDx0M*YBlZE9zI<#DDzq9bmRIU(S5YtLJTggX3%hMw~|6#;tuv3XXf>Nc?r5> zz|LSxkP=v_;TJ??i^})9FX~xDr!%ZRZbxe&F0$MHeOXz}dbRPdA?i{nn$f)$UQB7) ztywbR32?c*vB5WbjS}74IJ@o;%%U#E9v)l}R5m}@X>wupw4QzIg^@QCk--KbNwxHU z)Eb6Xz(x|$@o^k;c7fHFXSLu91im_O=O+gOLi&>I&cQ4=$vkVe)%QyV_2a0Pd? zzZ|KS6uZCiqvu9dZ`Xnv=|IomJH1g=(m*fraX9mMJT~f3JZ_yC>6ji0ZyXIN8KJT? z*|d}0vTl9XmG!A*o8qmV(d`{1BPebR|sL>anCR-2yGUth-(M z+&^QY?QYAUZ+i1!7P*l38NAv%Xr4&=)uU{B*sJC1KOue731%x~xIN!a=6TZ=eeSE% z0nE2vJ`5(u zhgc<gJ zNo^X}>^-vWgLh94J9we1J}4f&`_YZUXg@yKZ9mOtoyv+su|PA#5*jdbKbXCH*fVd) ziI?9RflPh!>=`Y9w~TfC+3&e-`2{_iIDhaJ5=m?W%o^%v%v zT|3$5!q=i!2beWRT?DVcZ!OL)SZrX)F6BUjr4=_fp)mH4kwM>{roVXyAxwoLF7*fe z>><6zNwdWRiStgz&aZOYG$+X%Y!pwI{Hp4Z3t%Stj8V(R!=8T!$*|3pz42kSH}((q z3ExiQ&>Wj($Cpl)7fvKk;Nl;7A2)0wF2_3+iBHY&(G8r2@Gl|cK1NNPykWivl!c!N zDXe+zs(-RViL+q{QcN;YvI1=7v0VKxzeDPVMSp&Y+uuK)4X3woolZ1=xwHHwHv=;;`OXdWk2_J#9uJBGPY3+C0yY%pm;0o1wH`c} z{Q&;AC`AE~W_K!y=L03A?<23mJNXHTRsb7~_fKXDyy5gq(U;Z$p5KilDd$z|Atrb2 zP$R#DZdHf9+sUZ~`Ao*!8{g&FUU7Q`y!!4=d(wxe!s~z=_3CT{i$`PGY^yuS)=k4M<5Ptmd1ZdhhyB$ZU(2!1<0X(f(!O4CMq+Tkbo| zztDy{t)?RHZhWe|@^d4=Lm=D1q`={hIUFpeDkVy&Zco6se8?zhyl0Vk_IWwC4~jd@ zkjp`c9fr&HVB-HCKW#X74>&yC#qc^ zd{0t&r44gODPHo#U;ChSr$x+ULFd(XevH{E0Yi5+Zd37E;3kCBKFgJYt!7DX(uwwG z@8t29=cc8nJncmCypeB%5Gm%FRiH5)b3fIpqu6JCb0}KW)H-=}t$RIrowU`wlJDL^ zRwj93aj?fml(*`zf9kI7OCq+1iw_M%uGPhpZxI}2hV~iE*Yf~@8;fDB4T^D*QD!=Q zkvnO;0%oUd;kQdlp>+RfkoU_e2<1)SXlcgdrHn0nQtqV#`Ad{*7&C918rmmqtY|w1 z6RG=bVW&7lEB2Z8TKg#hDR*bY(c+`@%UaJSiXU*kJ;!Zry92G6vJ>FAvav@zZGH4_ zE2chm_+*>Jl(1zD9mi%iR}ruA3>AMia8ad(W_HfXSeQCK>XL~GM)Yyj9Rq)NBo2Kt zK#!9MH&&U`wHgS6r8^030)XQGJw^lT6ZlXAhx1FVyxcyGA`V#tRO5C@O7ut7g%^>Dj zC?Sq{s3_&4tjrp(M(%CkJWI%t(gcj>BN?E2+bBHqWs2RlD|2(<_|{3PXQM@crr~|n z7z~@8NjsCdzPR{W^Fv=e=i$Q{0QM5{_0U@eK~HjH7jy5o@vyK7MK)V?@ChJzINgDB zswK^TNC3h)$-mZu=N}CzeDM-ed|em*GT`BD?xl;V!k9`QlwW;9+gzr3qt?v7B6-z2 za7L)$H-hJGCM#gYp`NHi)wp%0(%NTK$E<-^Ui%9;P;LAv7xL8dZ53vJ{#|`2Pd$c9 z$`PJoLE)3dy7kF^uxV+(8`97mgu<+F#REQLH!g^~zq2rr{~{UgkCI)nhiAesc*6ZB zAx}o~QK23RY*K1cpc{!%?l@)U2;{6isM$Pf(Ck;ZQ)T%|#q=}Ok1O;Tf8AvY~o&;pMTxHn#JCBZEdQc960(O4q(#OQ`Xq3VRQop3!wQmOZ+26wqO?7JIzO zSyYM40Qt5M;g{}1$cQENsPwvjD-Q!0>e2-_{EWVKrp97!kTlx7dgNsUFZmm$V%Ve26_-GGqq6`P7f;q z>MS8br_uwV-2*Rx@HHhT!AJ+R7u7o-ct-D#8`CMUc zgcRKoXD@L@qZvH!MF-R@=zV&xONND&5wG@ELM)SUJ@iA>%_WAgP#J6bhokpC0Gn`+ zc2Q>R6E z`XgZmlFCfKGxC8MEHW!$wW}J!O1a^Ia@~70@LPfHAh$KtzZcEKSx6cQ>-dI`WTnk7 zWDsOGc41Uz!5{wxL@u4aE3N%xqHPC;2wD$M4$TOkb>V$=&!8jlmc(lkEqpKKm%=T0 z186gUm<+jG{9|mV%Y_I}n&BXc!CgdT<+LBC@ZQ6XddF$sZw{HyO`Gj^RU*tCksXle z8}dMI?l*5E9YIQ?)=rGM0=O*jn{$38V19bSLjt=Ou(0f${lSpAd3?zu)0`XXK=JK? z849r(lS2O_$QrhzQ&;Sbxh{SQB}V>tPiYFNmXMEx5cRh|{Asi`F}4eC)M2w$@@t(A zSqdwq#cfjhR$nj~<0QU-u#=-WhU?K-+zDO3l+t(ddfq93uUKWAFo46=EMd5JVI3~$ z{#$@X8)aq6I)5hhmGs}Fp?OzoXhs!?wR&@l9{rv|nC{rze19o#;@9$Or=*_K!r&*n zU0i8Zm9_;*EWw~pFK?p!Q?F!tvkv0u*uT(II$j3=Asl*a3!;QEF4Kak0O_(kmFeuYc4_E%M82(=Q+KSRh_Lm$w^2lB*UzbyoI zA$qABXW4x2+O-nfZWn~-SjkN)Ljf2QP-;b?Fvl3nMclC`V>Cu?sWPc(S*>aS%976* zo^!lJM&*w&YnL)G&7ROwFBdH zI_4H3r4(7PWEYLV(k#8#lfH_cGQ{;i6!roR{$Oc>e|L9SY9wh+KX)P%A-k_qrRxeq zjqQb9XaofCC9`h6bb1nQ?05HU08?c|M?|$$L3tQ1p&Os;K z{jHF$HNJ4Aj*ef*Ais42L&z6Kkh^-*a$LC%tcE(s6 zR;&LO8G#v$9lf}dFlItCO>+v@r9J-2bT$cs9Axx(a zF$XSYi@N>3?9JSmWfqZE)u4!f8#`}*MRlQppWX|8W{?X!k4^mrq3>h6s^$y?yfH`)hz8T%%3bR#3Et63%gcUuT}GKM_je| zf`Xrnz$=G~$L|leLwXE+WA~_K!Ttu(%=hTkrs$K+#U(^CbBxJ1l=G+SS~ke0x?p2t z&s(mBG-;D+7JUf>e!RZ4b@=DlupGMi+G-rSIqFsVKY`Ul7sxXm6d|W4*!7As^u2zB zwVNi?-%hSqgi3laI}#i@9Wl^;6Wi_w;^Un@&%8(V{PSP!%4=o4g}D^~FP z2hk9sturhtw$$*YA!>2_^?&d{GtTGHn<=^GmYx1XY=t1DfiD`_$e?uDkbaR7RVDbJ zg#Qh|N1^Y@)3erRZW3)J`osX%X^B6A;IelwMROhLx;7yQ{&AacnXjNf#kKXDf<=-H z!~j5G$eY#_cjEDBGii3IFV|3MAID}M!T7B!)7USVHK20Qw0Mh#Pfqs2Fl24zH+*vg zs`q4niu0Kcv_^I(M%xAbmR?YBwmOnCtA-S099>2v6*-L-1+D4^AYEagikY?*9+OUx z@EhCGYHejXZRdCC#TnP52=!?*mP1QlB8}u_Z&XOb(iJfY<$U?5@Jy3b0HuRJ3xMmT zC-;lJ19aBPXSG(mAJhxcugPJ(kLisZ&ug^qo7!VH1P=HcgXQq@e-yFx5F~7qX52A>P-gJI0TV&++i$z{e;CPQwVf0Ax%lYcC)ktKzH>3*vx0{Eg!2IQ zeg?ywlAN6Uuy`!XJ#fA!Dni9q+y+EIAP@^jZ{lX`j(;)f9Btp+(=lt=znAxaHtx-- zxR%y<@B07fI^GzM?GufH{XR-|T?y47a~KR3kY#t5Hpg&Sk{Szn&0{8ZN=Y^0M`%&| ztRlP1xN`BBrV1ioi z$6G2*$X2sIFx#`RD-eFxpDSvq;Ca0lJ9q7e zbgsq$(199ka9e1sv?^xmDj( z08&z#N0aQbg?$=0coI*iKHxCpk8+o4i8n23{SGn~0(exXeNIbxlKKTG?ZIiMK3b(2 zkj^h4Cs3c2pxyP!u%F+)T%kpk=ZSkmt$QI0UI>OEQ_2m&)=wIXY=n&NnwShYv++FP z3`tKMOrJ0`l(?xsTrEC2>?G3McA%OrQN?T zg}END>G#n@=OLAs?V`2RiiByoT&-JjqWpt?;Jud$6QahWIyDtO0=B3x-y+Rx4eiYR zfHuKgF5p|{972sw2+p@}n}I+JJI<_<=Fyp4_{d2RA&Ma?$XoAZn-m zoMHEze+iwek#CP5d)kLP^KHbL2b#L=xzU;veLEpb5K3_$MFZ{v>T zlz?+=fNM&ZCY>%WzP`%lS`r^OeYzHfL6Y82mo_oHew!2){wy+nYI2V#de>L6I@eYs zA1+^+AVn*3zb_{Xwr;lx?OR`oRGY7p5_ca&wgg`JlA9ARA&CFhd$hwBXwe%?Lq7lg z@1I?zHqHFy=_lF6_fQ%a&mKK0(J66}QjRRKo>e#XQ}f4>2w(YgJK7;-um2}Ag35Yg zkQ523k`X9GfZ6tDALIt7t?AX*Ru}~nvGNHC_bMzZ>*W9N{&!kyUwK}_*U&p}3IGsi z|7sI-!_;ibK}cBG@WGu&9v}IcSQ%5N); zW}QDCih1Cm=chy-u>%3VRU&X0aY_5QFSo~R+;=v=R3pu?Q7x@$=2=1 zR%57M?slhG(u_}QuAKiOyBp*pN`_>)(7k7eJ5H;$*J)6FGT2;_?`wXqwfRs0q6$mj zi@6dH&*d;_seSU`K_Fg?&VQCmmfEId+Ty8+2CfL^1g7KJxw4w`4cVFw*sgB|02;{I z?(#mGTpGW)F*xG$vRT3w>1K=Q2FU8O@%;Y^?EOM%{B7{KMR@aEm2eZ?2D!ni zIT&I{jl4ZoS=WQHYTdHCOGhfB7gc|K(;zxFRS*L?)(_XIHScZ$KFj_`xMq@S8a-KF zdmS>A69f&Hd(08!YgmZkzglaSgOGIyfZbDF(O6b^Kc{K4y*s(yl{->MMc6Jx3UhuS zMEdJVDg}FLSAE8d!`pFV$;!%5DqphbbC{(Cj4C^caY{(2M$;8kXX@eg^?^EO+3_~W zJx6cc^nUy8%Y1U9F@4ZCdfky=qju~=+|o7byQ%Bde}M2{(^?hWUWly;AU~b^5fAVh=Th`6M$T-c*}rJ4`e5PYfUhn$Zf9}ZYvJhsNh>ZV zM+Wc)A7{cG+NovxqLM8VHq&N7w7KOdUaq=`qFX;`nFcyIT}RcNPWEOL(5=JFm3-J z;x|N+oYne`Omtj{RB&6YACdd-f!$fvYLT-Ra}<{7X0>!YsWp#X;}K+Y zwp)^RCNsxt2xHYWEvRi_FKV|qth5ytnm<)AqT>!zl>FbS_}=0YBaCEWo8nk4EBdOq z_w+Bu`&@pO3fq=%u^{!s!c_}%_5t^u^iT12nJ%S66*(;quMnyVjCj*81xM>)g_Po1 z7ci^WCvqE_y;QtF+xc4@><&lWyt}phbZWtuHyfJ~;LB!jt7Gnq4Ay&n1K=ATGwNu% z5~-1|_y&_%5F2&k%Nv?;qbmCLeK;tel?l2&cg-{6Xl3_c)$qD(?!y4r*TEf~bLmSC zkpyC;Nb!hM#d{^ULO-ZRs0OOezn=Vf0uKfNgou+d zamByU9sAW6r5uM?;BA+_1AC3|47RG=D(~AVy2(`1pkZ%&a#PvDd^kPsaCOn@gqHQ; zZBoIN-AUINy@jwO!~Dot=1PAQb0;!_vC>Y%1tMP$Jk?ho^9m-}gO`Kve|ASf@t?}u zh!vpGg9DXsm_2eFb9a|Ou|*D%_`{fE>Yt9#tMaqkisH;2T7RVLLv;O-d~et;_t*1g z`f>lZ58W6K4fN1*r;I533>5=CUtG0M*9MhuTu#CJ^8CquEJbUeBS|Ezcq2qF!07_z z;3!$ySNne{I`eb>nlZ_z^^gBL*qoJK3!jVa8?LaM5K3!}zLGyyt$%(iqB}Z9x36=- zGT4EvlF6v433fUtGw4m!(1r24xp=vsr_F?qb**?>1oZXXzCt8O%%F|b`c4jL*nr(} zWn-u5z)UQ2oeoHJCk$AL$1B{^UnCTg*`_PvFhZ9PV^FuXl-W`PT|Iz zh9WDEdK!xH4({$PDo8x(AR5&ccNjGCwp(I+A@1aGi#8ple+3`lGIt+tEero~pba5d zjKS}dtx5KLe6x(e-&+4)==u&ec9><7u08WNXQ_yDPPVuDlB`X}5iG0uEXmsu5!x4k z49zya!TfG&wIBFKMdM<6sWz$=i27uW=k5rs|+E3b~nNm z?nh}ODW11^gO?jdioJ*Pt}3db`<={XI4%N)0<(di?Xys=-Wk$f^nYT(PU6&m5suhd zFDTGymzXl5i_$TnTPPK^e8U72)ojvbS&m|Nyv;V{dys(9h|bG`=w(`$rDL5CTdn-- z`xQYJUzc-U<<{>2vOw1+3qA@X;iH&aIp%V#2%KCPdr~j!JR(f0uJcEj#~n4rt{$!| zxv>Jy=Z{{yDp!4u+x_3dr+<=V$0sv@+M5MKVlDfrG+~(+#9xqJkj|2sL zEB#Wy+E$QE9uCJuEJ-8OG6r1#9k>F5v8(ev&n|tGcl6&2PqWv!^nmTFNDOv1^fDQ| z{6}*BBpSN_wkWnyBP$2r(?K!16bNCsPF&}(_j8324pYGL{=Nf$<@Ivk8EAgOJ!0hJ zk`!&KNt)Y8IXoQ`>ezqlO|Tas-j2&`QndG4TI){@P6dFGO#OY2!Z$v5TT*Ot&jt&4 z3I1pR-Fl_{F-wrGfOfC!$?&ksyL*Qkck0Q(MoVXHqz6Q@h2yhdC0OXZy9m4?YVu(w z_iCzq%BdpTmZTNWEiPZ4Y*G9xsaw^#t-~*S{zq2?EDJu!`*Pt0YxOvuZQAkT9Zdz( zR~7P7YK8X`?%k_3T^#w@%%yXK|1UV^IkF1yWF*Q{Sp{@jiG!y$o}C*g1;VF!Ox_5m zau0!lr%fJMS64=at_X9ydJhT&IVPqzCB3GKps7Iq|C66I6{x@I*jI1zKdvE$x zA)%hrG+kB7Cp$k!j z2?$8)l7Ez)4yd($R+eq!U}xqocoB>oXiW39X5(?UlznGE4|-lZoO1_gX!yy~5jq)t zbSP)GHiHhJq3doK%Lh7ofm#+8B51vOu_Y^**|tQlk~3<%Pb2CYSV?F&8xW5B8X*t$a6T8`F_xh)aM75F~mb#gYzWs(+ zlFz8>OO5I-zw=gB%(=0Hpg+tptGNACN3A3Lel>bcEJ5RYD2}nEllS}2NDdtr=5mb# z_^TiXdl!A!R)3A3y%}hc5Gv`fi&}@jfxw)FxeS-zvdxp{a5`0!x zI*496C6uV6h59ev8_HZCTOW(%ZP){6S3FDJrJD%O-FvJ;9YYG$;TRkKHm`f`Pj`Sp+@W10AJ?G0OpUX3^MXI1Dr~Z5 zyey!-*d_#d8m2wC`851S3bE6>JN}~>d2anhlh{M-@d>r=51FEPQgbqCpq77v>D*gz zJe8=CxJeT;tkR|*&M8VUyPzwCh5g0BxB*lrnytGDJ*aoh_i#=)Gw|d+L5FXkvIy3# zX8iO@@_S1{x7r(a|J@j87-_P$svb@sJ5UoD7!XPil`7y&3j$NPJqltb56Q;)q0rfx z65=^_GB|W@Dq!z+>*}nRSboKqc7>`@#vc?)J~$#OUqIUPH=t(v#4UViZne|2sn5AU=rp!sc9zO z#>B3G2k5M*RcmL{ks$t{9|tlt;SjL%EIBREav#9&9z+DNOGA^YcB_NDN{wwF4ycGP z#gB$jE@fA=a5y5ez%IAH3;Ymsms3mrHI)lo%30A62qb+ghMwUzacF_i@7M+TGs7(E zFe@NV3)S|ROJu`DxASrwVO~%#*GYUQYmD`D_jshn{jpz)*&TBM>tUS>0`D%~f$^x; zU3VhNJ=ScdFI9L~VWKH5rHeAH0%$)EQh? z0C*VEl4N%7d5bDh%>9im$kgV3g-i<9pKeYM+P^%yPG*geC-g<@-5|h{?EhSES#N~j zqJQshBt)pT+sNIM2f8_OTOT!~k}Go?Rqur;p85&4{UHyql+}g}tEf_QdIBpzc!ze= zmt3D!a@d3hG#i7{9)R4{@KL55*1MS{SKSpL81OK6g-80J(8{MMWt}RP34{{54PKwI zgxPUQ<>pG6Tgp;%gD>(M@k>8eaQI)9%rMs@Ki(``GYa?rZbEMaOFzC|0T>m_=a4cx zC!L>QGw3M(F~|1q>1!Mw9zpY03v)ojsxLpOInskH>wb->NK$mTV_&pyBNe}%cSs92gC@py?@D8|(9HJeKkd)7fBaIJgH=LpG z0`V%+y}h^#ti$A&hcGP+)0)LGpUH5;5BGO|G&-I$Q&p}Bwr$;$c%y4uIOFqmJ&dHW zv&0y7>~^khhev;cT(6$;3nK@DxJSJU^A*68bA4TLIz0EhC=~qRVvwGGta>O(3n~Eq z@*ZDcw9uBmqQ|pzaNQ%{uD*UIK-X4_AW_h!z<7Ek6Oj$La%F=W3axJTzg^qag>zQA z_de71Ge3t*Pvk)5{i2|a!{Z>w0z1y0)&vKRZduJFUZ0V)w&}J}f4$eHgbouqfILIO z`c>NZg#e!bDpzr@a6e6Ke>aR7bR{e%IJVQ{d8i0J3#35G>5*33RU4JP0Ay3k9s@xa zT0V^w)H9gS07bcu2c;{Y1&wi)}?2x=>}x)?+1C`a;k`p z?d@i6?C5b$NCeAs+FS%muXrOjH1jIXNpl50#F5@ZXlX2A=<$Apgh?~2j5oacQQc&l zu6p{ME|IXDQ&g>)gk|QZbfl=f1HMZ_(z-GNc^SDMeF^|+iIHZ{QUBSgdEsXDVxrMn z7M`~S$f0?rMg_{G8UMo^+2xkmkcXOf%YI;78;6WS5#LZGX{zbWHx@2~&u=*= zpSAUUJRjit-%BcK^Uw_eOw6SQj%CRbo{H`=#a#NoSo>>uFFm}Gk?MlJ+0fQRq2zZLcu~k<*O7EFS&F-lD(J;dtalj^F;KdF5 zWBl)yLoM;54_v6$*d3Kjxh-u3K|;ntQeXf4lCudtz#jxT`-4Fcq7>W#2SUl!eo1cK z&h83-pW+;iA|f!6CySj7JmBtghD3noWN(w!tlv`Ll}kWwvyI(JJv8_7vPyGkdPsQR z?XtUu+-ALcm+zJPtgFAQ-Wm0W{48o=L-q9WY&{h{M2jT@l9(gM#{-MZ@bI_;rZP>e zH)g7&w68uPaI$7-E0&5a-aUBQiKE3^pNq0BwPeg$JQQUdQ_F_Q0ll59We}Q;jkB@5 zRSiLJxf{8$SJGjhM-~y;Qb!?FEzIY4EjcW0yVq|yb+S8a;Q|)s(_vHVT{7%xX%2vx z$u>Xi;P%Sc*j7u#t9hnphQ*TY*YU!tXOpxcC)P~Ex{g3&dzrRVTRC{VE?JpP3ruB z@86ttMj6`&w=C*h*i*8Nf5S{ofL;PMq@{TpSH7AB-12Mw(=fdpCfJ?vWx?z-Y2E9f z<ll}>Y%LG8bUF+2nNmn@ zXx^p?PrsMT|G<~`=#e{Zfm3U0d&8$7dcAQk%4*sq!T23bV)574_pt^=UUUN*;j z9kk=Mo%r0=f7ua)`PuyfZ#xQ=9JHI#ZuNZ7E;l8+`&tTp_ViVd+R4$;v_fMykmq=G zL$$Sas>Jx9(hwRRqHI3H5R>+nws+|BkS@=+*_oa1b91HXHC{IKe|{%awG)>l->l5( zVksh&uj7ewa+TezN*ia}@%p-tP}pMH5WZw?`}h*@TJF+o2E_PiL^%9`zQxM4GbcdT zGmyL!oWt}1lda(G)uwtiH#a^ze0D6rP#c^~Wz70)Jen>Y;1ZI@Y-F(6GwIZLTF?A( zN5q?M?-|v9;ld7WF7&5&YKEkgt{hjV6*s~ot%fED784{AycDNJKwu)EkwnRu} zEDp6AnQ*>Z__w`yw6o@+POhYSjaNWN#{$CV?+IUU-N2xm?NnQ1%vuyyYfw`2q|S}m z8QZy67>jzOe2OF0Ea6|6pp@h0rFi@GgB3hiPtfc~cXzIYL-cUBNIG#zW(bt8n*f|g z1WEEdV@r2CoKb$NWMC<3V*_XYLiCHvBOWPI4A6-yA^cTlzBd&KC2rQcjg272UKjt# z-(9=pfN&aeZpUk$)5t$-{6{E#Zp-s+$l=nR;uxnwmfkm3{ycWb?ksA^-_5nX?bc_1;ow%}QMR*f3eAoGGVA`qqS@#=m4;Uc zTC=w#$d66XI#5B=ik0a3OnGUKy@OyC)XlV(m_gkV>hF)qAmj|zBSM+L1dTlkdy|$1 z95Y+#KiQ*Se71z+qS4dqZ(uww*Mt@`J~pGv&0)4VfYSO`-7Km^NiKs`zGUFLg4df4 zL1vyW8P}@51)gVqk+9&`Wd=gM8cO@hS77FVC5mfL$T0H)V8yUYiQg5q2#%S|3U3ep zDc*!JGE`erH2S{|JXP(8-1ZQ1`DEAVv?~0?>KW0);?uIoom9KFr%(NZ$kQ7Qhij3) z|9AyvAK&SEOt>|grjc2*76dA;O0_dAp>OT|r5fzKTOcedj;htMn4UqrAk&tCh$Nym98a%**$- zXOf|b+SN&{a%cEim~Jp5C5adG%>f#}>}2t9c(-^I&fz;C0q`=)Ioay=v-j34e3IIn z49)*J3jOUNpDBxr>vzFd&j_{R?m&P@4Btd&z}6TV6Fc}={IaS3Ksw<;l%Po@5`7T{ zd+)?DhPv_4LDUR-_RYP8e36GE%x)$Q=IRf!_{`M#U~IO{tPraFy%I6v4(Te>$90+4 zO^+L%bj3nI-095Rzva6Vt$?4dJXa^Cv3oc`G&&h%EPmKKb&7REMvz5N?RylHS^_G> zlzX-6I{JK(XA76Mq%ZE*8yZeB-?^bz-5tm~IBI{l$P<9Q|9pX079`G*(Dv0Ai2K46 zpU$4_ZZE=ZVyt7<&epH5cj=(MKT7KpTZdu*Cc99M5|zNb#LJrJA_2eFXANgYsGrv} zXGZdA_;uz-k4Kgd##(Vp{3`59uzcj~;*crC&6y5(<;)6@?5>V^R3RM$Fm`}ZtUbD& zG1-B(np44itdjRRmOghrzM7y9F*W2E#G;Tn6`2Gi)}C3$DayFYSn{PM&ntTo6O%5g z4~Z}wK08eJd+NV?^e^mb?SGJlw937EZYc(}_ira%VmcUd z5sKULTP8)=T5PP+dT!lu!kPd)^x*=DH~KarkCqpG+{MXKjEk$Ib>oh~bY}}=3CEo) ziR!aee;rmr-8z|*zivg#lridf5_B3WXz1w)4{4mWqtK26gH+!V8hhi?1TrSf0;u2C zNEf=BJGJrf4d9-=1#&@PQ>|P+| zsp8df{?ql@Q)=$a>5uv=4t!CE@fM|>I3A{h;)YC3{qVNZ?4^N2t{|?U{4_mr?HzJ> z=GWaRQNQ{##}AsGoaUUd_TzyZxtX9)N=@9)OMeNHapvn3DQ@+1U7+ zGS{g!-;p;T6Qqmxxme(_i>>(s9|0YvtP*6sZqh?v@@z>pDz4chZ1GP+8M_QRo1W7F#0c~9KtP;9L5-%(i9eWc(h_~;J?x8y+ z^Dr~nO4W8ezMU&=f0dH?m*?yB&`y}u*bR)cUpi-+Ba60Nb>#=ll^bjzn~khW&0oa7 zV_93UM2<<01V`PBUCyR**^AuikMI0JU{^^%lZSoEM*5+AM@b97mzAQBA&7`9w*U;H zZDA31K27HOhusW%J-tDM|k?}uegO~zO*$pgQZ9kybKq`#C&1Pga2_;TTssAgOZ>bqC~hp9%@F>?NcgBM@)SK-30h$^g&B_$J_>?3;e~- z&F)X?aK6^#@~idVLGF@Qjr1t{CxJoN7!4N8MZa5O3}#UtH%jJx-eS&Wks83xHvpg0 zFV=E%Yu#hOcIrHydbnM?q$3ISY9S1X1d%$VcP@BQ48nY}(2MF-O zA1Z0zFs+}?VAf`dJ1+`LispUURPHediAg(0?&nWda(wCB#NW{1E+DtWnV_$)52A>3 zGvrOhK-~nuAECrc#%aIMtm6VQAFgMv8d$=6A-58s0v&P9e*+luFR@GTMzN4={`=3{ z`Hv*Kf#dSQJ?XImFVoITQOk9^Egi$)9*l-|fBkH znJe0LnI5aBRj0I|Syjg2U|LW1)!#il*{=zt=+8eoe_eoi??^@Wp(x2if*YD7ENn-r z+>ZMzK7|QaPTl3&g=XRzj>O>;Az`nB8>ERRhh&U%AHNycaczC4p-@GtjA(7#Amw_r zl%0*!v;52RYb~Odg0Ec59qxejfIFwMBeDttw35P2&r{RkH=k4XN$ZSA2Im#TD3J&- zNdNs^Tz6`3S>-*EmtSgrS&{MT%qj^D@(-e3+?s=ZY$h{lBB$lwTGWAH4qjR3uYA3o zuR$@J=}Ze>)9X|J=W_}~+{f7y%=AV*xt$DnsLIK;j+7+Nma3Hi!Cmq-O9hPg+qDCO zvr-|`0o&CJAvrsTCsbO2SUD8Z+hO40i5zdOz=)4rA%3($h^8NAXC`KX>oV#oR}J+> zC+B#C90#i@()F?(1m57+V~tgf(8U{RrqwganoVEVB9nr1XG_nx=Oc$->G28wpv+pU@5Ly;S;|fdpXepkq#jAl_!%M z^7>V_*mb~?Uw~`YSNt^`t@ujZ0x7`g%o-LbC3M!Ro8*PP@AAt3!~5>PfswL3VOdWa zG0F1=vweJ@iWztu>Uc@s`bvwAgAg9jYkxkTx<5Ck!=Wg}2Gp>OevXv(@%%8?T%$ zH?@SRW>HWXR76N}xmitBR{hymwQ zBwv20A5C|pTyoC2=^94$*1%1Yi)Sr8#&I2jQ$6c)KxL|jerR#<5$_F2)~6*kJbfaaLF7@$_K+ zdO^ZDIUcE0g2I%0qQgUSf2P7`-V z33&gDs2F3_t1A4VJwuxAz9@Uevbf$)^J+)iiqlWxP3Ln z(RwMwKp}g~>Xn9EH)HzRA&)B%Yoz92sh^5hNu&xqIO)-<0fonbV?c`&Y2(&!ry4mL zP35T+_()y;(YQukc7VT^Fz*UrU*+M{Y(i<^G{zi-E+-)XaMMN|QJXXUKh`AShJL#~ z8*lBq8Y;BvYI&1H?k5iTC`KL~pOPbYcUQc;&tH}lS&VRuw?8@9r@IMM?=|U;aOq#4!azw%F4pu zZV4SI2k|l-6}*0Dh*m{YJDzXM=$HpmXcNH)1wmD(oAa(7%?(G3Td@--n(z}goic-R@ zgpI&yBjKF3$Xz0F&4r31kQ?f;#85#RZ*A@4+t(j0z74pLxKinQ$I1+R*x%B;8X0k# zP=W*+}}Ku^$kmKVAErSn84EzP5sPjcu224KxvfGw zn&j^}zR= zTdVZlwh%On^nA@4kxWM0C^7YE`=?OI%dm)}Cx9Wm?~ErYz@S^OV5%ro@|xbTF5|pt))L}7>-|_v& z%g-`H_)5!VFJ1M$4*(2n0d!yUCM0NgR*&Xuv2w#p6DmMwjiYX`nmkMcvRm>oeFMH& zh2Lv3W8Mws2Pe0&-=nO)}1;&A!!Ob0BIZ`e$W zP|xfRC=k1%-Bm9BJ_`)0i{sz{!RXx+nh7%w2-y3ip8zIZb-=s#Q4Wae1dHdn07$gs zZ5C^hk{Hee-57Q=)`Z?Yco9%nDxL4DIP{!DrbDyH8$l7Vcf?!0*x*s<#ZopXQ$7=? z_}LgHe{+vFUv5a6-(Yesx>N)ZOSsO=#KI`H1^Q?uTw_ZtajqZCa_Eia=6Pg$*~yET zbXE2hxI^nkEIVqA=4OizIKL`5UtG%0#!c8}?vMLe=Ah5{JNdefNx9_ks^94W8e6Ly z8X8KF>L54HCgB29MllL@6#PIlJ8?~v_0$G$J4yU@9xAr@bmw;sB_WvVEn$bGTxV_%;Eky)O_m=}B$0H?9I=ZY16+w$ zuWYs&q^k#5$4RUd&U%?rK-e+)0OWJ#T3?C>#9+EbPs*O!ty;72_ao*f4VB}TJBp}lktobt8*VY zchDs_$YH6aCk1hymE$PFFtm8Tr$MV^c+xxZyB#rlx}Ke*=b6m|oZs?&=HU^MHyEN2 zjN+#Qhr5p=2_O3?UK5NQba%PMHZrpLg&53`AWBX2nS7LZRzvQ$|G6KR4AR~`bE2|Z ziwGusR_7q}aNiQ$N%?+Q)#@HzmbEP;ccQC1@Cc|$KWpwd2E^mOW(RGw zhV8a`O`Z6(kXk>y*rpWm!=*mG;Ys())bL4Ei#$?t_Rfj}c~9xEz45bM+TWUUYn+z8Z79)ilVwgY0qDZW@yBwG3OEa?0)1czG!A^4;PC)CnbO8kGqmoUgZj@ zY=s017*I+Tz?s3tZ(3oVK%B7uq(W%0j7kJ$66lZaoA+JdMBHTgrqfve5Q1mUFqtt5 z^wTKCdCrf6!W3;r z#HD{^7;Kt9HNF|})sCkxY8lw*LBjQ?3}~ota6pEBsha^3ITI=sY^qSSKr%=5k`R;p ztIRYM{2BI4hMhla;X9mPKek{bE9&(Z5{#nbEa#|O#Fl5syVD`{`&8mE+=r3bfLMW+lc)c z^r9oyH?hqyppf6R=={6eyn0MvaDFe?0{)&jhk$FTcR!0q0ekmFiddvr9XmN-OvW7P zsj>9I1f~xNj?M8;AYc-CLKgBYjj4zkd`nA%dG+HR9o=Lzcp~8(i@DoHM-g=?BwC)e zdQ===W9f10TQhv(A~O@vU#e_mwOs}$yR;L6wJ)@YmB{{Pzyx@Scc-TnW-aj~XHqBFJ5SxlBC)K&hFu4K?z+UI+m|dW6u@96 zeKF0~lMSjuMvM=c@#MwS`WX1XhlPT#MCCKyrFVzCjFO5YVQqCAYiIYp647y|An1*7SL`RmLA=O zGo9<@Xa1Pwcl3)~IcnWQ0AEHH)s4)=SC$!-L^Mut>r@0>=!+H7G%o(dcwe{jzQ5wH zY*bvC)le}RCvlDaQucU7AM2lV&jc*pozv{NQi#iw|RCf4T=%5SJqNR_#tU zN7n}qw-u$Sii;gwr`>I*!Yb#rbRjx@u?)yZIQ7jakxZKDvShJ9+xWBN>7HicszOQ+ zAgm8;CEhaDPiB^wJ7mODsCDH*ccl~^3Fme;m+6aPIE02h))5Pm3JfAY4N)B}%aE(_ zGEX*#v-1>3PBdCvxvbYXBUXe;2te-xqu(~ArGF@%at0`H4KzKLtnm!Au+WM^)RoCQ zqTCA#2emZV`pw`vQ41~rzp-01g9@?BMO_XbOOw$*_T_k@zIoQ1EH1|+b%i|27sr`r zCv)rS3PJJF*jY5A2KoiUFXtZLJ0b7NpcB3-AOceAKIxk!11|hhhb{^R{X(%_Q0-c{ z2-DHZ7~@JE){(gKo`|yv)5YEAVU_&-Bnw+gs$72HiiId$c50vKI!=mIMe7uF6;rhw zs`JKRXa0-Ea2^cIB>{$4eJ1m%_?s})GyJiM$d7BcfD73U_-Rzaf!C!7ddG-mA=Sc1;8O47))z+?jiEQ&LQ zzU;Gf(%dekKWtZ`MTr&us9g2+Ro_2w|A;k(n|#aQGDCdJn8|gixN#BgAqm9(iniCf zg!=JBN8tG1UMEQSP&Sk2+4Y_+h6Dow{XkCxYEF0Bj&3mwU|iYk%!YEx-(R)SGGrMk zQviKCcRF$}SSD%Ow!UY++C90xkM!Nl6P3=hurwi7n%vureRZ8DMrFy&Azw?ioqQND z{hMV47CRdjt}yX0urbLvUGMbgM)>~L7H3pF(~ZEV)bP`Jx=b@|evj7H?3_T+#srVo zdvAo;zaXTGUjxS1ZMpo^DJcYo{APp@62R{{J;| zcGOJC8`uP`-YG#{;X4QIKA_jwGGvJLAo87-ycjM>Qy)It#iPIMc z3y3g3ddSUW_b^*iEkh_V$qW|%h!!QJvXxD~+x_yQS@Ij&6MwR{)W@Kp#wq6uJ2kEZ z;R7(EBYs?i_x8>d@mR zBVOe9(PNlancZ7PE+po^qXC41}@krPB-KT-& z1=M@&4nRi`*p#y?x*% zK5aJ2bMfTu`l$q03vYi>*p>_R4#{JXDF3O+&HQvf@<74U&=`f!)JmdK#f`Q6C6v8#t8lK2Rr z?g5!$DkG&FF!d+3Wa5C3l%DRZW9HCr7rB+`&#mFvNInTxAB2lhzWq<`Q{6Of4Moy$;7jRm|H5fpu-m$?X ziqw<1K?Oi8zmIOSj22jixrImDK|KA18PB}s__i~@2e|&LYB1M#zd8Q}4PNy(FTjsu z004_59jz3se^fcY9@rljd%u4l`34|z0{``&dbi*Gv;1i{9GD!iJ?R%6Ir^A0___I8 z;trvYI0YW4vvlv3$!F?m-ENji@vdBVYDE9(6#zm3XO*6cb8rLX9ADaB-(PUKOE`wb zzSe_7_l!A=&vx=pYiM(e03R5#AgaMmxg5-V;xS^1!|W$J7dd34UfOf9*cKAyT zpopXHCsy9GQTl)yfrKI+i2qrYi_a0jy((rQkmIJrm)A@H=&w$J|1PL}C=`H3v9ZK< zt{P!eX{*15Cvxx~BP3e5|rD;yR&Bh2`C-4ob89^3| z`zqKB)cqvDGszE!C&Wa-A(gBzKnQjyya3L@{7=#Lk3*1x!s?nJ$oJ=(i#F>Im;t4& zIefQAI5M3uTI@!;kif{e+_BsnCBg|iT&YHf^x_KCU&hVe7Isi=`BX(nDV{X85p<<% z?Mst55+Ni0jDXjv2hRn{+Ov6Ax&}A{+ zw~f*MMGKxKZiE;!aDo5)@i7BdU2{9Ybek3-geM=`R2Z;*@W=*!b@+(;QyuBHf@Jg0 ze;3OE$|C;i&CL<6F9p+zOl|6 zS2*#TcMS|Bz_#~{IdL$yCrX?GwPqarf78Qz3I6RS;u#2)mKL`5)E-mxDAoC4-|^m@ zW}BKh!_Zt8V3aEoY0I1kbiIlJCu-GG8&5Zvx>8?pYV~&;End* z3WCESvBro@+~&r&HlQWFv1|5py{g!4!jm+P**Ja0`G^w$d^u+Awpd=IQS2Tt`kUm8 zE5afA@FmAY*{|Pv=G{JeW#Fj1W!5stwveZdYAIz6XpA}K>`kq~PfBf*b&Lez1yr@~ z2lX%^^whUJW3+(Q>zib&ilr_-kpk=^0ynfb+A*OBNC#BCC$4 z%aD1_i269KGG>moUmV;I3lbIrk+;O7%8mO3rULFAYOrK{9#DkaiWPk8V)Mvtb_+78u_z%D+`p%7Az<&7oHjP>D{@F2W z+TYNR%5S?-H3+|Jw;*7^UfPAjlWDStDBzQu?aVBu0`1oxk^(yGSZCh7$jexaP5wr_ za}%t_IPl1fjP!xqsG#X`NypyF^g4}kjnm5vj<@I|VpkEZlYun)UX5^L*~(Wg_(S2Z z$HxZx`}@mmV9Bu{%=~l5UKUpfxHN`0T^3c`Y*SU8W^`XKKmgOH6@^Rm2jSjh`##8| zu>B-#Q;nl=Us3OQ!zfBcz5LMbm~U8itp?kwL;Fm^XuzT))Ov{it75V3=4)9e#o_jE zp*eUs(TyDeS2u(EQQn?cx+N9d=a$nlrrafVgU7d0i>=iw%gk8!nHF@>0*R8zU@}V0 zomO1Zh=!7}N-j>Z{wKmkdL?A>~auv#pI@VX~L-;isdQgAR{2nXP-&6Vj4j<9$q`s%>%inhms8M5#$T&vRE4b{-0W_0 zAB0VB(U`jN{vv~{0$M+WBuP%Mh)u(ovkw{Ra4crHMM`wuo$LK%% zx>8O&v&nddA^0iHA2RcbXbG;XWTkypDyzGsqjY731P3diX()y*1&;@|9sK&(C{?&1 ziuN8uB>pyyj>hKi8h9vvT@LOCD`YeihMNm5PM;?3Ebg=E*J1FcDMeV*@1A$E171D% z&LXX5*}tx847jQODSaT6j6ksU9Ym~~CrkWzj6U)U+iPCt^l4{X)!D|EYLRX0>2zK zu6$5FlAoSd&0wq{wc6Xc6Cn_jSqx#QKV0 z8V_ky8L0#j9EAn`7njsH05dE#MqA7;NYl=_I^8P4T6s6>BpuHU#-OT5pA}6~K<mAP1Jh-%r{QmY1lkCId$#`WFB3|rJ&ZE4H&P{2jdl_A9TIVZ>ZU~KY4{p|Hh3lc zppEPmd&xIZW5747RIz_~b2G%c9BLr;4Cbrj6&QWpqS)(SQ7&V|p)cQ7yo2m|ofD_m zXx$SH_s~+@#RpC=XpO}+RK&Y|!a2@qB_>piOQ>7%KM-yIV(o!e-pFMF%LLA-rId82 zY%_EbAuIcliG{b7f~8L^T>vh46Sr58hZM(u1B#T6Sd*{C)|s(-sLZtJizw!Op%(vv zCm(P^&820lKQCGg8oaF0?vDY6G2f@vKFV-EZa#VANr zez7_?B0XcuF(CI;&6V6KwB}$it?c13G#vl&Q$C*&gz2RTKT2_p3x^sVYnP08(`;UH zJTm;^?b3pdf)VpqpXK>qnSDH&Q`xIq|6sN{BDxT!N2aSlKV&uy?_cmf=Uay0%@<%pDi)~M zNZXCpy`AAxo-~{OAPk?WV(Q6aa70j0EO?(E6@%;|Bk9NS_hfdKyk6aJjSO04o}NKV z-eE7A`LP~I9y(DeA!zo3&z$rd%c-fQDrDbrQbd=Z>*E)Y{oy$^N(@&XjNF(yREszb zRz6S8_>I~7FY+Yz4hQVsu4#$yH7T`wLdETk$-W@wc{p!hY$l@$2V!E{sD(Yp&9ioA zdY~1L_-1X9!EGIv#`JxFe(l2_J45h){SiVglt($2Aw|3@Cas(dY{bm8cOgQlhzfMn zkDospy-e=G%R2rVX6!93Zs8E5))hsKiXr;kXSRq?#c6b-Qpd@6Z_>)*{=buHd6C2A z`T4cVwH5c%Fdn#Ez{ja?pS}+@Wau#cOclNsNgusxY-X)3?8!z(OT=udPNOR}yc-#q zv=atAPcPAXeQbmQRhW-$=esZea%V}IqO2F|1`UVs*8U$NI$#!C-7%jnve3vJLJsl7KxY-=^H|)C)+3V{>G+ zSkwo#(oETwL&@$I65@SQdS`EclI!8hW$dzytAzzCr4A_m3%~@fR;DYZggbYh6m2km zR=1;HL+f6iQo1$2Rdt+t9!4^$ncdB7zfTwuEpx~G>=*Mf$%JcELTc9Pml`i1H zd_UxVqWN`pUF~MCba8LO^fM|o+B@8oQw<*mDjznCU@9W^mJ^}hD~L+zFO#50dvY9- zC18{{8Qw8J@Na;+xkOST{0G`2jh-HLY#mQ~5zrtuXt{fVM8Gvq$Ayl(%h(}3<@5CF z8`l@T3M!ImBgZ?dWJWQA_@5mj)w;@T~;q(ZT8^bmBsw(EMm38*iF&Eu>UexRVAdA;a$R)D;n%c`Su z)r;XR(4^K>;jU}REeYIALT z99=-}ev(Y7^13a`{0Q~UVAt;0^>iz6`kO&P^4Eh?XUM32hqeIq@jSzs;$}K*?I9GV zM?b4van6c3B+p*Z6pj|A+$t&?bsrz&#H{X)zV z;F!T@a`PH~ESC_3o(H(6Vp5=`_GK6Gf|&F7v;sm`Vs(Qycan}G`vi-#aY!MRu=MrB@}>P9m1lKgaUw^ zKO;C?!~Fc0YMNdGKo1gGqwMou3pxKnZf|d#Y!B@ODz81Sz4H>7=9iaV={LA0J+B4aC|6Ph1Vp)`7T6#qx}Sh) zhrnWfG0i@amxy3NZ`k=<%=2ihi(uykE!l!N=r)x<5~|i{V8U=nbkWTFK}0 zPMbAaSb$g_{H8fSt^`5ll*v&V#zO3ce= zm%b{yRsym^G}YgkLDDdl`{%@GUsDP>5Safb>U1bWfl^!j?3k~#7@XNAp7>#6(iU4rkU z{7QF#1J+jxL7_e|f$J62eL;9olpf@{v$Bz3(LaM%0-XJ}W@7dE(Q-PnrHB+ScESh7 zTI{p{2HtL6O5I9F%yB;FVz|Lp;m2!@7E{xsJH$3@KnX~8qu`4b8=t0wej%0w!Tf(n7urIVD=d zY2{-Y)$}D=7T~#Z5SG)t0O}xNRvO-1-rX76o|BVHHo*?lJ6VMeW7$VW1DNk{G7@My za)wkzt30{L>A{zbl$zGi3;#?&rTKZ+{B`VDaqiMWaUZyd<)U9sbU-D{&lh^rx;~?p zE*IKfeW$$55^k$|&wAL35peqY{W$wdw2JiBdf?q*{~c9l^_v;$qKKqCpgMR@z5S}R zKWE5?7neK(ZP|SwdRicDw&r!g6i=c5C{4BZ-O9y}_nsIk4NE<)3?ygyE9biA`zdnH zOuR;*$NOS^b1bqMyL<=sQUZte$~h&6**k~1IYHT8wZuXP>hDbF=2ojVp>mU7!HTof z<=tKT`q9tKdm(yV#rFGuU#yZ~NXZti!+C9XsHA{^bgW-{&+*T^XwjFkvQ9*p7S8WJfKvbMEI{8> zqJo>9tj8v=}(sNuA{+*&2!jSP>5pspo-zGZ-jbu*@7kS2PBSA-v=$L}}!gm2Jx@N$#%- zQ(^!yJfa{j$_X)BJRmgUy@dtJr?kG-91aRVMuD^*p?r%9;Q;LWg{HxC%(@_UHWLv( z=0{lBn@peu8N*k4rF{X6o29OIi+GGbQY zE(l0L`9RJs3boWqogIF|U|LZiw;;T{{WuM_Pl^D)?pVZFNINSu=VC^B^tOJB;axP$)+X0BCEQd(iiM-$#ZkQr>+2Oe^1Vg}Xx;z#AE@|2l?7cY;-} zbcOfo`=l7d&QY@AZw3Q9>ASfu@iBZW*%f04Y3 zG_4wsF@_o7?N9e1&NG!3y>l+LIj#>h#F6Zh{I8CG*FkGj6&lBtMz*(ig0o`B@_cUY zo%n?ONL^h!I3Si?ne)_&Gq5;6zo1!4EVil24^W51nISAM<(>l$Btu!#eD5SjkiAa! zj&G%yef@jPsOzKv`9bEUDY*Rt>6)hY~ z3;X5G(@Q*$_cwo)Fv#w5JJNw~qHDQkkEM@K*zYe?{}EPGrXAov8gV;3v=`i!24mC0 zMHPi}^0Tobao~_hB~@*;_${Zm5`A%bxy2?gU`Es@!71&m3d21;fn=Lv)%Yk}hn$XU zJpHg~Bk!vn$gU@^lEXR$F2tL|fe&Vm?DHi)G{^6kmT_x< zXj>MOzN%nL;!~5Hhr|X;oE6zKAFJ--UqrQVmdFu`2O!@cA|7i|Mut21*B*+XDAHd1 z{CmGHbGWq#@vHmNVc3bc)_tE971fOJ7Xjk;@pK65>QZ8c93l1g_eWQ8D7e7ze|Nd& z_k)$MLeIMP%u{8Zv!AP}-rFt-_nViVJ+9r~^HW@}O`VyTr(QJSVHS(4#zH%n_kQG3 zysnkFVMm0osmXMP2wGRv*6OthU*J+I>WR0LQEVGTeE4&@JA{prd|iEcQoQ7o-jYz3 zwH?KE<8qf=NwK z)a6n-LJj9JhZz@Krysb^`MIy85bpQM9aApv@HhWIKQM=vRSRknhyoC4zb2mNX zh%g^0Qh=WfsU7EvVV9=c0ux2?U&Xij#qM$@O2`^+y$G_%y|AvZQF(7JNch68ch&lA z%bW%>Ljd1mHHzrZy(T?evbZcmI1C9IWsHdGm*=O4R#f&X&Hu;HdAPILMqwP)idHK| zD@u{rswArR-jrHJDT)}iN9_@+DN1Ul_NZE|S$o7RqG+O;&#t{{kBB|K`~mNEy>G57 z&vVYX?{ohM%qk-9bx?aAFK0J}mO^JSRkN=yb_boaQ!!b^6%TR$yfVY=r|N^qv4Q|f zF8jkQ(aQJ|h2mDLM(o!i{j{@OwX@wBZzGQ9_d+uQ#$=7lE-ue6r?-MY`fZwDrmSj9CpfPTz6~#IRPBTx@9iDU zwmTSbSU-E!iZORHwP5&^E>L8|IMIth$UKgu+FhM(za?n)N&0XU|5Wgx7qelk*wNN; zI@^9$^zA?Kv*^CXhB6(&$axQkO*_dfp_7A^t?l3d6V_$84K>-4qL&4C!SJQLs48`~ zyt6tVcXZ_b^1Z=!<=7%){Dpz5$=CntwOK!P5~}l9j(X3s`bq|0op0mFFIZE!;C8%H zHdV69@fB2XivhSfWSsBQEc_)A>iDL9vV5u}n$X&`=EsEb}GY9d?^HGN?MY;=i1_)Cx0VF=W(cN&4&6dQWdTpi#C&hwG|HL0;lxd$R-r%hPK z*3^_A+*dIO-&1Nxmb?g4XVdfIY68G_ALo~$rW#Ky+$5%Vc3Qfy>4P1lXvw2j?IFRe zd`?&MuR>2&f=P$L_2y%e7>TP}mei*&b75lmx^I_p;pcfacYdmgpb>f_=N;zKY3PCI zJjLnR?VDV8jf}DrF3RFw(>91bS^Xtq`mo-^RmVF$&8YLa$(_L#D;BKvOV+9z`?~56 zrz@tWOP{vhKO@TFy5+q1GFxs-Yk}KC&qR3Abj(-Y+XWwG&2r{)NW(><7#CdH42>w^ zUBTEFW)=LBPk{>3kVF+|R1q3|lTvIBWh=nzI7bIs{Kl*?uC)TUHQ>>-|JBQ$gwU(K zcA&=20AO%0|u!sKuh6>hQw&-U5N24V2#kr~>nUQ1TY2byAMI_T|`~ zD{6(La85Ufw{2KmOkRwsb9zJY%}0(eGfd1senxePK|6C7V2^nmwNU9|3!FAs>Kg!a z6%}5()JJq*Hj~S~Vn0bf-f0UW{tao7V%Q^LX3JjD{V=ylKH?%rbG$8Pk90W z6`+XX59@A&)FZ*ib6^|PpF%qT3RdDYR+eJo=kpA{nYCgk;Z%Eaax(4HFktF5;nps& zLaZg0^wEdCWRt}WS!au+npnrQ%9-cnSpN0ijOAGj>Qc+y?|Jdgn~qXF0>m9P2TwGT zapw-C9;W#m!LC76Gc6g@dwEOg2IcKe290!s*lS#O0MQYwiy*mpYKR>YE-Wyjz@Lp6 zZz+@&G&baV#uJ#{#sEGHGpXICpyE<0r>8Cesc->WX`+GgC<8WS#zNFBfItB_5akVs zV1Vj6A0*j;sq;}_Bv%g*R(x>M&DBF28}UME1{(vm?UCi7J$|K{Z3n;ydA7yPm3za{(cXL8IN73-?)>J~ z*1*uCmHm|gm$N!~fycBWAHDUaK?VAzB_d5V0ty&R#-nGyp${^-u~PGLiyySir#@14 zvVHnVXTWSEh6+sf7)uzXR%yD8f6b;6y1fw0848#Q(&@i?dOaR!gDf8bG3=JH77-AAA!S*>$DqInSK_cRx)M7y{>Pc6h^L-Rd#Y^RzZgTYo zw~Eyp-y;`u}7llh&C zsi7Nh!>3^pXv>=gcW)$qJ7}pYH7|L~HA%;${QE#g-xxL5-CZnfT=b)T8;*pJO;HF? z@dbvvy|T=M_FGcWfpJf<(iH#Unx?kUFoM*h6?1^srhCTI3hZLOi29s5GI_p>p~ zrSB6qzDA3s0w0Zs_;0}HT6^=|90spx;B|SQuB&W&kF}GnpS0mGc2+WCDEwqaRx{rC zXFexxHC5j^KclA5(Jq9$nvw7NP#*D>S5@SxorKu9WNLH0@@+lwm3Ch#fB}IbB>- zxO=b=I&m15$`d3q8~(SWN&eBB34g-!nw?+GXArHjDbcRhHH}!#M)H__xLE!UgULeF zm6Vv|7INmsXXv8qS)6LsGuY@ygs+ajYeq~p%x>Lxa1%-%DIFN_ZT=c-nd*SOuJ97q zfv8mmv2B%#J#-A;PL z@U9O{;{^A*m#@a7>m|Yi7RUYseSlFxfbu2wnRTX2X~Gmb$T>9cH=gvs)j!CPRajBM zDC~>c&4CwmZw=j0Db6~8+kk6aJC?AAa5ZhAcM08Jfsr7HGE^YN$($|%fJJ)c>O2D! zQzp_YYiS5xr!z5ELK)R~XQPN{Bj$I*nclI$J6*Oq6hMc+UzN4;X|4-EGn~}>-+SR@ z7ok5QU=Hl+fH|;T7wsonM|PkiDnBOF3kg*DSE#$oP?z%ynXN)bA8=87hVCjnWJJ-j zuyd=is%8(bwsO-k8}@uPwE(h9v#3!7Vxe5W0F)3YHI^Cz$W^Dn%X(5WP-J`I1!+)F zWeYYZ{*4GIk|7ER;Eg1&6{Hp_Q1JeG53J)>(ct7O0;|DI=yDAu;<>>9Zm&_}*uM4z zfZYMgDB+t4ljC2u>4btgJEMk;Q_%TIO{Xq4<^=>r{4h6lA@%UY_96l~2U3s07RZsw zJYgBUkioh??qjwkDZ&p*oUQGHgaivjf?ccQ{;j)R7oeLKpw?&V2k7k=nnf6NGBCvI z2qvq6SVV^I5k6-WS}7iM+t-_mIJwJ8tul%fYd5-U0tMi3fOC>6D&6jhi|ZHN^c=nc zDc&B7?jrl4?J;e=0YH4cKPn%%>myC1+=rB)Mo0({+Fp(^s5+B%!$=#tXeG}}^~f}? z|5V)sh^pXT4owAE3$uik5VLP7M-SUOf2lXm!Eb#{7Ir;-Yr_@87sRL~mW9)Vmqp%6 zBBjj#S2p~50}6)qPypq?D7}FvezlpO&RT8(YU(zzu%~bEfRdjyzQHZ`gL~Cgq$b7| zr>D(P%#T|p#?)0P!D<=I!lDlsfA{w8&+mEpxBSN2q&`cLsZ$*QF#ZLFw99zgy1dM} zm(iG;7+5~i?}L|mO8pMhyac&Br6(J2%=f)o;cNeWvx;YYMWyBvFGc9jRE3tSInonL zR!b5v+vnw-YBoB?U77t$8PF7+6duvXUBH6zpw%2j^XCKUE!!0V?8+$gP1>#ydORyw zJ(b^R7pR)V&%FCO|7*=+`(h+7JHwBRLhu*y6vA)bK<7>ArKI42pI)=KT>ho%UjF^P>JcKVh}}s3~U4ojo&DKg46Kad3RfH zmOm)A6>+t^ireOX@gRvtrTWRJt_%B@F{?KKi?VNI1<{!uH!kxScW-$-z{1Ztc{6W& z>pye&^>-Kk8wbpJwskW;Iwflp+S50xKGb@4TrRt%9)<0w{A4uTp|2H!%{;CHm<$EQ&X?SS zZ7 z=d&(7_+ue=x6GgIWAyrLN%qr-swfRFw~x2rG?Wk@Q)gGVx|x5@ukTolYsAT4V+eQphz5nQwb?G*!TasSN3ePQ8`i5(PL*@nj5gdS&o+#&yx%_PA-pM zpIPuMiyzLY@G;8X9>!EEi1kE!>$0kkx^ccT8>~Ij|L78r`>d$oR>NF1<`*zNlCy@s zsaiX=tx=IM#qs5Gf6%j}VPZ32gXDd7jC*mETuoXz-m02Och-@b<;*;5Htsh}Z zJV2}^8%H}v&!Vg83F92Dj~`4;H#pPdE~=o=mCr>}?~ev))myk8M6xcLllMkY{h~ma6OPCUl2P2MoIs z9^n3?kzCt;UBMA;eY=8i`#L;(77ZE?&z{-sv6-Odx+B~Z@#E`8-{J08 zj6~14yM*vvo!g+dx#G%Q_hs1?PCG$@)GEt6Ub+&>mAv zp%%Gge&lFWtdrHw`G@B^Qk0zkrEeOie!1(N#cVFwTq=~X6#)lywYA8uX19hk_9DsD zcorhh;*sZ35|{h*{J5yog!moUf_8J7=rhY0B-iTjg!xIDVhC}9Kh11)q%YdB&C?hh z`DC;&YcRzYlosbxFI4mVpdcxdF6H!KWEqEZhIpA2vhdf6B1q5gec2kpBt*|%eoWKO z{ACvR<(KHtJ#!&)0i*ql#zC>!y#1s}QPE27F$;=lCFv7;P2&SI=UAVaD1KJnt!gMu zZXQ*Qt7QEoWYjDth}UQ73#PM{<>dZcqnnKE2s;D5Q)Q5^JW{-z=U*%o!8`H~E_l5z zv$WHR_w&s8lq}hniyN@LU%#(ngIoxn9ei#y5bI(Zpksi9Hn&+qVvuvfOdIajGx@_S!7J;5DM3>Ey zVlyK#*UjbS&5P&@m!vnbcSut49#;CKy?<|uggN3byj42RQg&uMTQD0bVOFZhFxeGn z#<0MsM_xK|5CxT~XLwcF$$UCso2XBi>( z6mc3SDLM9VfP9CE>aP-oKF%;V9|&!1wV}(bfX1<8)@1|Na_FcppUu%zx_E&O2ly08&d{s zlV{)6uHxm;lz-#jeS&-lG7NDUUbYOlg>ctH7j zR|FEnfudK?==^C*HGH35BLv@h4baJ;xdb-AQ&7mAuFij90NO-=x*uOM8$Qds_JUyr z$%HaQVa;R7C49IZdDnamD8Pm6qM4%(i2x}}=lL*F+{6|TIUogf&Qmq%4=bSiNbR?@ zKm!WEXIG1^=4;e=8MUy3^gXm8J&zhiCmDi{>H|<715mUM&tno9>NooExLBS7H;gGNH_V1cV2;%;c3>*iA` zfvH{Pd3&OEH>TdxMy`(gb5gO8hY(6hj04x5#-;jb#RPslzQLujnv)O%L{b4XxVfBE zI}M?ub?&KNoL(_t8#TdUaB>Wl276)x15_DFp{&Ek2P$EvypPIHm)gX}S*7vf#DYKk`&-OQQ&-u$eU8zl6)3DQC!Tcq^< zrNxUdv8=UkQ*HqqR2s~WA?Y!|TH&gMm-5a(GGHkIsZ7rR`RR$T6hXFX2Ip7yx!0&% z-IcmP>M&X`$~{h+2|_#E2h5nm3UH;{-2|t9i$k(FuS7a!Yj6V9Vx)Ss1Q*dpYJ%Nh z4JSGZN@i+(6*}isLq1hsb(j+hH^68pUbZsR91}Ub-ZVw2G1KI|$)jIhUy#Wa1-!yuZxfw}?3UzIJBFIyGu#?x^AHPNfW{Fo@(y zgJ~cQ=wMP+^^D23u>tyh$TuhkTj3YcfHe#y7pS834RPWo#cyKpjmz`0yQi{O{o$8p zS;wJ_s&rsW>)a?{?qe%BO67Nlj66UoW7o|44@I@`;Hnv@fSz+SeGYOrrJe!i^k2WO zK@w+{wHWMvSw+GqZq=Ev2AS`cDvs3Cpv7Nzy7(L`wxe;jzrBD{eN+95bEZu%+5T0d z3BIo(?@^gg`@azW>p?GehSGXJ(}9Jbs-xy{XE-O(Au8y=c-9eH*YCwjg&Z<|h_&m3 zn)VOQG2Do=-<2<#N^_Nk_~TeW3UTHkpJ#$1U(|-X8HE{KlbVrx+rOJ52&k6@P9v>f z_ggqbJVp8he+ixJ)-_|=ga^;38aHYQ3-bu#v2Sa$#iM(V`J|ELbm_Fg>&VX^SF)!l z0A2oJmXCZE<-thEI6GEfvANnbjCh)BgyrpMRtO1{vCJJJi!L&C++Bg@4#?z6R*zTN z2-4{_uzmKgiP9KAn)?0hr;L{ezPe0%b!Am}ee@_%eLD=T`&W^J@aB;9OD5_X#+8Z3QNyB6(W#!1K znzeYm-}~V)C9M2Y*+yyvCt6zG3LBF?r#e=7ujq{kb$JE8Mor&kJsQ|H_a6-kFpt(V zR;=@r&N38qVR^S@=hv*O`6mt6I!YB$qGKi6|N(V@7aFd_M`eg7~grH(`OE(G&Y#Sc^ z=k%J+>n&W30-FxBOI|@mkdhebkb$m(yduCS?5#zr9h@QRUb?a7V}2lZeKCy>bIc5H zX@7vE(!dc33fhdWkBa`I(Fgv)`tX5zwd|=CU*74`AZ#6_8;CFgx?FmthVKBF0ACVj z^zW(nh`I4|Qe2~2RW-dQpz%a+?i!giJgjDis%VG+YW#Fjm8v(^G+)m?$hju z7_wG9ko%yYY=2)9|GnPSwG6!%QE{I~GhOL-dwLa>dT`y~i7;?-gnRXPFDvi5bP2vN zXgwz>s9`ohW1?&$u8(94UUq!Nk_=vtb1TlNcM&5zufz`uDFbu~5xV8K(sx0slHY2+ zX4B%?`Xd-4yVy9T;X&rx{`GHSY2PM_CW~osMlwK5Mp3v<-oe#}6@8Ymm23b?S5;J! zPjmVwFgB*z#2BEZ|1LpckoZqkE#{4kFL$hRvGyzpv=}okUSC!^&d&e983NEuvReY< zS8jP$_}qc=&e%oKGPx6|cL+RY79|;V_hM0{&T0VeRApZ@SIKj_d}p?z+uYS!$Zq@f zPeku_i(sb1K2yHrH-9BB*7{NW{f+^aj|M6Ua`U+Amlci|uVDq*M4aO-u!v)k)_acP zeoYN8p^V4=v%V%t$e&T#*KP*i7c7eTsc)UDpAuxTgMW52a?NqBTX~0rUo&JtiAsYQ=7Y=~CK)ywB=pTp$0L z`{*YbFoxu(*C+ML6(n;es8Y<{=Jq)}-EOHkOGtQ-^>31^4UiE?NSRDejm1QmYPqDxChk)hje5)sL>;u6Y;(6 zBb43!tz!6HHEPaiXF3sKmRm&@YSd~pU`D=TZQkaCNtU2>uDO`Vqm-eAkQ&!f` zUD*3(@M*k1kifz^KT~5Q>mXvE^E`*tz5-#%o((_lT(o~~Y)XttQJx~Gnyx{}jv6`cwabfzoq6vYgh}{ki_#>#CuZv#>3S zla+R@A6up;^ZN&W z9Lg&z4BqN{*tJJs3IF;@MiDd4NpE8AAwjP$eKa~X$MaOhSBE63aB+z^;z?Opo4?qa zuGl6)*POq;`Wx1FJz}nW#K)WP#7`oxIXEt8B|=>iCRB1bT`n^m3~5zrjq%ux;h8|` z((7-~)6wdGk&JmPz>)@U!-NM05ceNPd5;Ak4LMZ?2y;oJG7pm*CX|pP6N49@nQofr z+Q6K${ig+Z+4#5x@;KVP`a``D%Xg-@#4u+!N_t0yYxZ21rrk{2gZ_r@FLp4zj%|4L zz4aePp@$0@7Tu{`Ki5MdA?D#{oHmck(A8tuY8$yBCT!K zHKK0l3m1;{g(`nE?%WJ*J|+xx^q~2EN((_8U(l!17DWpU9_i(I3DulPk%Fc0aiKN% zNMYiSU`{>#caQNpBJ$OeC25>Higpgh9+8$x**6 zOAFH=FI(mxt<0yM#PZhgU%WQoXrJ=#bDfpvPUy-N6FxCrxA4C~!ei0xK&dLn4bth# zHeO(QlLPrPJ7DG`iXY84sSDj=)L6~CES^++K>u-ZKh!)iCLp@tXBjZ*)@ucQcOF>H z^yynFp_ST;O98^t^5EdbsrUUlE+k8>VIPaA>2S+1ogwQYWVLQaUT+JG^Inaja+3T372hCDVES*AQ~<(QdRazO1lMLLbM>{es-{*322Ca zqpu%7fHo46c8==To%j6|uR|GOSnPoXT~jNRNBD*8drJm>u0=j*NZ?S?@i)?8_LV>0 z$cnS>jZ4|=?%Tr9PhmFRfY(me&W9APOpQua&o2Wi+Y-X}Yw54HcV-maH);mDx-lge zxQSmf0X4r2=@$Pb((8?d9S0s?gfE69Y+UP7<8kZQXzGdlj4Q6xNpkq`B*~jjslpHF zYl^F&Wms50|NA13w?8^TzflyAxIA@ka}GaVw+GQY$;_I1T#-ZHRNjLLNT}K-FD4Kh z6^}PjKnbBf>9DiywFTdmY$DhvDhr>kWo;$e9&{nX_>A>z>G1FA?q&B4E~%aR>aw6D z$I#5pODW5oRI-GnGIhtC&$0HLv=P072;TdyAa}k`e3Bh{l|syKT;*3sHf0ZS9O*$F z4Yg4p_PlFdpP7z`H}fR9E9xk-#QC1>?HwNWR&r!I2713)4-E~JK^)Z%inh0Rv{~0r zBMl2t%e3_tZ3s+IP;E~-IUDCTe3tFWCYxVCi22d_x$or)j<6NiYy0vIK7P7WYAj_K zUWN)HEvUTQ_*?5}9N?F?+;7($8bZcd1bDy!122j$@^b-qB*#kn{Ofdv#A*}|9WoLo zPhwJuc8xQxY&+YjVV@75moj{N?sc`iV+)ro)hO7@-=`n;iGkXpkGMPdh1EAsG<+M;@QEb zE#Z}w@QnPnwN;*8_fKiPn)B6HVdoW`)9eZGOumE!S+?O4QPGX=RD&DA$LpkPpO5#q zjXnxV5xo^#Tg?r1M``p}Gfeu2+7YKYoHMOwf#m}{$AK-vSNmy49i-_p#jA;_o$z41 z`sCM6Xz1U=I2AYgY5ueYXGyz(GY_6Qg0MEvOG#6MQWQ3V;tT!dX<-j~lfFQMnsT0f z+8W;x*6|WwGkZB7mxl;aL>;cTx`mLot1sC)j@Gsf0xk}kwhVd-#2V8^YII=AcGKo1N5dcs1%ddwvj?AZhl7+P-Z%2Tvfky(hxB+E}r@=K-*Y(G|^EOlFkx zzY_6f6))z+v*_uqt@p#$OSCt*$U&joBKU_(7hg%gT^&i)c{4jDW@G#v-tuKehewwO z^@j(ZmsyIh>*5u9RuNaV*85{+(*8rTYTtGLEceD;EhwH&5ed>vR9zjd)sYmCAE5p6 z^WDoF^bqLf1HxaB3#N<0p0_YU2CD{)_>{T&z6U- z%n1!xbDcsz9YN9<;wS*>lvP4nQkfR-lI;&t)Qy-wLL6LE14+3@z@0$+c$$r^tfL*) zA*2n8mYwp2+Z|0jnTamI;<8C`Enkkw$dwId5Ls}9z7@Osm0v>;%QGG!#Ro9daRyZQ z2^LU;m#KaLsmQ%Pmkm3G7GUU{gENBL0A^2jjq94!jc7`4)WCb_-jsIsXl~|E@!=$()M`xZzc%jAQ}MSr zD&9me947N6+1)op&e_cYWGUEHddSvmlpp9tAxeXVt4B$Iex^rBntt?#25ZkhN~j8j z4V-62J@VTxAMmwa?PS)~%!~UdQK#Ph1HR)Js2CO+6-h)vm+4fJ3>5^Qb{gyO7uDB_ z%R~oe@bv|k@Lxy&wd#lktvT}`sfr?CM)Ji*FCRcN)QbXF-m2};@-o}fB*E{)cSk+_ z6IM&oBEVFLt6e_SqK)_u6oZz4{vW%5zdbPmH|Pagl%%i>L8$6m5fN~?s6_BTRV`?a z%1=Qb@C{TOk=>S_6524Tf|{WjcnuZt(V;A-R|sZ~@FM@O@vIxhYESM!ARphV_9zKc zt9%cjgc|6o?ut`UyygVKk)KzUjFrFLdaFW5aRVCr)^;hZ4yFWP;HFXn#8c|I*r!AK zBmDqCCn;)scno=>5n;p5MJ~)GMeHI4e{g6nboKs}_E)&UobwU(f;_FcISwEAPRhyX zJk^eNNtI&x5c=7Os{wM(?9~(Bd2!IS$iVlr!d<1@g#TreL9-M}2b#g1w!L8IFr-1m0s&Bt5$Szfe^@CPsSa))&;hB%Z zpa7;=DA&ED+jv<{tZmGl*Rfmnf?X;5LH)dg=xSICk2Zi$MC!3%Mv1cP7B?kN5q0F* zp-ugeBQNr&fT?K#@Kga^o1L6)Z!+dqaV_$#@qLC50!W~NnwYkTs0f+!qo{CwC$1(m zIJ9mw&4JHB2Xr_y+aAj5HokQ<(n>bWywv#y^I(6}JHK*xkK(}*rtTL@T(6np)yY=b z&Vkk0-=gTND|N&!Cj8=6cG#6`3*|znwK&NuSccy+kR_Jdb2OSj_;l;FwF3n#O_%NE zilyM=hty<;ayNO{{O#joEKmuzL}AmoQ>Oc0UvT48PA=ZbVaDI(xkh2{w$x1xhDdjL zp+$+a?e);T!^;=UAH+Pu|B?H(%sqnH*l1wPa4?$B&ANEG{DtBO-bMGfzgY-p5tr%9 z{mnqJ!}ayL>`zF$XFzyi*01~=6^gjy!i#Crf)_jA)*)_p!bx;ydWWo)SIus1SEeQC zZy{#eS}~nqp$dt!ON6mzLSdm*Rhf|mnXeaNpvEQWgz|sqF{L2-rb~e8OLj`6^lEv1 zUYJk8#|Kf)rjAppdV(A>VF4j_t!r03lqF(o8+FlH+68hQma&U0cboISdF=RF#f0xHk~bdr1@Fa9`Qpl$?I z#Tn2B<5zFkMxzfzullY|H)%RLz8bM~3Ss2wBDidl0ne%v=2(d8ir<8Ws3ICtZP6y5 zV3R_Ux;lC@8YoILX>FodQ|I-{QZ<7)RD$YLC?%xMkZ4|%(}#47)X8W9pyGgFsgUw$ z9#K(I5sIL<6V)8h4_GN>n2OXOBTFQ4^d$|5Nf%mRq~(g6m(rosn=W*g5Y!V4pcVs1 zI~S(=P0y(c5SfEqL#f&8#n7LT#OdmOL0cm!&Z!IkX3L!1Tqu~DpOV71Zk9b3B0u^> zy_0ps!dMxlIXY>Q5#-7}=hDv3_v+Wmq|55BP;2?KT<`B_Xyn=#9quphMimUAq49H+ zdf1OC$#mMvU}_cy7W-xkLoatlThyRfHI__EF11X!m{^0nHu-cub@Woipsh+;nUYvr z8#I03pu-@Am!>3(Eoik>iLBuEU#uDgab|NLw~(T`Kli^>ZD94M7wq@y6ogmafTcBj z|M*v1f;>Zc6ngyRAEgnC9}L}dNV>IS8S-~%wO2f|VN18u$OhopwzKN+mi9l)4Z~2m zI&^iVbBnTfhK_PpiyqHV+4^^Rbo1*hzWy5FG>bmNX5pb^VRssS!hhpU7Wg|A?d=%n zkVRjqX1VYejp*MSWhr5^DeQ0d< z{5(WJ8$_O4HLY<8o-boBMV3(_@X_}VSD_0`?E7d8cGt^s% zAlLuri=~0!z6)a9eMqz_jIONq4YGPE$l~sEdm~3kf4cCWa^Q!~n7{3<>PRPbgm>6` z!2)z`>s-1~(x*Xb{ob=G#P%IdiP_7#u;YOvPBNL^N94102WuwHe-$RRh|r5T$?y|R z#mj)pdtY>K!t@+BGq(tEC_J;6(pKrM(ajhmY|8!t`5TqGM@Koc0$!2G(V0tCS7$Cp zVY6ISpm>|RIHS#rx#f~7j}+Zf+Xd?V(%?yPBvE*fh*t1e-x9s_DwT90HeKyL3_l;; zoLOeIJykka`!K86dT09Z`^BeUKFApKM9J*M{CpFO3N)9oO9~F?UO#69vPNN_$=L1p z$C+7RNT+Z4Jres`NWyalCObZfbeGX6LSol5;HZi`)kWnk5+bmN&n{`}9uGFLBx^ z_->1$M3&}b3G0#WOXu=NXX!jFpHR`(xVY?qu}<&hnrlz(`hi`I!SmX~W3A2K`uA;r zyyt;{W5}{~%9Ee*m0_qPN-%0cYIL;a@Yt4kxiNh)WODH~D#`c*QSRx@Os&s6f$VP? z@mv3WL_6=?z1O8*W2u|DqCT>vP)Tc_XzAu((GZoKUbuF;*X~YF_!{XEPU>CV zp!bZQ3TT;*k@{zwaA4>@qgnq7aVooNHm2U3JR&R@`$fpn#6LJpGYAnx)P7QifA!b2 zw%j7O#3YswX_IYQM%c(A#%*jt!%ioTs;pbHAKk0E8oFBEJznk`3*TRyy>JcRQ@m2m(*PNbX`Q=}_7OEGINlAH= zw6X<=ZfI_58NPRSFog%~dAX+e{7f?VN&z(mb&KB0`Ymr%KiziG5)!-<E%snR6i2e|l*7(OyXz)2%PAR-|bs6#8X4`F&?>NHf0 zh!yOL@wRYS@Sd%>H`4wlV2pTZU}j><{Hc1hDUqKXfj%?(^UNhTd~f-poDl=>K*+Q= zN!v1)%H91SE<%M(D{}))it$QNlpL)6R`h7WU1qBIp70HA?IR?KeazLQV<17bQPd*#(Dn#3C6zf_ zMG>cw#r5N*b)Mp{$e$lIkRAtFIKx#9FXm*~w92Z~nW-)s2*Ssx?gI4AQ}$Kb{l)81l&L`cZl-Y^ZQ(^5p}+fvyPrUpt>cc_@+oHEBB zorO)&g()Hq&o@`Px7SE^GX0eKe@ZKfEkdSK+xzQFUYituE*7_I)A*~bJ6LpdY%IN2 z!%*UR=+Wys^C?LW7`7W}us!Xpg`yLvB{jXR@XNgPfllO$O=1J2yUL-1S&s-Rou!o+F4v)7NnXScG0dRZ$XK@7p&VK z4!=D2t)JE}-Q=(0z&pK9jAXRT)%WmJSc=VldNzGIK_EZ|IY#?dhwz{9+uMy`KEXh$ zz`vXIi~&cOEX)P5gg^O>mciX#1d4O4`=qsL_Kr?X--xZXYXz&5aLPiH=iNSB`;mft zo6N0TviC&s^7OEFbrsE+sF;`56<=i?E)Lo9@7v%XY&aqnwl-Ud7N1P?Z*KKHpm3*` zciQh?_G$AlJM%XzoxAW?6m}dbe2#J4rKPWUknMRU^$kZLen8VD&zAf9RUTHD8G#F& z%x-ZmoYV+CHnjg^p&tSIK`7x@H~D0t9-GF`#C;rUH1l^0)Vnw~F9HYyka@;9Pb##nYtX;@xQji;#h7LB`Q4&^=yh@RiG zY4h`Q&b74i!p{D!6vgw+oUo)3TLxyP-T56Fc5VnRPfeM`?k-GxU|wJB_D~>qxx*(h zJn8>}8|8gTg{L^tG|n;20zIAi!6A{W=-G=y#p8-s!C@FH&dD+d93{1CuYpg)bR%BI zsjW61c1RQfsAAvum(5<}U17cmBcE?x;V3&3!OC=Cs*=G$r-6UbXEbkxiw#&(*4+F< z&Xn0Iq!cj04YQs(^%hUDNifrAtB{Ggb4N_I0)V$rT=0hAlD);V^~n<;v@L|F?Dd>) zXObK0ALh?@^8u?_cY02a=&BQ;cY)00sh9OtjizPdS!%NOOoV5UL*n8eQE7Ief2+X? zksl2AzfvbKCsMEKJWQqFMciy_1mEOI`^VG~?Vak)4qsABN(6w4dYVbOkFkQVF3Myo z1t1g!qLfMiqwzt4RE*c>5_#Ysw73$~n7PG%E1}-%t9@Xkys0gCBbFK%F7oUn>J}F& z5uFTz+kb6RLXsWV-@AzENVFP&Ha!_uXv9e8+Mn5HEu zOp_V3Ti{2>%DcdLJr-0B{1d#>C!$?m8U(m-spUA!&lPbp=>_DlT^CFH!LJpU6bojc zK-7CB6oVK=r`m7n zELbu65(&Lufve-=c^k{f8>1`4S3=Je#%fyINnF^(2*7oHFbuoL(woR#(^5Io5%{{O ze$;(zB`AtQMwDSKMOT6Wilu<|0(!9R*D0_kg}HS2;2j{;h}kG=j+KS)G468C5;#ES z5Ac|zFQq()9^7!v=TTkysh1nHQ}^F!yn1d)XUj_BT~^?0_tpdzv7J`KjNbzxgAw7a zC!aqm+o(Vw{4vb%v4H4BWu5DtKy4j80Adqvr=wl5G-pW#imohA9Su-<-PX+Hs_Cd{7 z?nD(%e|JNBox7;1hHAejq){vgv`WWH2~<8%;9Wq4ct#K3>F$&sip_@oigOdIcrRh} zuwPn}NE%a|ax)wFNm^VSZ}IqEYhHw6R?*nel;w%%^xR&F3mU7VCc6Yw04G&O$DCIs zS0}Stbf;!s*C-6E@6p-TuRnVhcL4@!PLVPeN(R6AT{GL)zg*~EUPBw#%vk3=E{`FLT+`xX_ zTQWBX4S3yVhVpFGR0+J?KXGikVN*~`kO>*56V1)T+6IOb$$pE8#;R>VVm}=Sm8^j`aC46qhv2K?#ugH=!i>3W0<<&6ZYtCmJgHa8r`Kl=!l{oO{Z)>=mV$Nf% zf&z!=vzwk@`L=8ZEx}(Rd>cIqnT;rV4NM%S4&#=2q^9a0y@xgxqJ8iy8i5<3yKqI3p=ap= zcHfybcfw3Z)uo+fUYfKhHqaVUd>nNM!h&wdezhyEM-3lM|CIhnHaiLMwk4pHr|2es zGP^x7m*FhmDEmT@PYcn@TNyI35@l zv)AN_uM*{DiuV6?bIUS&>2$o|XXjyR3~jH}szq!Arxck(A}GBI36vFYgGPa=40kzT zRE21A5H#9UCdCK{K~kf#={5R+lt#LOZuIW^+)O{rXC=er1yvzY%vc3U^-gN8P+fKB zm_Ta*HTF!2Q-OM+)xm#QVC(Z(%9}a7_LVzzhQrd4OJR)3FuwQ69{*19E{{}W%#%2$ za(Q)^3jb5ku-EmeM1$OR;rxYjM(R|`k)Z2oXj^=6SD@Cn4Yp_GmGu~-jcV6`scY{F z>r44R-Fp5!WiER7lv(9wlK1PW+&8&tC$_V{ia#+Nf1ecV0j8j(ELz%SLSB&6&Cm6( zM#2wYUiB-cr|yqrjSUib#ZJ617TG!9nWqkcRJTPkel2N4Ynkv-FD&}Er4OMbq7grd za)AS}<-cy_kN*z%WADB}@moM5N<3rbJ)XV~4tXBSiTP(+I6w^{#*fX7TYh+I&Ubre-x)go)3`?CKOdIl;ndXbw9{2eck0GtTk_-83ArjMc zc^-VIf3>?I+HvIua+VhL@KEr-RxNIAnT=?j4J9oT7pvW)m4;VI_Ko!VxzFyF;JSk? z97f!{<=Dr_WZB(=(8KU^$&N=TtQyu{BFffFFbEP$>spcAxkL*R5Co(r7z(AZWCT=7 zbF2~x9-AHKGb}qE9s<1mex~aUY(KBB-Y{p@aH8kj@k`SFs8ud7(9Tw8YP4_>jVTd* z72j>6Dxh~bf4IFy;2(Zp>>1@>?xG4K`M0*T&iqf&dH7TP|8evh>5{mlT&1`->#Agw zm3i&k6|NAGY?8e)u6gZsajmTE>~A*LNcJWnu9dxSc3k6ke}BNek2^n~_iH@Q*@>-v zQCv9`9S5i5MyZO4IS2@pmvICypjg`^xPN;!i+X0F=wOJLz?U#L%GhubbEGiky7yZa zrO5|a2v-O_g}*#y8@^q4JxXbsc*3eT3Ha?6dg`-R<oC^k;7g&vCWK5km@H=@k}M1L0U8!17-^9<8BK>ir@Roxk698jDAU^gF;09fuU? z3_rM*-#aTU4=K2fvKIN14mKq|<~4_dVWc^mhxM9RX2Cx}!z{ckM`F_pWh0*R z+hIj(Pg~>=s7J7sN!be*j-OMDuC5C9uQ@1{J~Dc1TUKo@n~(ww`FX0^kDc7ToZg_n zmZZ8R6;<*Vf0Gpy0F0fUj_FnS@;AJHtd>aSG!#cW8>>Jkz-_EPoGwi_A~UUMv;CxV zv{Uo;SVx=^iig;ky9}+5!|+G`Y#2Dbh>?72C#do86JqWYT-)1=KQhO_#HdP*RLR8u?F0a@I0osQG%3Lvkuj1ENO@BM+ zTD((4uuut!zs>X@Pu3ueZAu9izODm*k3T62i1R}Phuyg3M~|9=G5S1kN7z4zxR}>_ zB%%j-y4~5Ib@9&@QvWl;N$9vNy0)ALD_D@1Z=QZKvAa9}YW<_{tKvgIDx1M{a$LW zzc5Z9M9aCM(J!}8WH2ra$7Ce?p;uy(DF-0S@NPx2K@o?6&01F#|Df)H-ue+^R{nb4 zqk!*oHZRA1DJby88e8|{{t3pq$f|zxpu#Wa6L>8yu!8YQjf*|~{|znIkOpCAhrIzA zGA~jyhxTLgnD?#fu0u{Y^3stmtl#mDSM~Uol!q@X=F7H0|#9f(41tQGQ-+Ec(PMJ}CujRZnXZ{?{oT<9*h@7bo4LF#(YFXyC#54vQpT_~@{ zkS?LTM~5=$#_=GYG@O-DMo6I@sF7nxFx+XB3+s(`%a0kv!dj--(}JX%zY^LqpA>lV zfUY5E+n#3(R!6kW&6e*=@-FnB((_4`*Ci*fk@p73ARYtT;d+-u~Va*~{$I0io%^rQPeTdubD);{|Bn z=TqB_OPBvnBTHmYr@9Y1^X_*WpPu)&yX#FTd4m}S_clwbWAX;{2p26Uo|&@J85@T4 zGd}4W{P`VTE`~!T1@}}4Sx*W`XyadGT>&ZCO8))!^n5$fu{j$wry` zyRs$qOc?`=8_A+=_;~ZkQnsYTCV$S)&|zY0Y|K;o3CDxu(W%CPTJZO!GG2(;rr>mkE(0kMhV_J|o zJ8HF^pRg$yk!R{J1Oc z+1(KM4}yn>?7#iU!EaL@CK6Bkn;h-`4#`NdR}8HUj<5!^(bP?`SIv~x-WM+IE4|+Y z;AgQ=a+jJej-U7O@bg6(r~l&E^%x6xdT>jm59oj<5XSVUp0%@P8DH!fH=$2mk5^Ys zbS?5tWU#%_MDN8B#&6}7-6R#F{Jo3IZxY6@UT}ntW&<^`Pp`t>iE6ZJtvw)yPo z)urDvS?RdxbHAM1U@KH5?(blUo<-^-Z44;lM+dNdMAxl(p7?aQy!GEDE2Ef07YihS z49=YJ)c>WOwb+e6A+`q7rV`Di3V(Pj6JrYS4Pi0BIbw))^ z`yfWVQ5>s1J9y3EU2AhgYaB8dn`a8>5zo>|Fkz3@H5Bf>revD_a>z6)E_acc+<*{z zFBcKX(iRd&k$`|=-w!a!siIy|e54-&{(;L4$u?I3aJQlWf%0KEa1f5#?ECj%bIgxr zHsR36Yu08FLLpc%6%8m3``?Z11$v;WT4MZ501N>!M6$hC2%z}Z(Y4^5phX|`tpm%g z8g&X{G0Qj^xSnVm21DpGU-QrA;5o`G{0qafvboTbo2B1I_&FipaFj0>0s!$WAJ|KK zStua^*Uvg0FGfusxwg)8B@ZR>N+od7{n-{0?`oh??Bxt$@gW1b*nxYU<5fW?2A_|* z#d7acwnHn-z}IrrJA(Q0X&@bk)r7flkPmXmvt3ATG3pfe1`4MPoZ6UbaVjUMg>=A_ zGo23OZ)9Obeo0tSw^>Ym{Ciw)tPo|P#Z`n`*c#_=h^xo-g#7@AySzt&G2!0IoQ08W}j`4N*#=3m}!PAzzhsJ?V0WN@2viA{F4@qaPs;p^Ay$ zV`=A&4O^aJ(%&)z2Ht@4S0kD7k|3Qdx7Hp9F92NH41ww4I1oU)I`GE(1+&*Z?1A*l z5(PLJ^fxZ*4v;n+A&?`t94Hi$2`p0(pp3841yMt@Unkkz`A(AtrMNXak{F@_qUWUe zZL(gb#K}N+`%DN|MXS>CV!QNyoDeMk{tU0d(fGLAelAn-*O!!#YJ0*fm)hx%K7Vy| zqL;+Wc!%oBPvEp153l`ZM7vmrb){}oRrB57TW%G-vH22k3g)wqMU8?#?N^~%2!sBTW+;L7g2K=qGf7ZS*nm=M% z|77d!YDpZ|tJ9zTuJRm3r4mQe`h&n@>0*0jAp+9A_1SP-8DPqJZ*yWE1D zlj|IKrMZG9VQ|(+I-_&JJ+!vZLRTFg7G`LZ=)?I1n1^F%6Tw&#SQ1zH%>tFyB-XY_ z-KWkb?O-#m2<6mKhHzCnbvfS1vEs~+bz9{dg$KR9brj}vr>cjGrw8QdHe3^-#Oee5 z$p@G&_wam@b_CMq-}-TM2h8++V=A@g4)}`(vY&8r^3+&{P}8k1-QZVGx?;SzYLx`| zUd*3*ltup48^RjTtQrs9U#{Pc^o(&JW#;^r}vmmv%OP|1RlY zSt>{j6d!34P=Lca|NQp7+&-M`zHk;YE;~j!@;FI6ao-wTS;^U&F-5t}rl9ylE>>qR zHf&CJcR3}T&3E3zc*Bbu3i}61{ZmJ$ix)df zmPEgm>l$LA4`8UUEw_XEId$GnAKkm1m)lS0C6XDU6Dc3)h8`q%u|L-Qx;ah2!jTokwAR@0J)x5aZUxUS2#SKGVsGRR1VSO4|5!ev%VZJ^PGEL*5Udw#?C1kZW`>>wFMc_>c+9 zl#g4X0ZrGwlu<2X(vN~^N$!fFihJ{3D~k+$4WF-%E@SH8NIz$&HIv zb5eZI|1^X=&jMf12b(o?4{mReyS5e$qc$r|T)4u(Iws z+O~WxxXlm%tO5BAk||63F7LdHVz+}5n`)F_iWyksG0JfBS5wPzJQfzf;rjTDQlOIt zQ=?`GLl*=n$O;5U&Rv5AyXe{sa&IxHA>p_g{8~>qkk{aPmTwKof&phuKQRZ3Bt3J$$9j~_k92f7>-jm3blCt2b)q%?s zs7G}l>4HbM$*;p>RCOc$CPmcyfS)GK<2oy4tWnXmDguQ{arbu7pCd^gq~(u(PPNOl zVzG?+NgNYfmBj(3?{pdkqnNq+BDY7Lvn*DXSj^uf?Yt_AQj^ZW74&#%B=mm7b8J=$ z6vxwQX{@cdibmP|=fsYFp4!zDAL=7|i@&5Gp>ZHscz`A923&ul=GRYiZZReOL7aeF zoRyN>#}@*a-W%LiUNRX^G^knOme`+yUPixoBX61B6&FJYQUB86(Ra+<`RvOcq%QO+ z!fBnc%I3bQbu2m#R`y%)jTi&MIW^f%Nd1DE+7fiu&rp`M z4de7Zm|bEumcn1u&);usTbio8T$1&^ICQp&Slk&bkYKQo_H;SmqqX0SmHFG=qW?I# zVs1`|i!mbI3`M!wec|X!4%htKv#*k6I6$Rm4Ep|4nYX6#lxD)twUE3m7 z8PetMEb{lzzde!*$4)rx1J}rX)D)!Ty{8o#zW*4nwl3NUOC;GXj(PU^t2Ynk=Fb0} zw4Ap4xiv>}vN9A_jG~QB;u$VG8g%M$F%y1*nfd4uw%%M;crdUW?;`LCQPgvz ztD!E}AA^bxqWWHIiv~7K(DEr~!I#N$B8uE+5zKcJhAodQt48%@(uQkv>7BscwYK>S zJrZV!m$w6FrOS<+b#&CS`LY#O~mPwlnaGra$!f`p>dUBGtpdjWx=<9YO6lL^o z8N*J--%xMv9ubAISC4LU(q+Tx4gU(!6upjua+~b`Fjtyq>|#OE2~>+-TT*@r(YeE{ zX2KWn^D`iv7Jh#EE^u+ZnWc%Xbm*oh2PNbKYmktV>~wc19)nb){T}48^KI0^9$B8a z+Cy?$h*B%#&|^#oV1U`()N(n+YciaGPY$=Oa;rQ=)wta8Zbn1mdS69=DSTd(T_ZOY z9OG_CL`kcNMg?(>w*WNlj;7woyJzhPS^)1BNe{Ke?-a7ixu;9Z&Ntl&4 zXLF{B(n5s$gQwniuZ97UeeaFnx;j-mzAFD{i~5YB00Sx$|&8VQi?>P;7{EC268$V_%Djr8k#r$M6r^V zVz5bT8kHY+1BoF_DE`f&n*hF-+RX7kKS)Yn8B`k97*tHy%AYruG)0PRhUkP{oS_UiQy4}a zB~Llhu#qNo+LLb{1-?ZM3>zh5)E^<|YRErgWD>WPdJ^Ql_l(GLT)a8Rv^bKiPEeEu zCnWb2m3$Qw`nHIbzyI+BZwcX95fjJ&%k+;a?gZ-mWyCj%EFlc{-0b#?EVq+)l z;?;QWSZ6Hol4pFQGJRFQ%1E|ZDm7~$e}OSAL}+g+GSYhXz=}6`)Kdqr_c&R{=q820 zaFWp^Fu#O6_J03Dv2-hkU;PJI;Vyw(=jPnxU2`eB2DN?|Ij|k8kjlz4*#UclpLgq1 z?P^P@%+zfg%hRmoNPp>OM6A7@Kj^A;GuO(0Epp#cYS$fY|N5P(xnrx1FgG7I{$rKh zW~vS21R0HF=oOKMo^%&2(7ZFXbN0zo)brEK{TE^-^dkT2H(Wvzra`9QSpt4%CFfmP z9seWD&&T;$J_mcJodXTeDmRz5>Q)kn8AjxD+egb=V~qB?iPJp_R{hW|@3*h7Jw!lO zQyn>WpE$WWpg%Lw6EBfIm_<8V)?D^^UL+s=&7#Kn{)GTAH$>bXQ_y)r~e! zKcduKsNXF&_NW`_%`wC=TNygm8=tskI>Cwu1}rn=$sckh>c%h6>fg5nqbqya=c_I_hWl$pr~gAXYbwO;G# zt=Ww=o&Fb$D^}Y(Zr62m-&TI|k3ilerRF^pCP~EBrr#W&!R@;v z4s|=G`ghGrZ_dwt1gtNb|2#60sJMk?{tUoOYrf zp-<{LluypRWZta7nc01hS9j;nCR^+Mq+XT8E38kOG^RKCqD!J>L?2S3Nt+YahDaAh zCtuNM!}EoeaZ>2z#`w9t_rOitkE&5>6b5o%>ZgtqwU*Z5fysIaj2s+WhIBByFD!q| z^~n=K;X%UOtjzA!u^ubq*6#6MSkz6k&9YXR5{*?$)4z*(rNWngc0vzUwo8V~TS$Kw zj6OM`<5}U3LtyVCU+p!<4Whe{9km+JZI_hV&e^4!62WKmh$*Ige zg2PA&V>*r$!6P3D*%w*nw}bcAXD|2WPA*D6Tj{@|&1^b{%lCmyj&gKSBiD$S@rj7j1U_h*M1`=3z=A0rx@>4Or^n7YQOcb!KN~gt2bSP;d=-vcco6Uqg9E7| z68VJk!@{T(+Tg0>+j>4wARZ^BX^I6Zss{Lk`3HGm0S$}sZ27PbIW^!l_MjsaKWl=A z0JE>DIDVOl+BDukVoe;%Nrh;8A@^U#eM3@nvN0cxXX>QVwVqr4_Y7d2uA;*c&N69F zEVUIgQ=wv;%ln|Ns-sG=IMdfCD}A=+6*wRuPEsr$Yn5v69zAs15ta(T^t#H# z%(j2HMFDmk(nO5AWelk&>M6amR4NKSyLOg!kyF1Q#RTN}XMBTZfy~_GX5}s9RhU<` z0e3g`WW>@wye`iK62izA)B6X5&dN=YjSFD2I89XsSVQ(&RHDv(m|8Ywp;v`9$UF*i zjSEHEP$ed9YYz@M6R$cvhbi^jUFotj$9HZgf+^N+i5n&;ZJHT`!-MqB6ghL0%% zgdPNr3HL{Z!z}gxm^lv72?(2+=Ji$|xAS2JDy6WoFo~_z1pTN7;7-L{j%Zy2+vO$+ z_OPa#T6_hg#lQ$kE&o(V+ za^-nRis;v-46BGiRftr)u5B6b49g!7*@QAyx|WsK46Lpyxk1_dhlP-LW6}S_VkyFe znp%yo+{FA{_E_x!06^~E?@x;L;$;NOH#^(=i;B>z|E9BsBfG~Z%n`!p8)@BRHbQC3 zR)u2)RZ0cI554Z$OOm4U}#Iq`*tU`+YI0C~yIh%i{7EZh!uENC2E zZO9xfu$xyeT-hQW_fAP^n`fM_;$vISE=o8q*T-9rUk;-XLR}?e;Vh4}43NB`qJup8 zJPS*+uVA_wC0hq-1j69AMy=VAarIR6kiW zp1=I5mkcoETQRI|{~I){ae3HHtQhL|s4E*<{`T!a%?WQawB|M`Hp$yxF;5h@vvRR? zY(MtPQyJ%9wWjw{&T%LQ z$b|l*XjA&QF>{n_XqUAb>QQd){q2SBHr}=3#=9A12c;hE)ur1bg^J;k>&?Hcqu?F2 zwjwZcDZ_*TWc_r9ZVdP@xaXnvam+90l(V3!HhJdVLz1i7KvbYvN-{SuwSQBoLewbZ z9KmEA=$WB|sZ19*E8mkgKcE!}ci{}=LOCip;u4>e%)dk}bSK@gN796SPc@g!?+||} zBuYkI=AwRjm^lg*aA9=exxaGn?+BWLbNjj}{J%NeE`g{2^0p}VjU;bS$t zf?^h``R`ghMuRuN_fjydr{P!Q*Q-505<$o4?LBWoGI=<|ev6VaR%YA%I^?}*T0Tb6 z#xY4`mFAI%I!=&#C>7Tw`LrIK@m!g%0RDF(+QLYY6-)=8IJ!;^{ee?mYcTaU6tmM# z{pgwm{!2Y~bagp@^^^f!HGOleI7Q%2x6%Ab($SOrzg1bYSA7*enaNWZ?VqWPIT&|* zvGZ1;?l(D=Hs^e7$wjyO)_pUZ=8a=s9lR_s9e}XeKl*S~|3I`(OjWRGh5T2nDELZ4 z(9^$U4K>qYY4gtR2$i*tZC;C736{rEE}0=c!os9F|LumlSI<^wUM0w?BY`ldIs*Hp z>-1Yv>}9;zjuvO&dp|XCSfs-VDJP|aC54&jD=Ws2tT=2AOineE;vnfN~fvMT} zo@l)7(gN7!OZnP1acG;u{>ge>ynub@I6w4Tf)}z}{e4Q18m176Ld#-2=&NxC{E*I( z*ujw+BHdQ|rV1D4ZpLs8{EIKU%w<@b;bk6M>caQmJ6WGXpvr!vLX<59eWlNj%3kZ) zjoxeI@9cE}=Hv*<(WS+je}~5_OR+Le)4bcg=cVQkE?{a>T>QO+*YAbL-8ie&Sil+` zP|o=s26`oW`To*UD>I;Sk!rQ<1C3XAWI`ej5}Nq@h$nunUki=KR+U9~7zUGQX<^`^ z{CGR>XPyGCv%Bu&uDi`UG5C$cJmL%Unb=$`zxed_NrKwZpJRE|PU@}CNg|iWWK)U- zGAv;wybAJ(K(nRr*zy*4^nIExW?&MqtjdWVrREQy)fSd{Bj-AF57hA{ObY|n@2eV! zUUFJ5&aq}xhjt;5GJYVP}f#dq=Tgb0`nL{|Q~_2i(#@pr}kV-Cqt zj~yd)vW2^-(KGcY-)nbx>S|rwfZH@;7)PHbL8U~-<~U)_XPN^ ztQ6wPQ#VN)+gec!zmL!_`80*&JWuzl3SRhgmGG)hsy+){#on`xgwpcIP1im|+Rf{Z zHQ*G>8_*|`)z>M#{OWXC3b(nL<3XWm75P6y(L31wQR}1K+UMAt8~gpohv%-XvX6NZ zwjv2X5%bSG>p$qyoL!PtnRz!Srtp)={e$~s!@lXZTCYmtz~%F06?4Yu!~Mg>_9Jr? z0~L@vB1e3C3-PDr2CvG&pnJEB=#CuxMnHxOnt12n$3W%SQl~p!LLwvJ%Sl~m%ZXB) z-2|R>t#B#zk3a2*)fr#^nWZKoNI7-c+>kCG^PukoO04Far6m8EKvX~S-jWXpr5@R| zb>C#>+3xA--p;;YDz4;0nM;(bDsIlsAhEl+uRupeF>3TVT9$tsANeBKMrJS{v_+U5 z6@OHMq~jM+N1c!E9WIi?FtLz)!pdrb6>p@CQ?nFb{wodMKyq1c(A+YIOJwe=ua|X2 zPaY(ws02v(Gjqih=9Y{nO_Itz#%%UB+cy(fHKxlGC@YZ@b_c!P-NgA>hH`1yccmvs z?vpVkrVVzl)*=hu4O%YslP2Df?c@Sas|G8N>C^vBo%V*7;7{wngGJTRl3CK;!gimt z%e=Fdvo~mSh0Yw;BWEhtsuK40EicYD8W^SHS#lU<8ga*XOQEv#*uEYaw*gvcFsN3l$cOzB0m9sTI2uTz(x_P>vkC!l_$@JQ^XgY$#<$7+_><8JbmAS&v zuU-cx3bqeyQ-d<~Sg5{^9 zT{3`FBQwkQbhFR$%v{L#;LKj;k*no98Ck-822$<4=m@fMy zNJq9ucHc_07;|!a#&qd?BksYI?M>hQaLjiH0lnB)C6@Q*=08GF!yDG=Pdu7?^Kknm zlP3^*=-xrMh}xN})f|*XL^U!%1(#sj<)As_f;G20=6r)avPd z!7Gd2`}gVbHT3!Nx^)uz;_P@Oa_Q=5*!W`kpsI4>0Pk z;p<%MAPE=jsx~@rD_l#SJn2?BnDWuBn=O1g+!W~`Gn1JWbG2MJe6{HC?&@%(*V^z> z!w((2O?~^SpZs)VSu)Lyb0EGS4(O}aI4QtCJFvOe7b+Noy@3X_vfjixv6YQVgFt#@S(;*PEPvoqvw2Ria9DMI{Mkk9^ot`UZ z)d|eZ&O>uF7thXorRrqlem^UW9g?E|_`CrKGSp;Fy>$&qDfgqU4KGa%E4p4QXBUOS zLT?MoBPrtJ|qgDqf7}wN!2Xzs4U<_uN)fd`sGsSST#NwPe$4#{2z{LDwf&+5 z#kkaf6zUgGi(4NytYYAz|PQq!_TkKN0U8ixsneqphj@F1&3QZ`w%*~2Jk z#T$IXwrRP9Zm=+Dy`)?KgtO5?y;=RaKd51PgajetG!MD*Kv3&m2oFtEk5F)1c2XY| zmp}b?AzRvbZa5-5Sko*z=p^Vm)O6V-Oqnys+|*JKa9=C)cKH@+SuPy&{yi*Tj$SS# zEP$3Xn;v5Q1<*#-AG+83xP}Hw$Bc>x1jqr^U_eTu{>xy993mKp27=Ln;(1)T99w}F zn`uc%0Z=23@4uH=HKs&O1n@flQ@u2jXjf?|7<>IXieJ7>f;};a*w|7x^>vGZf9!^%Pvi1o5KJ!2nL;-AUbEwZ2FBov|9)s*lub#Lo~gj}OBF4Z97O5KN- z^J8Z!AMr_lPZCl%b69=`%UgO*K7((7QWQ7?(&Mqe8RJw>#oxea)ey9>4`q!7ylr8^ zanC$60Stoy87dG`OHJ)SwU&X~5L55e;%nG=E&g|BDPL}^;*UF`A?xY9wq);1b4#n9 zfo;iJF(T!6s5reH znXuZ>j92hKt-re|S%4E4{QgNQJm_WHDfrrlHA6}bl;8e#C%%rj--Jb#>%NrdnH239 zsa1H+&wTy;CqP%Dy||2Y3m%{Gs{i}N<$_CYpOZdI@Qus=rYsQ-V)x3Pi5#jYtXMS9 zs^*G%c&HpCnBr!A>a!iV2QOPi0CzYpHeB-_6v*V}O*lLLd6C)EjyWNkQjsAdkd;&e z;#$*YoJrJ>=DUp=$bW+~_!@Is5fU~6q{%u2Krelp=vH`l!uYl&A7 zDgRjTCt=NMz6l>btaNZf}5JYF|@tDZznyJ^d>T z@a+r{eS6{iXlsU`=N$t|T7p=RX|rKKJdE0|Om|;XELAt%U!oIC{Uh66P|32VbVBz; z=Cx;>W>oiW=DZ%GN$5sSUp_8Wft4M<;JsF;^KE)!BCPhlc((2bsk>xFXaPr~^835s z(j*uSpuW*ay*u%B<2^}L8778|gLGs8GYSb|c!&6js5Rm%4g{oXBS82r5*Lmcg#mH; z4{`%2d05e|pup?EG&cp>8IYi)82ySlf-|i}UX?4@y-vMkrSH5kSCMmWzwzO>v{0XQ+;;t|Nq#aWcYAXy+`W9lB*2_CPfzGEm!Drbe$-eB|*kGR_M7#pW$6`d&y*si`B^ZQcbi zlcvqe3@20n5BKI9b0v=_^|jQkt`1tyE7T=m#X>+Tc#=h;T+d@M{h}xnz*}5yuVJd; zR8;j)C5k^m@1dE9nMfL|zEJ$MrIOk-&cdP!#rCkesLQOV>|1^>BL3%{;K4_B2RU~w zJj<)-R9}yWRgdc1S1XZG6H|VaZ63|T)f1`CXjR3IOyK5FR{B7=;-ovOXO6V+Z`qZZ z@<#S;CDxyxP@Zdfd2OA=m2IaveH8hxd6dQIIm6Y$a{fEAwCj&xswxGW_C?YKqx5;g zpdai?pCGcGi=L~NsTa8N;MDTml9)bZSQYT$g!`8DpF2}Ll+%w69;|A5rqAOh@%h#3 zByQOCZsoTxio-fSNr_mjoMDr1*+j#-Bp=6M+VHFso_rl_6)ZBcY@J`S-_VE1E$ zAf*B^rEgylBiw`%x29{1RNLNcr5X_p!KlEYn|6do_y6?W#kbjDUG;P2CnN<5j)J(H;C-4@o9q6tfURK=YQuUwPX^RHd$8_lY6~#LRi_a5dX{UUjwDT6_}f)!KkRlcw=E z$MT;M9a};Hg2PNq5G`{K^t$1TyMs+0!A15X=utn_v}Ob{tA7 z{!AGt2Xk9JtG%n|Z?kTso5(IL65Dlj04#8Xr)@$7BBIx(F{!t~ya z1fqb%P|!mtGX+(ILlC1jU6d+{ZtWp6kXb?2`blcO)yem7AU;5w42NM><+hs;W<>FZBQ{c!j442xW40GiPgMVmtEC9t6kLyvC;AMph z`p0hu>}L9NjeK;UdBNLLI$4)GsK(jNr^*ya25E(MeB)EO_)iH$>nZh)GXi{WUa4um z<;$Axf@C*Dlvc~J2r0){SAV>h1)w29x(xMEP{Cx2%;W~GeN7^BIIl+L{n~pxKM@{w z9$v1dQ4`D##9dgn@H9z~K7;uO`5bdoF~xKdr^%Op1VS%-r3Mt{@Of+{4p!s37zaSq zn)EUh#|oiX3~oq-)}mUG`4A+K++z?41_1?`dcn8kJGekvwhC}tZO#sA5WB5eh&#|X ztc`U=Rfg~WEm~^3?Yah%DpwZ^8y1J16;!n$l|RfUwIuuZ6|atPau-!|QseCONZI|B z{NEn;{d~i%MZsUk7GsGWxe%`U|eG-w(UN9dA#f8 z=7tWn%Z1Ds8#j5AUft^6QL3ADX)Pi9xG$d2yHycpW}8}lNb>dVy-RB+$;62*($NQe zV>A0_>0>wV-|w1yF9u6I(CAMGn=Nw{K@N4HzS^Xdy0n4S60}1#H7xk`+_&dRsU*>uJ4=>gWLBo&kV4!>)8m;1 z!{GxPiz=jbbr+B;!2(`{Q+z%|;V4u!p8Y$?zt7jD(x%U0!^_7rdlV4MhC%l_`EbDz*-?Q`4U}mQ5&OvIWxIiW2 z&iJ+ zL_72R^$1iQnnZ)N_pRQIBD?Cb!e6ec@WX?sxfj)Ah zzfKJEdpuNO%=e$8RgG?h<=Ez;SIrB0mB%?-G{|}Ln_=5TKUidhctJ?)PdhCwL{fCQH_m+$)o?ktU`@TxtnC|P26`9-?fY7 zgo8<9@(^ClCM$EW=9yTDk>#)1i%V?6_& zNr(93Oz_M1jUHc@hN=5!$VisioysRAAL~vuI5e~m6ZDTZXYHT$1>O+oIw~iolXJ!H zbCVgendZ$m0{`xvF6tT2O3P&MrK#mNF_zd#m;Kr^?GSph%3XN)&u15HSpK*CM^3Q7^ZPI3Q=zD=@(vb9-OQYMM~ z#W&oWuC>E*(hKBc3?iwaif?t(b{e-bYIr=e^mJqoVc)hgV)s^$r)vg78HvWNXJ<#G zI)@6Ge{DqXx_f6w7n|-i+n<}c^6fI$QnmO6%fueR6@NHsy)pVk-(YFEoxlcP00-!QfXOkF`3>DHfpSqmnEZPlRrUFM zWhjKqf7qWOw~O~5kFkzV#n?EPQ^+S%HR*I1e1Y#81soBTM|u5~TJ~QUzx>@IUS&81 zEiE?+!372;#0ojlhox#NfaO5^4>`Fl%MyF{S$tS?`v@F z{5S)d3IiVIl?K*3cpDNq2{ z0tTbXCoaTGLG9lIqX4LYxS-elxl{!m;ZTUFoZK=s>MKN&DDe*n%K;(6Fnj>X_ww+( z!v!=a1LtiS;7zsga5XHhgB?v7Fya(X@g^Uf6VKeFkVnlNZfa^C)5APs77rMbU{M4# zyMzlWRU{tMGNocv!-3&u)}f*uc^Jx70G9TH!hdjTW>`V_*4Y9LF|raw$w+GVZ5@t~ z66@*)nKENY3TAE$&?BQrOm5S^J&p?zwbjej)w8qxwbp-WTU-5%VtUDSlPCR0X&w#^ z_C!n`%kP`ysVlg_CInqYcu+g3N4|gZ9l-ge*)+DiIGREgb1VPTJ+T8UUw=Mv{QcHZdqvSX-AQXx&B_&eIECwt1w4`>&EDG^5tbW#^W@64eATP1GfqbUqnSQetx^TT{ zaO8RFle3m35K;?Bj(|eD7G^=qRE|_?kJzZv1`zpyHxS{_e(Lzan;4wFZS?kM1HLj% zro5@qJ^Q*999M7gfQn9y{=7zk2(>J1O|<`^$9MSKqUzqLqT-G5&g-)E8>5Gxe9b>v zM)g!RRcv+c(T2V=saF1?imfm0ld90Idx;ZF8>Z+Ktfp5K`l6~n=0yz80|nl);^8J0eewAN~ zEXHW3Fp=i`2|ehRQ`9_F#HBBIf#Uu`5Bc^ahF_gJZ6cn{x>w**qCdh}6eYzlpXyv_ zf6ku$J?}l&GoC;HcVI>TrRH7PMAs_57VYfo+G=l^5LYdleJ5hVyH4ByWAdBGNV&w? z+G0(3z?|~fHm!VT$sA`JU}3`GHtbt(u-iD408$Xcgvp+7_kJA^CH+b3zll1VV&p&{ z4en^j`bpkRtdNg-gf<5R$ACX0-{{H9 z;c3V|NJpn>)6@iSWUni#GzmYmxzO%DIVa$epw>co@E~I_Z6bKCx!LgYPi)o;Fm->eRe!_DOYP=scT{S&ws>BsTV{aNlA(QfHZ|MF*k|g*9F(0@q)S! zh2@2(tL;S6hJ4H^x#S1JwH=!yg*ZhJMb(!6J-z%ZxxCaxEKJVyN?Kh0ggkQ8aw60p4$KCPNIcCSIH1%5F;S@& zp(rf|6dIqx@=-h#hf)2MIof|cs#DE`p`)!2KJe;0>~D+X*(Zd3O->X1Oa5M zsfub>x1(w_nT*@E?S^4Kn*s=9GuI86#CSYTDNV{zz2EdhP{wE_6OkYlApplBulk`) z#Ovi&8Byg$Oca?p_{`eNi<@FpbUuvO&koHYQj$VQ zttnyWy5KrMk(Co;^=7#Y$+3@&2;h;3FiDvu=ID91+vHgx5RAd+O8v_fMBEv9Dq>>;X}kk!bmAZJM{FxfHo2mNR%-VMo#I0 zH^D+El%hNAl}Zdm%ppeS2GS};R$7TfKKpR^?s|A?z>hS!68j&Gl1y5w?#&zw9SWM;21)1BsFQm#LO}J;Qat8 z0RWLy0)ihhQxxTBTkmX@izK_gBcT8y$3znQz9rI9Nf%NAMo3723}h8y^4{gSac(f$ zMnFK)N;n_2QHT(|4;++~pom>CS>E@10Myn1LuB^O3xSZJkD+fHNzzBBhzOaK)KVn? zh8TLMjU*v6s}l)7u$1T-hR%)hJjBp8?P9h_(rQJ0+qkZu%%{B@&OiO5ryqTObauA9 zzK}|{gL7SNiwY5kdaH2w@{3=R5L%febb$PJ- zH5=JWF0{`HX$6f12&9l538|;Iyh{s3s^RvaH zdGTjIdV00T({WZ%7?)~3$ zrp&x+{q6GbvmZXazu)-YHNA%v_jOOGUOamgA>OPS38b`~PDV<~`|W;WZGEVbLurY9 z$jXtC`0m4PV82_Fn zm3eb$CzHwb?K-98ythhkHf;*=WHExs&!3z{jtRtO+kX1;d+3Wy~`94^4+SrULUH`+}v({^x65zwEW_$tDALw*ms>z5#(mGJv$q72yZSn zN7L+XxjQ)I2yO@i$ic&?EPwsgC1Cu)C&vQB-MX1p`DVZ0)P0qy{SZEXd6FRA@0v%8 za=&jft4>cxheN;KwuouDX-^iT7@+g9Z<4arXXdeYO~l$2P`rw>)Tx zb=y^=ys|d1caarhk*k~geO_dcXuE4uNG`dP#Y}3sn3kN9l=6T4^RK?SZ~yr7$N&1@ zeEpyP=_ePrhfhB~2_bY{F9@wxTFET8#^?vG@b8All8`bhs(=08|10J$#4xyF82W#} zy54nPX!=G=b7&f^WbgfcxAQR`_H_hiBtRJYFbwU`_d|c+h=cb&I8E4g^?J3g zo1JrkDFH)@(HQMq%yNC$?nl#c7#yHLNsgmTxZUlwQc|FcF-HLiF+mKGl#-B`lMn|>Hb5y}J-$%g<)k_b}_5g;WX&992mqYW_c37-5Ms)N^gaE0IFgVSfC&IW5e_j14ib_qQ38Z?2XofBnTQ+B_MJL%tMccMYiE>nGZM+|L`(2i)7-CUXd6pS% z>Skwcu{b&f1e;|=RSH4#*=)brNvrcb1A_5rDzunS7G$L{+MpdBS7lKK@A5or+g(;x zLW450uo>dFTHM{?5Fy#3oKB8}R8=)CN24+;Blj*isia^YqEl#o_@mD+t}f3{p9rCD z?p8;Oc?=<8BBA=e_UuBR$~+%UM|n}SU3auNTCZ1K*PWgnU0i&)zg>FYD`T{fqtQ4o z%c1X?19N=#{KYq~-o%(BL6H|vUOe0HckN;41KTXqQtUQcrDQc4%@*_3=3WUM0>Ak9 z`Q?WT?}zbx9^7E8F-HF*ij0vT{QDnnyOh$?)0|V{lrn{&Oy?6K1n0k}(t!wo0>2Xl zIy*Z`DLp?w$};uMySs6f9Xx&hc(&i}#z%|Ic6W2XaxOhOnirXBhZI;yW8YnEh5%N< z;A7plC&!C#K5R~pX4=sGa(_Il-q%gv*1!7IuRs6jbid!{N3-WokBwH_HqNHy7k~9P zfA}YVkmuR2zqvV@=5-$e(~HOR!s`Leb}8HS0T7}?^lQzIezl|WV7!+etPtO{`H$b{aI<1 z{N~;LwjO5VaaSK&Kb)T~nB!{Ge*V$%FTcJFk$>>wtnWhI4mYdjxwW@<`>yML^4Zhg z`RL<%xf+dgjubdu-|SBo5+Gl1Gjx&cY{F6vVu8CWw*P!EL7)Q0xOXba5Ne@*9Vs%hStThtdy2M1i|Pz zAv2I5sY6Usl2LMS{%~l{j>lJb`%H;(m7~C2*Jhc*6qS~3-z&uerEB{HNhB=Fe7D=C zgjSkP3_7=vNR-P4FU{o@ZXc||Ivc@$bMt|^`@!k#Kg%TqECiV71e(uESHwru7j!i%unuFC6 z((h$^`S(;(O3V*#)&C!k{_iYEB&3$w3aRPAX9?dk{JRFfzy0s8_IK>J)gE5I+1u~! z{2#~K`uB0AzNLNb>%(tY(!VQ@`rCT{!0*4i4&Pf&{loR)JH4jgr7hy`wh_QTZMXjR zB>%}e|71L3PTzHY{JSzYM3@+Vd))M$KGwJOQ(|T!eAx6`?X2IqKeC*-(;}E z??`*}-5dO-*6&E({zLI>59y&WeXk9E@9XdW;P-OpbzNtzeFzbVF#$+O@u4M2NFgK= z{aznHL?i(uek0-a{oaSeFg$R~AGSrGhQS*pq||l26~-W>$f0T0QmYUGN-d&b;uvGX zB#{6FQ%cbjlC@S!(X~V3|C_xxi?J-ruEX{j@BHqYU(7>BL`G(1W>s|!-PKKYvs>M? zL|c?V$O1%IfbBmU@Q0xCX2|{)o)1tmV#H>Qrb*&?L0%RV z(=3jI&>s&kFrp4)mhB=$l4x3Fnd?AFl=X#n zo~8y2(i$^@G#G%gG~6Ld0$jSo*w{!YC15CZP93{~fJj_wEekC;ce%y#yfg+GBn?8P zHa3N_5F(Gc9SBt_Qz|KipqybXrDwZHX(=;p7$pQTz=jwEm|`%75aRoltVl5CnhM8v zMI4u+$S1iGLSsTOs#YuUY{WfBWSK67!C+CR$R=8Ag`h|hslcz*ia~}!bKsT(v+2~f z97=$@t_D;{K{3%n3n_)cRmaVe$a89GK4+KP6*}9qM(>m(f}@sf>KHd6-tUU0C0EC^ltLmI`gRYO~2W9Y|n~?bntaE=zei4XuTOA>F;` ziX!HYJ-X-%sVu94-N3Sg!DMWE^<3$8%`Wn)(FG;k^4B{pAF1-V8&!R(L>Z+Lm4$Yi z?TS5*^X6i^Oma+6u8<9Ra(E|YjZD&^3waz-+jcCwh?96W^?aJfDL2L8$yrt^22icy z?oQwCV**oB!%fA`{90@TX8QZa$nv{TYI?UUBkFmB6~AXniR>zL;Y~HK@P+r4?bA%!@aBBVq!eW^PxrBEVIu5Y#w#%ZZap|4)496#itmr(g4p53AbI`f#@qAAHee8DjJ$Y#In7Ig zXscfR@T2b5MoTF3>Wwwf#fKkt(`el7&ySCLx2~;hAbM~%Vw7&KHb?V>S^V1OB0^*` z8~cHk7qZ)nQ<>~;bu0vrPQ~V0?eJ_usT(E5@%i-nc3TQ%K!CB1PbT$%OeV8&L2b)E zIUjFtG;D@lw=y2glrmvpWx|9Ndpt{~Nnw;(X@*H&aAE@`r8J&vS1R0d`QFL!@N}}& z3DQhPNpkZ_jr9!AUjUC4e8nrTw9nK4-2;p^yT}X+a8Y#ll@Qx5dDP@c? z#uSsvAf%B2tuKo=0U2W$W5y^#C?SLp`Xto+>f+>en>WmKEvPh(nj3;V8-+W z%mDOb+@T+SvF0W?Adq* zwo}TU{!n`P^~6%@XXlyCW&mK@US**Pj4^_x2Fl$mNtnfiETjNVF1^-inh}bS7lRTeRtF_YMS)Mi9jUp*OVOE9!Bb3DHr&jFc#|$d9!Ju2K)dH`owKN)QZID)_ z5P|CfvMt+=(-aXhpN)Mluxz)?OT&>iki@xTyRKKsvIHS?X+4xDQ^$5{_14khac7~G zjRu(VTxy3gZ4kyd@LWwGusx-eUkTcs1;_CS#u(!?&M=Ub#nt1}li{f6x;`?Rb3Th^ zli9?woLM?C$S9+Opqdn->ADvey;iF^lL^77Ooi0CEOUb}N_7&)(|NYC)FzCDjz6C0 zWG;}7$|5&PVV=+P!qrIn5J!pUTS=BMK{@4lp2calRPm~{x)}EfCC88VKpIUnrR3Vx zt&@|ZcB=)5jE4h2no*h>L2Zr+=G?}Bvn0V7MbUikVQg7E@K_S(+>xS4vm!%;sZuhI z0OQGIVw9+cp&R%~np|9*`L3%qvN_VAXVE-Q^M$pgEXk&`spp4TocI-I@4=pJ+lwo! z`;Q(00;3JUj{{}UtD7y1@ZCoj1Yv~HGa5h{V>CDn0YGXf1_TH$dmLPz2P1Sz1N6GX zdZ&$yx&NrEq*`p%LQf5+c{K=p&*}E21Pp+l%|^$kqFMLH^Z3U0!o%Z%(3XSq&}FV4 z`k_CZCP!yotj!Bo7vBEhpk8wp7wQ(bav?45oOZ|8cei}s&W}d#-#vZdrCYt;Xt7i8 z_XmTX-de4W<}jW`qX}ACs(o<(v{QAqR~OGu_r1_LyO>;EuiZVk*xl%ir*n(qs~fF% zJ~%1LavsN?vOSk?t+tXVS*TfO{SiUPA}Xlcj^){Y@Yegs&8q+Mt)0;eN;jTWMPQp|{Ygeeb=; z&8oMw*b0N}Y%qCcckR6o4sKjqx^=TL9*&#!@bGkWWux`Z?Zd!#_YQhdnyqx|nBr-i zy?AwF{^9;Yvo?=nLZ%N6`|GQ1ig8{P|MJ^+n~mVs)lMz&-no0wth&AaY<<1GySwqh z?fZ8=I$v(rF2>2ma+6zZG>a)^2w-iga&&zD!cOPT{j<&W#(b8P^W>Em);_p@IG@GH z;H~YI)AK%cy)-G0k1p2M7AWV0;Kj9dB_$)^TFKePsM)AyLYH|~W<@fOTT6=v2j^ue zceYneYSOeYQlrqdZQDUu1I(kG5lH4!PB0>jQkE5pSwt%2JC@Xv!ey-=x+L(G6n;<< zMUkX}FbsfQ&leIcE;h8(%BUih6~`?KIgjR^!{_t3-E1aVh7bjWZOiQqBMf>r%eW;m zkR&N=n_y$gLfM>J6)%Yrp_E395tPP>NTOUAx7nPHQRO|4hfHlq3D z62ScNcBMZPOdBDL31OU2hW^Mn{`2vCK#xA3s2?FfHpVzkpr641f8p4#KU1;^0Z0Sn zX`+EKp3R~l@Sld!$abwX;@oy9WeB6^^Ebd~cD#q_$L_iaq5M+*j}SswD}?|I7*4HE zrWemK9Y2r}e4O<>{q>|5$a69NXXPnRY=Q9;ox{gD?Xx`Mx$N-iZ8l(xd2V{mXQrPB zJ-1jsbA>#&Z9gG@p5-J@_#yPiZgHQ^N)3Q9mdndBN1!p#*>LRneo+*RG0GS=NC_FM zn8-_ih7tj2iG&aq#RdatsSy}iV9o$jP6$Yqrl~QQ5@QTD1~fKBAt=R!Sy42tRs1ZA zE$S$Pl#m*feeA_n3-CMBoDB=a2AxX-<8o?ya6o)X(q zNP#LCqDm;&^8f)uHYP}Gz}!$uImV;us1k+%h9IjHQM2AEltM@XQfZU~j%(TW#rcVC z+pIzXXf&T8M6}YP)E1)@TYwb8yvz!W0AW>@!twng%XuL%rg>gsL@1-kAdE~9I%$$3 zV~8=AKu=x@P>M1}Imdu=DQ)gj3VCKYz3fm31{vF9fSJ_l@e4Kx;sxzOZyz%~{M7(6Y0%Je^K=T1!b*R4e{$d7P!G-)Q=tCzYzs zW);uP)3lUww}pie^~t1CZ(>XU(9TO?mZb4)TB+CP7yHePZGyNEMYlIj5F%jIY_5gO zlgL}$`J1m_&zx{RnIb}DQCJo$lAKv+|KXlc;@a2#hAu@><_sZO7D|Id&3G0uMkn*6 z)*+3sQj}T<#cutzHH#Ekwra8YWYUfF7k{G80A{l(B}x=!G#j=8$IT5R=t?!{pZA*; zTIBL~e)ShkDK(%nR|sIH000~enZ6Wq0swFT0I&(Xqd)<;9*zM#kq+9tM7vrYEC0#pHkfweLB^wwZF}{6;7Ejqi?QsWz57_0V+~J%2R% zxu2*f+Wja0{O*nG%m3^Dar>pK9VCm;^IyEV^{;;KJyDcjxxTo*y?pq1h>6FjE+^To ztrg6;)C$(QnqAW;HCeyt-C@csyL`_>{tRSDzJN$z;_cxZCYnz?3eq;b$ zS!*nnvOgFvx2yN}&c6D}*0 zCaEZ7S*uu&&qmia+O-|~(dkGCx!A7W-yfExdf`g@-a)@v^|~@r8qz{u-)JDD&bzZt z-JMR8BG<26UpVYd=V>vTL~$l=Y%~YcWU13Qy%@Z5^U6n$kKes>y0Tcmxx4&u|NQH( zZoc{9iB=LBv$4`L7@wby1(3sDdgIzsnhQ$V;o#?GGp08;ed}p7$m@>ut-) zj7EFMgV2J-PF)j30sZs~OTYSi``_Ce{IwUC{_yeW@#*;HW+TdqhYwHJHWolXvHwTU zvL^%xP&}I;gfOK_ivQt%`+xq)fAgREu0tvNp@{OJT+7w--SzgoC2hbQd(zgna(Jsf#(%PG@Zk*d#zvcJwP_I2BDXv@PgB>iZSH4fIUWxk%Tc00 zgc3{~uUh6YW%SDWI%5olB+IijNs(n&1Gh+13@Gq|OHJD1!V+VY7<77cLM`gpu4}V{ zqmwj?DWy_~daZ^qE=qBFe6VwMcQhIXt~Z&CEXVue>#wEJ*pRmCgjqI62-(~gN@?k( zWkwJR!|K+y+wGoLYZYY3!a}Qedgi%~=UNCM+jTi579-qtFhvAmZ7=}jd4Vu))hlIb zdj0Xq`4A(h1hyBrvXrexb1>|!t*ubZHOMGRUB_NqTTbQ)ckDulT3Ee(`}URXop{*i zoMDP|Szt<-&9%xIx1^9+mJr04CYKtndc9GphIv^KAdGWiOfrsYo!0s3iBhJs)K0QY zYi)B5QX_;ox36rsWm%q`9D~$_51$Wo7~^}7x<7;lzz85MHKz13BbGuu z+2b(62+xLtLeWOm&r5Z3F#<4*`-qVKARf%h*KV%$rg6h}v>r67wiNca-`e}hS2hsk zCkG=xupi!k^zs|8mPN*lYPW;Qc=n|i*So`{9#)S|`#U=;vp6?NjC9!@6f2#|KqX;l z1ws4v-Q%ynaYKqsB35rfe;5^oXjB4DkTy6^Bb(Aj#je$YcW>{1>6NYhqw$TM_HZ=0 zzjtL>b}GTWy|a4NX@(Ws_aX`%T|?n7Umcp?4J`1ufMc5Pl{aYs>`R-bY&^X(ui|w@6qYX zO6&TyP8Jo2BSx$=Emzh$_a2;I-`&u%xhgN+Ks*ab7OS1Vh@HB zo6#sKr5cw)ZLKe*MIk^VfM^~MCdo$!y{nr`{oeG8FKvGC;NJC8K;)TvQ+tgKrpzjZww$x!itNq25mUSuI)RXlf>C%KGjlc zqm0DUZr80`J@6oj&rgoR!0mT&tx-*cP_lH9&25$^f?70==Zt_<3Y!8G zP7yMMQe$k}0zimTqqNPj1OTbDQWQWa{p`W?6v#rKP~jp}2*oJ=^N9zHF#vx7D*&Fz zuNi;upZ#O*h6v%$W1Al-uK67O{}U{I^OW@ZE1K{Cg3l-d0EsYRmi>?Z{@4GrfAq`v zso4MNGQ;T7-xAOd%Kwel2q9w(rS$(tG7A&i50?hZZARG2@>KK-2j2_a-Y zO*20yHT$@O`!hDgJn8KK&j5>ObB%tOXz%G4>S?VCM$f9>p3`I*^l?9V{IN+TG9Nd1 zM4yxkqK`{&;2FE}^n}mRH>QAsQpd8Hj763!8*$bQVv)xEs9J9%^H@q5&1T9V43uz; zk&#Mj(AXft8Gy9iN}9|mVLB_Ct%Yv)1Y=Gwy@o*%LOmzQ@=R-`wXr=L1A(l-1oUNZ z9*XlgHAZ7D%d)_rg`}=!DHYq6pQf3GkivvxR2CA`(sMkiK@^#g!nHlEl`JLYlvx&N zD73bGPv(Uz1!3f}$cS>LN(lf!piFYDO6~@6nrf}*Q5?;pQWTueZL2Aj)LLt;s`Yk0 z>j5H!THpN_|NB>d_CMEBUZNA13n3Z}TFr)1S}7@o=xpv3Syrhxv{FJ87PI_z1!JR( zMo2rZM=7m@;bb^O2-yy&c8CdSEG>z=XjQ{f;P!eYpHG2Uj_am*$!JokH@FvQDFLB) zK3m;ga(yp}bArrpIM>G17gubH^t%3Fn$@aqRu=VE8}o|AO`1!sQtnlx$nTEG8&}=8 z?wsGcy3(8U*TW!ewDp&)s^xLTO>pG>t z5+DJnU}&ywo*y3M04o+m1(X1`1>gO3dOnpk2JZ@x02ts4|H04x()g%I;!5ZjT^UT@ zv(eWxkw&xl{SOPzj5C=H&$C~9{P=XJZtX06=Q|JT75C^!<(i%KCU3mB`I~P(SZTRY zRw8XyJH^`{^){;3osUj_{#&=+-#E>@IloOi09MiRjdAANj>B|LAlQI7|qAb#0+2^69}iQ*<~t z7$O43cCGb=@V)o%?_ODcd28upI6mwpwQ93jAjh_j_C8XYUfW#cM1OcVdi}=YXfk_w zw|#s*c5LoaiB;(_)T-Lkd3x{uF(G8R{m17N!E!6eReCmxT7k`6 z+^)I(X^b=hf(c<#h(>5%^kX<_wOFP_Ju15;ZD8s z(f+B;@o9hZ(b4$YTDW)E4};3a>eAi)(Zj=Te;f%>wnJxSrHPF?J{z2M#~Z7Q4CBMz zWHiY-4L{4o=4xv?j*ok@YBd;5rn9KLvexR2W*E@nasSnqR~^RZQJxFY>rMXf?(uRv z$TImWzq?lnysK*sW%OW@6;encjJebdBLF0__!$9!3Auc3C@IS#Kkv_~vZT!VBcK+9 zz^Me&@rZM-lt6|UqLBfa<&NbBUZ}O2%_g?(#Pg})c9IoRi9Dy==0a*8W9qo+WQ+ld zJX4}xD-axI5@8Ty#5XJzd79q7pg)&MIBaSs1O_WwL%cL=uWhGiDpo@@Af8TUSZeDH&)hX%NIeH+r!AOI}@5XBfUU`#|B z=V@-$gLpm-8?7vkgq99tg0Uhi7`IBHl@UY%x9upJR4O$=yR?4>-p2rCQq#`%kq*?AbmQ5YY;niw|TAWcDRw~knQq&&Yeel8yH{;Pb$z#W< zEQZx+)bm`sjH7C;5zoiKF`<-dUBpA1keM_s&!5TM7-CZcfI=^b^0?Dzj`|a&#m4#y zu6oqgM!;Y)ih2XPVn@^2Vtb(w$_NA&1*I_Hzzvf;HA+~%;}VO(aUL9dRwOlHNUmv~sQeHZt~@%CyvF7m*2=5Zz^ ze*NY3vy0hTZ@T#6<}5B2ny`1&Z&m%<_s(zbE-fu~{4m@*o}M0eTLA-V_xow39{%B- zv!8hV%JFf3d8zs6(Q(7)^9d(dk9x!7W9d0Ke$?H*y7cPJ^)xRZ9E=EN8ta9cC(7bt zFuk(eWSnQooZ6Lt`_}$T*H^y!#jE%CyOhwk?;bNFg;MwTPHye4Tb7j+YBZV)Az!+& zrlh+6sK+g;42g;|DdFbM()Zrk8_iOS;O+HVoJfPYK`Ix@MeGYV*LuVFygQ+o7!cRC z+EVJpR&_FsZH9e|IJPwuW0~{*Xwq)C7TQ&WU_6}LE>%)`o}B{CGPS$2oMhQ-8hL@= zss&PjMEdUi6W_J(KRCcfhV?o^v^S2{*V{!=EVjZA?;jJSN4@E-?apX2_bcxDa+pNf zqy6(YUca_~&~t42_MOvLU)o$421Xgm$D`T8LUU)Uljdc2Jk3j|*>puA`{VISr#+gdjcT9)0bnVNXgSQYb}`xYVGa=?JGJys+ICOoWLlwl>b zM8fr)@hEaR0SyM3ER)h?%t1yK^{Ov~k*c(iVUFwAZtvp4aV<=(cFhqQ*_DcA(&fSiuwV@6M%)PLtikvd0jmoCe*|5hf{@~6%i~wPrPexWHlv0*?{>{Jh z_oNW!X(Oh~Cx_9>7!yy2HFpCL2GCD2n$N~l{>mfT7!yh;{}crI`S>jO6Cr@nY>uOB5^3=2;)y=%m_cv#$CGqU)G{)r7-@SsQc5?GUl&Z zwbQ?wdKZl0vY_WKq)IDw9_Jf5+ zpZVf*|AUXQgC7zhJgcQapY#ZOQi-CUb`S^SR2SmG024wPCxl5VVYpFWy0P)$-F-sf>Pj;e=>Pt` z$A9z7SBIJIon^ylw6j#XvQRnhjV@+o-M1cJ%wN2=`0oDMt%|+2vT%4jYP9Q*j)wK1 z)+@`V=Pb56l2sNwUxA#?=eprZi+<~kYfV%rj0296tf+-GW#svAI?7F6{)Y^+UVl)l z+P)uTao!)#s-YJr*-L5Rd#o&#L|Q9d^M5Wc3q|N|(sY*Z6v ze&?MDBJ7>p$5PAw={>EnNSBKwbBsE^A6rO&?+;HL*FQX+F4wHvANDUhC0-=4CiaIP zh%fB41ZLlVbe|FYGp}CxS9kWmacl9r_q(OSnKVh3ee2cD<%)Zh>IT3%O71}d^!bW6Ha}M z(^49PZ*I2dNq#no=oC1Hv{VM;wRY{eHyfwLWFB?u)n?USXa{K`=4l?qk}`r39QEc% zmRf6!@qAwq#+y}dmZZDuO(W$;``t%pvzuF;`}^mNGR&N}KRo%$OB-1#z`$xd+&`Y| zZnVC4@5m^#(y;PUZLKuAgLzo7PtL|C{rMMm7q6~0e*gWGFW=g{{ot(As=afsYk*=} z8l$eRFSbKBN(8m(+uz^!Jld+*^=gpj#bGzPveH^vs@}PKY_z(v(MALjijz1gT{@p9 z-@ls&F4EHthMqi@ZBoq)*qv_#F%;}&GLozl0hm@Q`>eM&Gv9Ok}{_*SB3H& zR~Vy`7$b!-CLAze%Oa!kXt}d!$XtoU^83T+Gq z4H{j#?Ej&QVD^;C@G&DCgo+zPo%UEr4mwW_0*W-S=qh$Y>weG zUWZS=XuyEh+GsFZfyP>c*2ZW6jQ}YCFh&^-T4SV*(FU{zjgVFno)$Z3WsuPbBdw$c zq!rQzG%{KlK-hrR8bBKaSSyJPAVaj#N`cgZV31l%M1)paAw&%@(1sYS|8nG6Ptku} ztyQ#o^3}c!uEw+eLc7yhTs%KN0|4K33FSp07%@tgM9QKl3kgUHEA$*c%!SmYaDz%b zPa3p>39`98k4FeTX-@@k<;vP8H?}92kwgi?m=mg$zN~;I1Q~+^*EdQjtqCRhe8#v% zC_TS8UtC&rsug7P(a}+7VYyQAWhq;&CdX82iNIitImZ^W2(f^e$#}|Lx7BI_#%WrF zwFWVYFcMblNg6Z8v;@m>@+4A5=~7{)iPG7mx3avH#519D7a$)EY7IXxgqZ0vPmC&% zQK%3E8Cgo=U`&uDYOL6;VD6LyurAg)~MZgeUaxxe^72p2J2>^s3 zlVHq`LjxcKwa`kk(ioJ*(=;JBcRJD#ljES`?H%=RU0=JnnCc?EzR~)BMQ# zs5#?EE-$y{nNHF&Iz9i%ue_AxMLLhi^E4CX)uwNNjs~OQtaxiUAgn{ z*ml`!y%u=v?&Fcscr;6@fq!*tX*d|KFE;M%owe#!-(hEG(|XlSaA?$G>Y%- zbq&E=o9+91=PzAbd-sE*PBWa$($)1~p;ecq9M7ZP*tDyD7;uTu7hm4_=+T+Y@!?Vb zt6$oAxIenG-hAu5J=?-Z-O+ld;bSb7JUkp?LSNqP+&k!PF4j&iB5r#h?2lL4!J8i( ze)YATvQV~T6=msLOqQZIO4k?bxz-Q%E~4q|wO4jpt#EI@>sYwesn#mNU@{LX!TB)0 zy0v`o-btLMomPb~G#VwAWo@punMHep31!@JcyAbaoJ3Jl3;lzmUM+NXcNepyeD8xt zx2~@RzBismr@g5msL;B((0+Vy-mC|AAIuOaj}e4%A!MuK&5{%|Z*6@U1GtWN-XB*y z=kRnO4K%CX@&bA1Zui9->)(BM-?hlCon=EYqvZbH*-O_}`opME3#QZgcs!?wxE->% zSOY?mS+cOW@Ob}dIGTB`lg(t{+SBofGwY%kNdwz!3!Kx7?oUHmZ4^iy{_jVKH89gjue%Fx6^sad_t1c2IR)iKp|3AXH}4 z*=R_)-DuVkv&$rRJjV$u6ys5EIGN3+lNcFkdjUoUVGLzqxxNs^&W-EC-nl4CtySO$ zV6-Wd#^$cp^746|%mx5}z#z+erqeV=8?DU`025ET|Nd3OLlMG+5X$ir|DVstA3I^6 zR{;FzS{?|)@biiIqly3!#)M)*KZg4eLI`KweMA_bkLCZDD=$maXLZw*QuCvE;Cwzl zAOB9$GfbE^>T?GDlSF~RK%d%ZApnCACWKMTR!V@;U-{ZkzWerj2Cz~>2zBZFBZ?xZ z)};`R!=#jiGC-y%r0Y2VD5%w>C`C~kPJG4+QIvUUyPhfaJe_jaF7k9f8d|<@RXAr3 zqd3cQ&$Y0{Ikn0%3J3$=fHZ{vF|H@J&juJ#*W>BSS7ezT3qOW{m zrABoBqWhbB!@z=!F(oHBHKHfo?6;db3&0 zB4?4VdRG3eZ_MI+ZK?IsU;d>M(ewU@U=Ttk^VF+W(j?)O$g<$JU8J#*CNJa3bV?2L zYkoYNF^s?Yvwy2dKs}Z=a)jK%} zTtDFIcoH8yyt^^oedl+7s~r%Gu~3325E;~Ned*qvH^VpnMtXER+pU^{l) zn<4^PvThNlQffjJ{dp+;FbdH>|)tBc>ib1Fb} zXW}bYsyEiFzxzw_26!>x%*9SL)VpegC}Esyf=NH$14*oz?39`_9qYQhV=Y_{Oz`{o~<6 zDh;#&Roes^ajIO;~inBgQw7!kr28$oZB65G4F z(KtNnzp&NZI~;ASH4ZQ0!8C3J-bW{+8|zI8_=W9emg{SqE6S+jUVLM_Ew#!EvCyg< zT@1c-bLrqBYK4`pB`+)TI4Ms0b4ExMWgCmt{qFRlA6?(-AVl7}bF#fsJ2)M@u+^GO zvqH$7)%rz0ViuLSyf~ZQ*j=7Z=RmAZ$NU%SUnkcfWS^=;R{FGtZKf z;jqX>DNVInN#+wk0DwPh)BBinjS8UAlyduzCIDRD5B#vTuy}rU=5n{+?;?cDyr3B8 zWv1hjTb2UQmzF_*ZO##Mvll-sdH53nJAedHZgfAvLcsx8BK?? z$poZHOGxIEGO!e83a|!=3`PL@QV)nOv3zma^H)iu0F+e5XoIlU2x(~ml#~h~!1&V2 zQb_|^f)+|Ep$x%V05L`v016?b01?pANYI)wVoZraYcL2EQUXE*0E`ir1OQ`s8f(gx zWZD3wq?86ztU((MSQ|u$l#*aT25YQV-uRD!p>BQqpMs)JoJ~K-GF%1Cn_b_`zU0G71$SEQh60h8!}R%mUw?%!Zt~ z+@>TUgrlrX@;C#^sKvF>pjA+7pigdS#%Kyen;$GL0b|)(Yl09Zx-6vBk}?ZP#cZ1k z7KA|>CD?VPlwmEb1c8#GC`yc>)@nPpm1hZImTg<0u_?`PG$;z;SXSv6z!}nDTaM#8 zwrwFyl$5nv4G}iHIO(3Bag4R+F#`e!DsoDY5F(e%LaJ7663c}mw*tSMPHIb`DUHPp z;dU91tBn;=%8mVx0jtfQzKw3j0|>k*YLW7A^#$uIKx%`_Y4w zt?i9!vy&#JEK~0C&SHaSO4>Xh^%H4XaXKu^g=W1GHVcu9Xv!9s7BM@$ciRv~oq&Kr zLI7tJA;J2EM?y%9vG0fD=~)n1p5qdZWvP=i!xUqQ5HrdU zj0ATGs9Z|?>MO5a42JXhWOHMuH#|$@yw<25>^*X9XVg2hy+BCKnXP5ks8tDLgpl=H zn?Lqyq|Y3A|Kv1)NlRn2u`TLZHURWS)9-(9@Z~SRFq@_0(Y)sJ!^1A65Y3WmJ>1?{ z@Pn$Ybtwh4&KZ{ zTWt?U^U!mYRvSx|-f-@Cyxj^1Q}NdAw*+wOLEn>KMoEuA`2)j3<|)VII)d)NCs&w8Ftr?G!L-dc)6CGR~v z>9wN6)7f%AT3PPi`{3x>wYBy%7!HQ-e{j@DgCvTsY_3eF`6SD)Y_E)_vnYU2MV(f< zdpvyQ#%3G^2d8d0nFo;sU{bPjmM?W1E8RvIg>l4>PxWgrUApt|m@&TEZxYh!*{mqb zPrP{L{^Ju}RTmeNS8iR}KR)ZVVh;As-J>LpU%0&f#@9YDRTjrlsKmxb-&R$l-8?=X zHrH3;Kscv2mpdNu!^a14D4AoY<5CG#Qwc_Qnz5~Q6ot+}r!eo}GQBc@Hng^CwtG?9?lhv(xFAWHV2DJ3;N5II6jFh&PfyP3qMVFJNzA1P zd|fyo&IRKPEqkh|W!+X%TObeKd+)6G4gibU=t)`?0eA-B!2|L|I6?wmdq<8S5P%5m z>#l(Si1fWSid+!cNYw81=ktT_KHcYcOb`l)T-^Cb|C5Ru3#W+Zf|~CD{eNEHIpg&l z{r~nu076Avh_5qnAD;j~#M(KASmycH{ac>b|2x$7c|EV+nI|4G&V>rU{C9umi+}Ln z_09^xnTk)|_&dM%-~Mw|o>^0CV_Mz5F?xaiH=FH+C;=ljnM}K#E(4S*kU|l82$ifk zA`uD%jQf4?fS{vr)q6$=QgAYs5s?(OsH1KyoM4PgDZF={p)gfG9}01OLVdB+?rHT+J4zItw>FhHPmy|=W|DQ#Vrl}F?fZ(QH7 z-i4CgytZ7I#WAwDk^JQ6+XNt#TwZE_`qqZv{P%zH=FGXD`usIQ?@18SfBHw)dl7%{ z@%i8X<@?*){YU$w7kAoa$=0 zT0Sr4MfTc@TNlImq%J$DT3c?v^=R<>U%&i!f9b*9$ESm=`qA54Dh&VjFMTk{i!Xli z+WyIOYqj}qUjF(A$G28nqteC^ciR5wYuo?Z|NTbo+)w}5%m2$)K6qg@Dhy7d7g1(+L&$_gvl3p5Ffq%eUd>@7tKz4JC=72E*!8~?yQ%MRyaHxq@h1N zt0IK6;iQ>2wASN!xz-7GAMM7CG*Gek20TP@=*W|YpMMCK)>kBBclIWSU-~~202@MH zL0dxd%IDwsnJ+U1)_{y)^WXW4_m5_;U2E3!Y0PV>hhdN`^_sJB^^3pws|^)>1_YJn9rww zMEQKhiRI^*AFWAQ6;4$gMh*_>2$vxwwIRWx3K_X!{Hejb2d1g zj_2K8tKaWm3PowO(_y>RWPos($6E#@=5dwgaGcLT>nh=<`mN*x+ zag2M9%zF^tB0*`bS4wccAON%_u=+Fq@}G3hg7*aI$#OtK0OyFnnVQHkCO+0=;uHCf z)Al1qi$seA3qmfLCt^~0t+^1^xW%;r4soMP5EJZbV|-001!d@)v$em$UP| z`&>xI1$i%#5dcR-0*~JqKKxO0WX2E(JrG+IF$7`@)#vZD7V=v+PmQ!u<&`J@_1rHY zh8PMlpAO?RnN3H6SY~x1<0{XBAY}r8`IzxI?RZ@(9z4NvI2VjXp<+ywd0rVqW&N=r zFaq!0=GKn)?wdY9h=?JUy3VGv`DA+Y#&siVA|J;srNq?QYCeyX#$=M|stV$`kwk!~ ztFh6=EGxn=9gjvy+Dy~t`o=n1S35f$57RiAWO)z>Bsx7lTwB{*YBh$Fd8?VUnk`?J zT!lqd5Q24?WS$XMN!T>@v4_w=$Q&UHjF+tj^V~D%Bkpt=H(E9?E%+edR2wM+bOty; z<$<$Mn4wb5S?L2d)m#YKP_`v$UQ#>4I&4BBH7)m)H77XA>dR$=xp9;$6>Q|a9%ETlD(7h#dvo6 z=7!{EdNJvD6Gyh0M#U7#d7(JXITJxvR@bktPI5n-l~-Q4@|8CqeBUQ_9_^hD^AZ4r zkYD`#EoAIsR9uYmYun4a2N&!8MmrUId&8~u-o?e#gKu`)U%hj5X}z_xxfDh+4^<-$ z{^=VZyu7n|GRW7~TEzK>2gjQ$>E=>1n`fsd)zVUWG0c)kaba7{Fbadbrli)`i1rUo zd#$A1PTqR=@%1Y!MWOqtJi90lj(2x9JB^rg89A;V91k`(`gi}*pKk3$^-uiyMjW3F zibf+W4O?C6z0&PUCD22+8CSVQuyL$jytYp05yiEg#)C&E+gts~v}iXQd6{!2^Le?p z(&jt|qP!@pth#Z1b2`mly1M-S2Zx`yef^WK#rHoveeI>oaU?%@e73c{WR1&k%KA3i!v7~}@N`p#~*6A{TTeCCCV;V_$LJL}yj4hc*sKhoVr`W#Oz<42q)QLc~eztZ|4>j-X`Fk{2>fBJ$wKkv3VS8-Zd>1VVLNRO)In z%w?2nbFdHptSoo_k>fXoXS{EvU;5B~5^|Jg;z?gIK> zp#L9p|7Yx@v1!lb|Ih2YgZ_zl7?3A`=XvMf?dJ8|Z{gbj8br9Vx-uM&l#GHP{Mo42jS=@0@2|56_R+H#d_cwbnZ4$a@e15LFsU}8DnaF>B{Q+19RiW?QEXkilQ)54DAnm z_IfiE7IAB>H>y2=|MAzaD(jk+7GY!@?atjF{XMq=0oKxwzPLlRdL7*?aoJ&xd+)zrzTCR`*-o?l#^3yJe(t~ib5npOKP{UO)vJU+?t+JsT#@ZPV#`)ivI-}%)SU;8|h*jnBcoV%g#c01L0Iv&r` z-ik5Wv*zhhX`G8fsjKS4apA%BQ*~uI_S!TgkNSbNQX*boY3SNrT5HcOlr!TnC|ziD z-A7&kdc8%9l60+so16kO+K$*tyB(o@WwRAE z!^fw&cMwP6)vcv>9-J=4ILh2Bx7IkS^(MR54mnu|{^q3)AiK5Fd3ZcRj*>XCKAILQoixz(tg?l%qq4fx z?|kOQ&RY+Mo9(4rtIj*`XT#a7ULd89k2_wchV+afue+9+}7$8G@aw=SiuNh+ieDQq* zjDP`q`p-a59d>?O=)W~u>uNF=;wS&JpDD6gJ{gcT3tbEYU*`oPawVK2uwK`Nu5)J* z46nhHu7GiGjI)k0hJx8j69W!x;n^oc_4$AO&zjnBCLI|f=RI;pjB_Alj9KHXw@N53 zxwjsGPzdyn2*~N?+Ez82nlb~1-hztbI-imE&E8Jvqh%ezR5J ziOA72P=RGoch`h=|-f^dzO^4v{nT^)JZ-i*jrqe}8A!$m z0E(grgV>q6s*J?KgHOZQu@K-JOw2r@$Hh>{$4g3SEm*5{VG!BUa{u7$loKLCtJ66< z8G`pK>+5x1bh@3#4;~zyoZWuy60U@i6@q@-4>n}lkXL*{Z-YX^^9!)2ie(k00i}TUm;l=t=tCc42@12pirgoNmR+LOB zQ`@8S$+auXjaKt)biQ{qns&q0PVm-yA6g5&es^nq`QT)9evyB8ba8pT+f0Is@tl*n zbANC?E?>RAl|<+f#^e00_x3*b+O?u|5B4s0F7@|L#-=jl*umK>isW!uZmlo9_QLY+ z;b!gucOzp&l$)}NeAn(egR@4o-R!7Q&Y z#@Wl)R?4cr`)KamG>F2_-QJ#L=IX!ymj@T~@o)U&?bp8;r;We!=YRSq|MR~wnpLa4 zWcT2-kw$4E8cF!*pt#aVXY;D^uF+uSynf;8rn8n2937q~NoZCZa1QKnx0-vmzLUPSzO!MJRjsqJ32WzkJISp zjjLaN<8Hsx*xp`w@aTA6k&M`AT8tl!E??XE8-M1Hf8Vt$zw+quAN?Qx*Sq)jR(grE zdNip%|N4#h?(SdO>ObBaUEA(P(b@;QXE(R|Wm)P{Z!X0}Ssk8FH&>g3NpX2&W%u}k zOLg@4xZmo`@+?UCbXEw?U%0e+d_HcZ(ZTVMd$Zb)&n_mH)|PTZYimp1Th7_Z#S{^v zKn;d-p;(?*$7hq;81QCet)q=$Ozj<>uPwDkvvDBRJg+XTrZr%xO_>{pxvr`xWN93Z zXGIuF0BWSoc|MPru-jGU>xi}FrWOb#R z&DeV;IYaQJu^TJhlk-US&_vGoO|K!7a=e)DyQI$5L1-fD@ zdwl+gbCEPV-up0ZIcq%umjN;kwCFV0WRhK6jJCHnJR%7J09I=y1Ic)yOUsRMzN)e) z3B4miUpv=tcP%*Zo>`w4SzVeWP2xBqqPnh3WsGxC6cBR3sM4-Br4lL>(s9Y9Mu?pu z2aYk3XC(pDg_Z$lD81Fw$;@~jMR8r*aW)3u1EB48ayrc%fFbW4Fwd1ZsZbPQ?)tq~cFYX{yJRc#$G zCUQoMfl{Hh7Cg*!{l;F!1qaUz=K(Tc?$sM>)>Eg`1jMY=RMb)i{Z3M3^Lb{XIIgsp zh*2{!ww_M(waxBayPM1LpoZ3R|G`AxSZY|tyo1{>U(uedXBM#CfKhIjmfEYUJw>{e zupjy4#-uV24~MO0z z|Gmz+(X9N!U;Xce68&cS_VGNS`ucKXVBE>Diu9vzw7~*+YKT3z1>4=S!D~T zbzN60{iYC6+-w12x7UipRuG5=Iu`JRRYf4uD9G}W^NoV@(eP~Ux<|kA=IZ*ou59j2 zsMJO$9L}Uizp~UDmHsgEmsi?%_NPfAf9w;hfAbgaU)$>a+JlqpmsVO>{m>^bpN(=M#EqSm zx8FbFf_?teJ52bb5dou@Z*H8P&6heU0)Mo3-0!E7^RKga| zSGLzptzB)J&2}|7^}qyx43u>sl+xZhu-;nliNQxuR0QU+83t!rPV~EFbNYt-*(c2T z(;OQDK*ktDE`*RW$$CcKGXzBcU3C-A+A7cT$?U)QTVI+@2HEJ`=-NB`6#7L1 z@9aV{PtFq<@2vIKdWW8ox5hCB=)JYhI${h7tue&N16#bFz*=W@r3Dj?>@xxYpArDh zI7`-Z$tCy30}vAeydxrVMkZ-Bo7yTv#+(Imx+>-f$N-Eri(A{1MZhNn0DyPalY?(I z-@llxe?|Z-+zNmg5+Y+n1dMrS0l~YE5CF)~IU@gL0_WKpBl6_awC${Yf>QqG#`Yse zRRR!PJ;`bUHsx!{~L<$=h4Y-thzd75Q~_w<__p>Z<32qmO(O02wmX|t|P%X#N&Tbnou$&^u} zEfC^fi-?+WxU#-svuu)$mwQX-Y9UmVM$@@lYPa=xW&-8wTA@sk7tX|S8YT@>6?%3- zDqd-)=Xr@%H`7qmI+CKcJ`~c00NCwcb5_3Q7y{nqBz)w(Lq z4v!qxO%aAmz2$D}*ycip<@9X1)oS!xjp4Mn)Vnx3S>E1Q?)QqSvUNEa%$i9YH^ccj zzjS$LGMS9dFA&+c2ixdl;M{^15@Dlb>(UwRo&8Q}0LB<&hi6r7tn+@=5JNn>7~i_O zxxU&vJ%$-L;b z;xG)~|6upEn_GqFXM^l?R4Bn1hfs*g*f!GW(iaWT%7HAfedwWWBum)3>_N@{1)C}ae^X0)~5|Ml{5R_f!6 ztlv(rUtap^`^R6qb6}j`-ds+bv1@g^3V!9k`(sqY{#XC$&;9J*{9}LazrD4yb$ooh zw6r26-nTUS@Nx}!7~Z`)unDxl*W1Q-7K#Fcr%Gz zZAycmy?vu7a$`-A8^FMNtSd_nBo`Ef4|gvV$Km?zo_u$%g z+-W63vUlzuUcbDY&xzzXT>pQE5C)4YfSI>@48Pv^I{OsL2*t+}gOt0~}v z;1$^@j0wmS6}oQ4u@KBSo0WQ&=aCGYGtN`9*NiJq&LS0!G@OlcE`{I-fXhq0+Own? z9Uq?sQaB+HIWjII9|oZcRPDX@i~(d>+3NMMH!X!qR=dQEd@TAB)dOEwaSkEZq zCjk9NqXo%)bm>3Ya1ar(*7}Kx0s;M#F9wa)Vw>VpE;e7r1TqE)L>``m3M{4yzRlK1 zPttlk0RPtc zN9MBse?((0V5O(id)_-|jkU%aZ4H{bs;gXU?X3Mn|K^|i>;L6{5+{uyjJOa&NCfmm zLP!7Y6d;h-zz-Mnn!6nIKIn4X)1X z%0$g(ZA`#Cc+^HqA-poiRgA^X8OE3gA0`3k%3EC&b6r;gxwa)^(l{ekETteoMkF|R zB3)Z9$azvqMQJ>r%~6i@>`W~!?>>Cc>vUe)ZZnBy${9KU(%u7TMT#7Gt3{fIVd{{S zh^*6|JUC>G0SkyAP$3tB$b!?zm5?MP z6HKU(b7qYJ^43;J=s5=<#wC*+$OTH~c}{`@uqX_iGezy2t$+&_cwX0LVem+R-Bwc@ z6DBoBR@WZM8L%pdEV3YohzJ-mA(-F{xe9`Ir$=OJ<0n<6Bv*=i1Zy1^QVC#6c*~Gk zaux|Z5#!uzO&&Q%WGpXp!KG4?b5YhABI7~GnegC&3kG1k*L98DhH+Y1TV=V5!(r{6 z$M?>SBa1}j{KH`mz+)w9>%8}6Hj{x2qqa3A6M}PIS+zSdj=W%a?dqDQGu^b8h#z~UuSAen`tQAQ2qJE!$vbx*Y^=5(99*m~x8`|K zTmRKN$6Ts^^wvHDSyk0~WDI#@e3B+17fu8hlj6&E@A^jjtA}N~8J?X@zyGDBSO-F| zaB2DC{FKOUt;B;-K`1`=+UnBk8X_^qk^C&LxO2^RSZdtr#ol9C7ISSAGrMJNUv9KKcr+$f zcxU%qq5q%%;d`irB4|V^kb*eByE{w-R*Vn9029MW{&T;!8wYGSm|gCLzj)^;FKM;1 z*Eia~^#1YjAVb7LyYq3ykzQO2A3i#HaeKKcO>JFW=p>F@Wx^C*f9djcR$N(*f8Q%> zUwZH8a)Vx8TRGJ%uaS6gwI3V}O<9jp)Q^vvG?#|A&y}g4lP6Xq~ zk#oU0#IY*N8YNFeW15Y!=`f7j-T{Fp$*i@Eu@?AH$Q(M2?E-#G+S9S!=lv zNEk#RW87A?2O?xbury3PqpGa5HO^@A;H*y57U#r}d*U7d(UWs!Swzi*9Heo4ets&0 zIAPT6bf$S8MGXKLjRr`**;_t2I_P&>NxMHgJ8Ld2g-TqUo>aPy8=YRObFlki)M`Pg zgEVCB>lc`aob#XfNh`X}S_qpHZAF`oR_wR8v{ z%i|^bO{@xh^W@&AXYd6z@16D5cm|#{E~?q| zJWV?Eag+u%RFy|(Jaek7&lsN z2zZOB(zTirMUs-WV=n{l#zhsx5rJRn#fO;(Q%0eXs#Vv9r)lME6i5M(1WIz2XS1}s z>`Wb?DuG4hQA%&Uw zJ1jQR@Iw!mCWZ-7^t(UCTX&8}hQ%3SAEl3y6(zH(xU|u+qx^%TJ!h-! zcKh^TcT!ZV{kEIx!0Bo{#aJXto}TRA`owDo@80uD=_*Uo$dDF{jvsv3+FalL@b2Xo zZj5$6xHuhLT3w!$^QaN)v-2z~R<2#G1aCy)#b6i{t>1d#_`wJLwN>$0u}gW={{mw;x&c_7)= z_DVL*6Ja{*t!WLFraKQ#obg7hzZr=Xn}Qa=O3f8aO%#vdoiS9<))E1&x_pM1S?qINb)<9S(`vCgt0 zNd*Vl?!*W_P2`}+8=*X(PLB5WSrAoawY1Vd9Z%cMC;~h^neLsAZ(iamlzC|#*bg2Z zF1OQn@9*D!d3!!LokqktYxf${(P(3}^LT$?oqPG}@?bRMN~N(11f8Bv)>qqMnCu>$ zzIE@R`c`ZV|v)p_4{{H2)R^bqt;DNLrC1NvADH-nX4|XmuYs-=(4Z@I7RaAPp+dn!w*lwlGrh4=7WOc1S znM^u;X~}TLJ86iHS7n(t+ty98Ss4W3WRj~u5!h}oVW_eq&&xsvArNpB?M`zzoUODw z*3`yY?-fR@tc_BtF6ttIvNag9mb9GlR-T?R%vHGI%l?2 zNvzVo;Og)^zjWi8v*29Kn23|KG$vFsNg9MINTPBwOWUEY3Iws3{6Ty&r0B^5;FCG8 zr`-a|@SCyb3zY2%9QWk$KnMunJs={&csge+W5}Yg$z%%<%jwj6M^9Xd{If=xKCT+~ zpPNV!^fN3TSAD*XtbF7QBlar zlV{G@KuC?KqQE4W#&XeY8PQ)EUB11w3%-HFy zVhvD15+yC|93mir^EHx30OzeU8W;lrYfap2dkeNKJr&3SK&U_=XGG+@1CIa%9+3!{ zlu-x>PHS=&0C*5C<~7MVZ>=##SCuXc6-H5pab~(DT%^&5AqjQk_wZD=NDw;mG$=dX#Tihu3)!cx*?G&A<^0&xoMSWbT(R9T^>z}qRu6vXUtafG>8o2m;S_`ddaZ)_~LW7UmRVnM#J-RmT51KhnZ4r zeW~-tod*mYnZoI+%;)uV&|kkKobFt{k28Dx3Zb|V;4^YuJ8dfvOxWL)N=$%2=zS{*&x(S8p18l_*DcR~3q16D$Bq*b zHKKrs+{fp_=_xZn&pshC#<&oYd*X_0pn`xLK^R!1Cj<|XDdAhu`bGmLh(2MzY&phCIuG^IcGqC$R^WK8mG^Gu8_ii z^u+|8=;f#VNO%f&eV1wWV%W zR*{N;u_7x}6gyjyRl*jYNOD=}>TrK|d1HfWilU^hOCsl}Rw|65oFZBqssSQ;_` zU=ZRowAKp=j5V~k-daiIYFjClFpyl#EX7dUS_&RCVqa$#L&iMI1g6?5De}_m+Fxon zwY4KBTgp18jIKG#s1rrt8G2KjC1XYvXCB)~2PIwU#WP(8=v}}YBo1nq74~YJ*2M%E zq}GQ^4c7DhKx$qeGMiR~Y_?EyGp`tvudMfur#YkAgWXtNo*SIo*=tey*w(3bMWx&A z{`vg}-FDlVYR&@hh@6cWCL5deWO8Na#@+YsbQ!&J`O5pd`$|d4sE!laY<&3eQ6q}m zjd17Ej*8Xje9%}~$)?3xzfa$SrG4tf{bXTv`rT&|VNX<5wMcvG|KPv+6LmiO5C7WV zeS7!9RJqeNdHYeFFMgZ`@QiL=U4HY<0q1-&I{nP;7uHwTv!cBB@B|z&&R)2(eDCoE zBR`oGy`?64JUJgZo4obz!zf9vZ1#TXjk~vRuI?V3-+6EbR=<2>4>iAf^Khp#?P0C_xUZ_K$tFc>umG#} z`|*H#?|b*$eb3%|t#5tn`%b@cV;8_Y{qV`MuCLwN+q`mBb>_~UTwGZw_K&8ozP0y( zCr^#4FrKys)TFBCd)cd3b{@O9J|0(l2je`QyK!S%X}U?G5Xz8+#vo|3z01Dod1gq_`k=$ogWdhpGwyEIrjn2!I{H(xv$htFNx$qY=V z&55Kl|SEUwZjkZc|&B^|irkZ*5&Tv$D5w@XTZ9hNV9mPR1Nt zA2iaL)xqVBgNHAi-q{~5&3EVLI|sw6oK&d9+N9sjTnwAL`wVvN#Omm1_{gdLQQ#=S zxe`EcY;1LVoo=DBUJoGxVv#1o+#Pfj$h0b3&n#_lO#`UgU`#>=LIAB*Rn?t5@gDMC zPJ{_6r44pcj8e62)6|h0ZeyoNMpK^`Hb$qD1QB;OcWcL4Z;{Z0(t#mWs^7D=vzVl5 zY-?q-QUa(!8Hypxy47SXD&n*fWLLMXlPo9ag4Rj_-eo1s&Zp3LW#2wj5g_<*=Tv^T zNJ8VCjpFSSl!#_}e5hC$0U+ykQ|Zrkkklk161+Fo-cfplyA24(V#-KzS4QBE43tDv z`r329nB-l&uZR7+hi-6xmhO+=XBprtngB!u&??QJ|L1>)<{v|v82}(N+;ur`W_kFX z_~kzR|Ni(RK*trqzf*Ue+zZKYjKTXDScwv)y!X*bJ()z|;9Cd~V{5Yx61%$o^FRFK z!M6mkyEo{@f4zn9Q^ckPvys zh~M1Y>UBFxYZ1w^6p5b^5L`s9u;_Nn$;2im=@h-x+}=7G^a@1=$*i6{`R1F~ z(hy#F_2#!ceMSSdq#Yo$O?KnS99>?AaGV>EymK;wOFltH6~!8KKy zc0l9d&X(`@2Xl+AZGG^_sL4h_2@#264Bm$ry;sVZR4GFwQ6#i3hB)g^==3rMWUdt` zmZ;Orw+=aSjN*MQv920LG+0>R5L{CQAG)0`Xq^-tS2vI(86wBnR8>MI#Hc|>j6QIu zKd+S~6fj0B6*-bI0Ky!V(lL7P8t)t;k^M&Cb_}4aQWLlI#2{zVm|cLY2P-_ zJaQ6Dx|(oGRK>V^1WVcudU;zn{VW?#r$L$DesxoTyG1gcv{`0ey?!7uEYA%w za$|of&+-SBiZZGy$ap&a(EHxAKRg;w>fxl+X}-I+-%XW4fFwUCCi9OzJ?P-@XtXdl zFaZ0LNf18TISh&hgV513H%Kh$elMNWt`7D>x3fF0Uf-YOhi$j-CRd;DtH-ZjemSz* zdGWc0N8fk#mCpmfyn@3BU4VWcMBw%qer@f{(bkQ}Km6}qeePHO^ndji_itQ&pbJZx z3Zh@RdUGD14f-14S?0KAU%<&NYfn;fUgLx z2>W!_gVD@iWgy{G!2=5vJ5CW>1zW?24 zkIe;;j?D><$DK(dIu2Ox{p?6YTB!h`KwiIBUU@b6@XY((8xSLN#P}7dl86XL*VOIg z;Cuh(&$Q)uw7>0|nq&A{(Ja1unFZus8$Ip;`L&`MRR4!bCi%TILn2~bPe^MKQAo<9 zGie|IWbXlyW1RUHYOR@B0^gm5*$2lvcHA?kgtnTRG$&)FZH^^F0r$tFzDeRee;G;X zSs@PL?VEw_C;;3Uvsq2EJjS5jSu-OMMW~eeotNJXk)OPHCL%GT5HSca5)!`C8xMci zY#L{+a`mz3!qf%CPdai*^W_AkNw^59l*9#F`hmxrPCTWP_ zsHz58ArgV8lWNDIPq?GA)l@Z&v{6i=e9Hk4HC7>{8~~L^O08(E8kVlsz0jgfqQXpx z_=p-+t5l{7-w0~o8xa+vBjd*u}$XZ_x7r&URH( z##9iBRC_d8TrdnwN1>jAK9?mlZZ99yr)>Iq+Zd*G+Y{hhBbN(z2KnKr-JaHKbG>FV zDzsKMlkwh~Z(r=D-2gUCqp`;7sx5CcB`BJ2gI%1{y+PZw+O;K@i=16LbL#Tdt8{P> zK+g8MS<%@n%hV{hJeM)=G&Q-_9342V3#4gbrgeP}+5c^(KQphbuiZ7877*v$J?$<6 z0NP{)*~Fy9kN@Du+j9H^fA1ICYVz`p{pg)=K)KTmfPiqf3;-d-_dI&KoeXzx9~=zJ zHJcsmj}j#(POW*@eCfp-{eEYzoBP;|hU2p3N6s!J2`(=5I(gQ%?fP8qo3J)t2&&s# z`!_fD<_Ck-{@FFq%w*E9;55^uXe)Z*1-!agtRC>dmWLJ~Z8Qd2MCs^0mzm zJavJh+qiLSsb9SK*3QBpKfS*ExfiZJ{NUOHXO@vyhvRa4_o&zJy?Ns>$rIOx{r&Ni z7f;r%IXIX$CA{a-$;goe89<|)KDE?T4QhkNSOxpz`k@CG566>KAtHmws4C47R?~WU zvFCzQR%7c8sS_tV#PY)Hw?6j13uS<2<=eB~5|3}c`a8eg9{fvf;nD{_mL>7l>#v=B z;No=JUOKtBvwu`YoL}r-e*M}*51zcfwU;2DUg~VCso47Gt{xmhk{WvO%=+^$y|FiGzVoS5P4Mo- zQXASmaIe38%wV6tdU#?nALOc&%ykp`+^e@9UG1zcTU0H~FWhnH5oQ*S%#mkuw)bv7|JE8=advFq z?*RD5pj*J{WUTH=wcH=STY7VU8ouHddUq!P0s;kOg)}0Shc|)rEIf8GHdS@sbo&0d zKYrhE|6Qo&814t)$N&s1A$q8WN3L~BlTyk#j}ZRy-~Cs?wKLMIFcJQ=+wB{#_Ya5G7g^rgXOt= zKJ9f9i8Mu&$PuC<-FlZ$V)LXfov|?hGBD9`tP^6y$j-aG=o6rD^cV##27sSq#25!F#5JdL1tD8kwApKa~y)B22g?kfp`zv*bqE`O41B4vIH`T zLN-aNv%=cM2S1L*+BvjDw~p0KE&u< zR&1j!^u5%~~f2ngtckI_p2qm@#rlIWSeV`GUB z1;mGl$OOXC2hZb4$nzxCR)~Pmdl#7jF+?B|1yHpW5m}=lO3|D1t`PwuQd)7us%|xc zv+(9t)dsQF#^|-RzG{>yhU2MC)LYZ`4yW5n%cK1UNNyb-xN2NC1s}R5oQiT{q1!F8y-}%^zO^^Kd2ob62h(!UPo8=D%)fr_ zO_NYnHT$FX@rO?JvSjn9-7TrypT2lwd}1j}Owr4dPrtTts^FVb?e~5`SnZ-lX;BYyye|d+wBj^ zr!Uow`@jd^U%Ght;-!8fk3ap?U~XYNtwS^2J3P3svhc#Iubs9EP4UwHjTb)sD-7_@ z{^3tC00ZO*hXNgd2taoL(i(sO6o3c#@W;OE^S}Pfi$D6m{$GFdhyDq`++0!%{L;_< zGzfSA1Xvj49K3J+pZk%Ya7`7wC%mibKigJWIKFGLa+ft_tYIGk;BY+FDoKjWx0Mf3 zO9T(W#WYVj#=0DxTv@kizQ27_Dcw|)G&O=8VvGc)yEtq&{Ir=iHGK^~QbaVyoLF0W z@uk;|R(OmmB7ijYL5$(t*;7ekbz*`G+9@Jph`&!!yV;SFrs>=G^dGx0|G1K&lzRU8 z7eeq)zV|&bL_`F68-y2T@9SnV{EvR*r>BRzzOAG8cf9)Ws}$IwY1$A%T69DJLKR{} z6q|NLA_7~RGDqP^h}vl8KxDMl(FY(oCTblkRpDKwnRlT8yd&MdM-G<=iH=G1UtNa) zR7#-;gAzcH2p}9;5RnYtvjFZ6W)@~5E&8}N1E9Xn-Ez-U1Q2KQlXud3+5kwW7#z0_ zBO+p~OPyq~@mib6fU{5skIC-FX5P1O2f9#*UwZwDBDyPQ@|BC}-LC3xjX)78#jm_| zt6O9$fVT&+x2Zv*~Y5bb2m58dkB1K<+9->5R5+7p<5D_{yDW{{kg_Yfn z>+7e_5~%%yoh6js!a~vQRAn_BjwK?-m?c>`okZWHS&}7*E&9meUW7+Pm|>xt1%8*6 zTQZCA+~SfI?DPjonlwHTAqy<`i?VVVVvIo~9)hGqc~X>ZnE*tS^%rb(Dn%%kd(O+W zacz>s*jlY?ZHcs12v}Co74@bn5wj+r3oX!1%#+{-W*Li?Q0~ZkVt7|5}Or2@q^#nl#?I)d!J~^iEqkRZ;yq;tnU@? zyh-InBV!Pxw4&}Ks|%%fRpU-B4|WenCl-30Zqc@W_59)&UOaf{MBfyH=U>15$b~hC zax@y>-Wi@kj=Xnj%z8^JYh>f-uB@A}sC z;@QQ`gURjf@%dBphlfXlelZ$Pk0#Q~lFhx*pw}H3eSWq7TQ40IiQPG@mlpejOrKg` z{_^F`$1kq4K-KtHU%yr4c7CC=H!P#l^POyGbHCfkT=ZLe)AhyT!%v>x*cojcwDbMq zL*M!B!-_up>%U%3;>Z8S|57%GTes@vwWZ0?L9a-Z(P-6~UViQ7!DA1drn*_lb+<^0 zM1AOqlh?NHJBGu(rH# zYJGm^_RdNN9$lK-omAzVg^SBqZXJ}P@r4K0HuoB>&GzBpaLR2I1Xx>NJ^^?z8t?9x zYsB4EN2c7(h(}R9W24X;+7*jVj14wkiMWry&=s5)60)kRnYc0k&-*U^5h$9E#JWVn} zL!Gt?Nw?cHRSb})(IQEjhQ`g9++QtMh+ppneEU`P zw83{NSs#~>zv8qbA^{-8W_Yw80*C-Yk`!rYfB<=SuCB%aD6X364lpyvnXh1EW&vd8 zS)3c;~T*G?`Q!Zb2DQMAq4i``RFt%-`3S+gvgOWqQvL{!vFNMzv-HaIkIOF ziP0ZzZ_N0K0wT=8*Ahh#+G;vWZG(485dvHvHB`{AJ^02?dw+%DNXYbysOL9*cij! z=B=gWh3HUxP)c`u{k939DS*_jDktNtDA1-RLKJDL#w2ELW&LPxKTT5v1c*tJAfjUz z8^>9ylB|<-oNt<{HURzg`F1kBHXacrO?fz;OwT>u3kYi+b1*h(0RV!e7%(`eMFTL1 zK}Df$HBfL~8EaF`1`I$`PL-yVkVwV0Rf$zZBorN!2E-U!2OPz>;?Omf0K^c8kVpZM zcP`#xhH4^dJs=_(WsQnnn}h)fNNW>gln@-YjSmWuzypIyj4>)gjKCmB8Wk$nG!a2i zv{DWGSXPabG_{%1N-JOiB;erM)+lAHnNCaBxNg5gq9)};Q!q9MBqlc60Fg}$q6(pn zAf!?0G&T_s1*EB}7=4y^L@5ptXR03p2%wc|Lg>yfx_XL8B0|d8JkvlT0?f!90)rM5 z#>A#JYuk1v?PIfqMKFXIBLzmQP|!!#Mu9Q}#L?R%i%|=liM0j|5$WLDC=gswC<5%A;}~7k2AKc> zfe^tMM$`}qsBOIn#o!45EGp6hoRDUnADeB7A`MF7WHfqdI7JehSQNz~)pU}j>0~a)9*UF{^S!1nl>uKANXuy~zS(NA)6M==Uomp?~RBr2N zvO4Irk@xn7Q>P5IqUprSqSE^G`W!HFfN%T2g}QZ<$>{7ugU~o*;OVm~5TRlj`%ndQ zZa%BaX|I!7g)d**ee}fO)mujd5(7Q3)+y5Dwd;qfFz>%~s;sKLqp8tKp-d`w`R4wg z{qTdIeQ6`!Y&eETPc1GyxN>c8atLxTYL+7~y`zu5 z_re<+2mAZ6^}P>#@Zy}}#kIBdh5p#llOO&T5LKk+)O`0#o0H7y!eUi6+dDg>(dgVt zzP&e1dxKtKuHQOH#2-w?=gzEt_uu{LAN%jVe=&o`K{vQ6fo=;Q_zVA8Qmmv!7Gvly zu1D`?IxWocZT)09hBZ0H7~vjOy_skb6h(5Zv2dpnFvyp0TzzXjIgzIMiBnx)S6<@& z?qR3XX}JZUww&}Hcwl#b7ZLML9)S#^No=>@M|SH=>o?r>f$6<_2LOOlWNq@P&wf5l z5>o2zGKC;2LDbi8+`e-4W@HwTXW#pz)|z7!gx_;wH6#9aI_Vuy-ln~Kuppch+=Sn1WJ<# zV4?`C)&on3flvX6Ya1X)(js^tg@ps55)?ub7K#WGg%COV7(jq9QAiwv4-6oQPE4Y- z&C8=bP)4hyZE8dV%+vinVpb|)jzH11HIWu!)Jg&)DuKw%vwIQMEP&TBdLqR!!fYAb z11m5et5Ip4DofFM5w>~HRnxDNB?*W|6U5y$B05%+LMX?FN?TO3S{DKlh!9eiB$A{` z7^494+xI0R2~>c0KyW!GJ~r*WDaO}v(w@Cc5zUsH0N$&NF#DuMw<{ubq{&gaG?>>~ zDSEqRckG0Xh)6pdw+IOZzfKVj1yS%|=k|%S4@i`0U4u@>rB9OK%866a`$*o9q9hMM zqv0^i^47IQR&a2YW1FU;q}!eI-1?^eig#j>5F*%R2~pl*1q%YOfE~ z0Zs*|krHvPFu@1Un1W9LqYx^reOxe5`Ur?3(0UdMnbE^m`ql)7wrpL989?cy5mZ{h zi*^)p$mO$Ymhmuo3dMC=Nyeh7nNDp2sd}*AW8yds zXXcB&;cik4@>Cs8YMt3eWZa;T>g4I^ns2MQETQe~g9mf$fjOFtv%}iY&-vIUM+e0MDE1YktNeCFKxsBB-kx_5A}-|ciJ zW!vlKyGNtd`OE_n@}uWgtLVx}b7FmdS~dsM`q49sX{rllm8Sk&_e7d)?`(hm)s06l zo_J(^E%@;AYu9^;TAb^WwZk&p+}wHp6K4+g#wJmnPEHcDqFa?N@0or#A5Q9P8%K$? zmoA*Wy)$%ed(gTDpqnJGT)F+kLubX{XI{9rINz-r`@nkt^=pTzhRatDFKXD{9X@*L zR5vk2Zex(8e)jn*yQ3=FR6qXE$r)!^TRj+bH?|Mgm*>x)TD`fsms&E>J^R1{5EQBY z(x~h(KK$SkN6s`{JiR=ehNtHSO9Q>TyZcQ~KKRi8@qce`UnirC-`(80{k}`z+)uD{ z(rVm4YPNRAiv=zzccU(!ef0F3n^VZL8*gr`E_WGB(Xk6f^789jA9~`nbYqrhN4NJL zx^VKBf8)h&qAs19`=&>W3%wIp_ecNFXRbVaX7DSYyYgo~_Qa=Oy7DRBdhAsG@@AAI`c=Jwvy`FdLKjoa^j|Jm2x+&^_<@%3B#VABS)C+wvi zAboqM9!{o3VxRlcwJ7k>r_K&1wMmRb88ywNldHqJefZoG1CMq`-9q2Ib@b6E&b@kN z=lp6EucB!p)--t84o&0 zpE$KSakqx!)wQ|P>v@)B!?IrKT2aYlQa^NJ;q}8(m?B7GbnTo1$#Nqxj;f~U^t=xo zA@5jbMno;pdan%ukpk7!-WmW@Dp5`ANoS(G_i-{VT|FU)MjMKp^g4~h7~p}2E>0(t zBu~?#u*%w{uB)R_RF>mB>G&uZePHPh`pV{{kwt{rB$Y0~8URrow!@jm!uVO3lE8r05Dq zIi|8P0E)6UON4o_vVtJp{@m{7MhF2By>m(wkr2TQS@;8sH1DJT_s1V*PH=x3z8d}i z>L!3*w}Wr%roKb{e@6emKW~3v*zg}ej^4lX-{@Vq|Bgd%2;M2ch(d(HxyY@P(mC&% z%0=%@*3^^#;UE06Yif?sB$hdP=MJ}TdDn`F1U~k?Lvd|A<0lGpaILTaVvK=61JL4P zc6iVrp+X=$z5>&myW6CHSF`{Cnx^$_b>if?m6a2lH?F_=*U1PRvXPRkWDxQ@7vt;BTANL zq;-;YL83CIDW?*Jfn983TU(n(01C_~C_Ga!iXjR_)JiFhO0jb>dh&?KqErOH7)fJ9 zL?mEPWM%+da2`04ppXIvj;ys7jRq15kvRxL>l_Lz(uhFDfKmWxQwxEjXD=~&4~m+m z&hw6sA-Ira)`cKGMCK$bO#U6@;z@RiC5Gew7 zZK&Bxj4nE*jL|@-0!D*08XZ|*NtzRZfC^1pLgS;fb>qELHnlbpfWQHj>E!(w zTLeH&vVFr2j$&(@&#SaGgxic#Wv7AmYpmZ~r4wN!>PU{p5>p+$45?;^DPd zH;#7phMEGY17V)oo4woai)~Xk0Sea|lMpHAn;G)yTn%p@DiJrlyesmIdY-960`5xyT&yj=zW6eBM^|K$&U(}z$P zP-%taV|4XLe&EN)``gjAAdHBBs+tUE)7a_H3%vbX5~ZG9U<1SF-5iV*>9q6AUA*u)|!5D>u-oKDl$`L?Zn z87c^wm_G zj1)wUA%>X_0gK?B1`H9&ih_N7+XC_3Z+;l`a%Oqg3l|ZaWFlg<{_Kk{&ybJcBuf(! z;W*n&)TA6KWA0!n_;o%pA#{5S)wt>}4}@dzt#9kVo#F5>Npq0cn_Eb=5@t=>Bz9?G zVQXhA$%?Ml&NY;Dre)ddcQYfA8SW8u77-sKfe_x!3yz;<5wTX|EPz1Pxh3`}%BW>j zOiVyk;3QAI00xyHGouDBJru^Yu3@bgQsZ0SFN}C#K@sd3Q^hc!*`XI3ye9OXv@Ntm zqg2b>Ar_6^OB9u8^j=btHcHo^Q`iEoDs>P-RG2ELFfka@ENgTw&jnj=W_&XmN*xR53?w-85Vn6%JMXex8(P9$Zs71eUD zdwA$wq8D^>=$nCtDNy2lX>ghOuxdJ5W18-`wwvh8P!)KdXq+XZrde8F_M>XVKFvDZ zQ{!ryXji*w>UgHf^ydnK~Uw!>(e{|u2Q%^j!yt&`BO}o4>*x1?cQ4-yKK9iWM!#)@!Vor!{Jf+ z#KWhy4=20(<8F~Iul9PKvkFu%PcG|(13!79`{nBg&py1A6?q8Z^0l3BecyvE&>Po} z28CT;D!86JdvWbo$DwZIx#zEDiB1x`ywF`;9^Bg8`^-xlkDgn6_~iWUVfEUraX&Zj zyRh=hU%a_ISJY*5cu;=u$rE3AeQ&krCJhd!&Bj&*CVT$J|IYV*|6jW4;jNp)BFP@V z^ysgB{-&`BM>)CPf8*xC6KA?rtI{-o?bi0`wfdJnd*#gXTm!W8=5FKsH$Qf|Y25cb zd-i8Oc`XPK;Yv51ym0d)Po2KDS-$VmnVK!s*~u`_98|JqxN4?Ql-q!WQK*C~W#GAV=YSO}o_Q=j|t;@Zik zZX_u_`|9mjHJkN*-djA}c!%**9ld<&vG)b$joY^u2I;Gx{p9(l zKKPG+^hZDRUElNbpFg_%+^3e#pS||h^#Q;LpaU=g_#glJkNnne{^n;t^Qr&y$3O#g z0Y(4`fC6X%BEXa9R$e~{i>J=-zVbN%Ab=X+!N;Dx@$%=+T)0#n9sR@o?b&_);g5W0 zZ}r?S{P+)nRvU-0YjEo2;uB9E4#&4{UVHf2kNwH-`1gyVnOo@Z4_i&tx|moSVyGJD zTThyRSs7hUh9P*=y4&f1DokCYLI9ND1*|s~?e88KqYg*Y#H!8fn}$Ns z?~gY3E5x>KIN zAHUuo_s74rGQhn}0LT7WVgyMLBhR!n@hilC?$iH&-{3#wc_H^5fd38f4R{BTErI}l zlr|{$UJ%C^eF(rIguo0cpt!n>u9=P}PMe5e37X1*Z)iL}ntQ1VBXBCwzWEDWzxjK!_-S zX_88e3}6`3EJ^az)wN0O`sq^*OTNs#BX|~!E6F>mpxHM1evW~H}iD_L! zK!g}Yq^^}sLvY>)tu+8n$3u>x+bcTV?r48Bo{U#bsL*m-GeDwJLV_5*4}cJ(Xsei* zh%_>!X0}stWEK`+AuA%zM~#>mW0I7e^U)bCK)@UTNh#Di&k7S_; zYa|i@U?1a*uZJ936omk-I3$%MsY%iqg}0%g6RQ=G0;2*WCDuCc+on!ZBa#3pZB&0D zVTKS~bQ%;3V%^r@0}>#TP7)-g5g19tc^{OZpfYJ@atow5`esta=%Vv!o_p_!SpkN& z4Q&e|1i*nsfvbFX(05Hcvl?V(Yg4TiGJ4mB(AqSY7y$saLSP?fROQ4ol0qa65?$lH zukxaUfPxrW$10++TI;|9$b=|>%z!h7DFa9poPnOiF@_kGLPaJ7&%(27v8)&o6-7n> zR3S2nu(#GC5r+r_q!KMS<|+!NTG++t-DEf>OUz6_5Jjbikpc&Z5F#fT*JT|z_|}uw zNS3VT;6MQ~c@`Z43#O?yCKW;7)_{=!0z^a*tu!GbS!*0eQaG70nw3k*tQh_P`Y%TP!uvdqr8b~Hsq z6QV2fBFaoG07ilH(5mR#+TYk4XU4ct9Zg-)?*zeKw};v;(Lpi zt3Z}lS5cY$-JQIX1bl2lTUs2OIfEo8IKrQ#rSQBE$JS~-8;Vpq?!z8 zXRFBy0DuSzm9a@=7l|NB6w$NlCJ1RQjNUt?l|fKiapVY;<~a(5*v2*@MrLZ7S|M_9 zfSQp=7>GbP$+{slv8~dy#~ecAMSz5XRg$LKnh@F;0SE*bXJ8;j2zR7l?=}HQBtjnp zDFYIP84#IS8^bXI5yZ&C7yvaXrBEp)!MCk7Mi2mmXVi22T_;!oP(-p>V-4br{!iMF zHbkmzrbKsyd}FkTjX)B`qBw|6zz{>4rl54Js?)1$r%vdbH*c0zi-dQGF`U?R7XN%L zUZBXmEE@TmHx39A4u^+EYrLZZw70ttMi2VkUbnNmv%`^RK8pDDmx2f|FDjCd$Y=$w2px zdme{0Gc0TY832{){{QT~d9ZEST^{xu)>?b-Gu`2h-S0j1D7D6xgoMQ?1hE{uoES`S zg;*6RSM1o}a$EsNDV*Snod8Lh00BF~xI7RWjIl8?>-)an_qD;DOIZdWAuF}EO_u`H zB5evnARYh&IE)e$$0>E@nyVs5bl?b1i~<-TW!;FAdtjPx>KH+&uC)p7kue)acZ{** z(kWteb!71CMO(ArcB@!$5C`BmLd}Ew$YY3uWab#j1rXc}aR?C%oQc^}n{-_%Q6})n zdlghGn%5M%h`}gzVV&Cs%@NTA8L&ZOn#2f%5p1n>(k2i~U8nApYe|Se;4~V=YlEDb zG=l=Qi3~fX0)AKWFRtLy&faheH@A*>x6SMI&BM*zvoVBt*ZEVEbs0yhP?yyyIEB=4 z+vmBXaoem{a{qMFmra{Sr$lav#S|~ib~oz0-C090wo^?~ zA_S;th6Ltthpor&aMlfX>~`=@8i4Ph0fzPByZ_4j`_-cKE0p@wjU^Ml{+?6)dfC^w zx3_c9+lBM{*AG{>=6zld-gFP&ckcSK+;e`1!CBT9cG9OGKbWsp)#yKZ*TcW^sV9wS zw`(S|84Ue99z634N5gx*{{9dC=4EI`pLq6WxF%O`-1z3Nc<{rYzxI`Hyfkh3k?;wFXk)b;gH=Cf&c@$BxcMG2fPoZkaSX1+Sa8;>5o>7LWi9xWyp_G+iR-3eACxm{HGuN{I5TD5Zd;!t4nlu#LxfI}$XA+y3E4pFY(T4b89p_3wp0^TX|Q=hJ`v&#nh}*Zcm#t)pSN8M5RL zeC$bN`^Aqxb!NB8gun2Y|Eq8Ri+`2o>yLcyYBTDdIqdJhYZ?hJ?l$A;=wCf{@VRG? z9q4a=@R8SFm|nhhIA1NFIVj_V2aEanS^6jM|2wb!s{ddyN;dfz_= zXaL^*pMTGzkKFvoPyX010^B`o4;RCh{1JfrB0OEe0452noERfAKnidy5E;e*MPbuI z8Q>hi3Sl>aWZ($5D(nDs084-)fUvb?1aN>3zyLM?8Q`-&2bTd_00fu-{PSPFSN+b9Z0bx$qjTJq~l@HnAH)Y`R3@;b|NStR8-=qRmox?6EJNIk$iR zL$7HfAJ5m{aQErOavp#&(&1wMhHv_lO^6QzUb=MY;P80887}q5JCB@s=A$3vKllfK z&t>Z~7h^z`HcbE&Qv~qXbR0rpQnw~`QVJplaO$R2tE$!_M36VxRN{!b zQD?PJM2>vv{HZTKU9UZR_2R{QmTNh4X3wSOTv0J_I9_htvG02aODTZ?5l^PAyKZWo zjZ$BQ4Hy{_HD^-?ki1be9ko#vN>z^3gp^WKhQrukznsU|uCwko%^j5qBDgq)msB^e z;Qs?JtZMG;Dm|&!V%t3@3%orGovgABFx}a?Z9{kBH~;`r>vMGhBHjDItG9gwzxAM=$47w#4uw&TuYQ$VlkfbFOev5*3& z))>+ZFRX?1j>xLU5qqejg{q-mNmU^ktJL0ug@cxv>|KK6xof6W`3(I|+4`)1R} z*tia*n#!=*^j+%AfZEnwIYup_E==4sEvWid7S7SOcEret(NRHt7*?a{POW9sO}g<& z%-nzjoq$b5ye*|nwkE^5)`ZM~Vrm`92?GQqtXaVT$cbZ!jY(Birr-|bCuwg|h7eE< z+O~-?nyR`na}N-~C?!=Gbj1iUCI_#5?V}Llbtj|7#2ty*h+ITfka>F;W)?Rh%)~n(6U!*>+tM$Q=YAI@DZa6N!R}4CZDQ0-;lJ zjZI>t$SfiT9xaqQlqxdx7#JLfp~e_XpRqA+0%O~xR3vLDvKasbu@O}O(o%rf!K(=u zEjpk9rH&~Onn(^1dX=bB)pB2ui2{;&K#n6K3R){56F7#DtCIU@+7kG3nVT-eKruDF z+Imq4d^8$!1l9m*Qp5n}^VLU=-QA{BY*QDw8b%6ubtywGZNe&2hnmaa=I2lCu7(=1 zZlL?%0iYQUXN_LDxjb4dPo3F2xPIKUVVtO#o?y1_05DWJse#c&1ks@H`}Jzl zjdmuxAvLcAOd}$aZC0z=6ay_qfFSpM8@UN_Q5Mcb@0;H6>rqwPxLL~aG|M>TR-(UZk zI`n4hci7{gpPV(I%dkO82w*M_pt-1I0!9FfPJqBjN~QKqN}*{*39bjDLVORwY z9NE+zfe2Jet(IZ~Ob`gnH}ge1n{r5|u9^jGOIgL#iBxdaip(Jrh#HtWDN`^23SbIE z!CWY?RAJ_-0_Kilu1EyimBO8vO?4Zm3`=e}^U_YAuT3ZEBGM zsaMr)Yl6R&wRo-tzTw37R+~O2pQVv6A#d z1qkk9CT6LPC2ML~04G)z0)Ppa0(Xd+IFOn^twxBT8UQT2jhbkh*GfploIQg2Y#c$s z-J95s#?5@a_FRzE2o!v`VO48JExM^As)0i>*<%dpzWk$ZDwEMZp$EvwOfaglv%e4FHUY*J%W8V36t|Q!_z}NarTg z&pvy3e>R=<)y6X`np$5}8Al$9Z7|Pf?eS{8i(VXUSoh|8<1zkQZTW(f3;;+(bdo1? zk|aWe6qz}s)OO>)`d@$BX0`Zpf8`&Qe*MPXo&Wt;K4pY&xc9Edk8XV8$$3>d^}6#~ z<@dhvF7VSo_2H-QA9daz9-B3Un{4-8j0(V<&fR_bAAawvc}P z>0yE6&mGvRhF|^MwduHBFW2Aj*83kjtk-+`aP_8( zv&C|C+|%x~yLxl=wQs!m*{80*;hxi9ygt7=w;1tElODS=zr46IZDe;c?v+KID2*oR z$;&r3i^bJ{^?~u3^Os)#)qnqQ{@^$M`5*e#@BglycYM{w*Z-c~$#gdB!n!Z>>mPXE z`=+mYRk`}~KSwZzriFj}KSKrh!++*``{P?vtJfa+`1L0qJ#+C@fA^Q3zH+qL0l4QZ z-a7ERF6{oq&m7-aLI8NpgLf|k-v8s@J=$1kVGZy<{P9211N0eU106uAPz|O4OMnRQ z(|_qtn?eh42(S-u9iRmm0gM5j0RVtg0L^at&~Z_KU4|4Mr&cFOyKk#IQZ}`vtyq4kGXFvSZ zzxv3Gpf@mpwZJKaoM2br#?J2R4v(LWu&9t6-ti~D|B=7;=MPSw`^vBWBLIrqrJov6 zeZzg{pSrbq@J#&pqu0Ou;Rh}s*6RmLM10rXyN^F}v+E{jcIfH~cY^NBru(P&KJ&S! z-+KQH1Afz=`rf74JHGY5oQ<2$J#+kfzWu!!#^3th9}G~w*z8@p>+GNU%C9;&mYj#P zr^d(2buAtcrjsaOw-%+7f=o^}n~sJ-PTh5}fR8wiXYJO02c~Dc;G3bo>7moRJJW-k zi^+66YEw6z^c(TIxpn078gk2RL%VF&&znh+sTfbpERbP6k*Ss zWrCl`4D7}EL~f>tqC~HM>z5HRF@54UJ}M#(Xu5SZ6p^YTZlJ2$lFx2GR9$tOR-~rp zbn*!*a%U@_yH_TuRcetMYAuF9s47zP;7TDE)e+QkTc8)Hb8Zbe(gI2|_&4^|#*YE4+k>gga%bVf3#=ot@0RkY8h$@E|Q;Rf7ZO2XX<3IA>*40r+&7>O*DtmjU zR57$WckQ0%G%=|PG#XFL%9Tex?xp}5I8I07TL;(In}L}|<5^(-;qUn7|Kdk~dU04{ zN^WMw8cwU+=V7&3tw)oI2sPtThrXJxCl~Ku_j#`?ZP$#)t(mUpea)L@JS7f+QHu3_ zpW0SR!7Ut5TX@|NtX5C6cDoq21|wiJ6QEoRE=u$m@{8Fl=HIs}ce>m|cBhp%lV~A<% zpTmSAu2Rh0WMEDqMMOgg+ynrqQkf$V09mOerBrLFstyn%nIkcyL(N)6D5O$KYLS^8 zfI=w!;BE*Mo9#W|qw$0Tk)s*J5Mc}c5iy1RT{cs9Bql&4@Mx(x0GO%9hEvlLv6?Y3 zB33DGQv20lU{c!ABoBQ|EfJ~~02ZkTG#ZbHf}`htjfh%>h^o}49hH6++b*QW-K>Dr z?5Z(FL_{@?41h7k5Sv=Fi8!Kbr4YBsJ(4qrNSyngh$4}@ODSrO#4!>gZ?hajYD*qO z2Ul<=G&fSh7-K_(IoCd0ErXj)#%(D%S4WOw5ReVf5YR!5QVLCKIhgmGoxPcvZ&tk$ zsY7&PMyn!yHOCM*H3?1fa;}aXLaBu@hM1`B$O>6Bl_DE6=?920ptFmhS2wSk)s=wE z9b+=H1O%Z$cSA-pbPy}c`BKfgHljNN3J@C@lbTOcm&MGLIb|C{;?ieRFQtS@;;xfn zlhtAfiX^$_JdDPHlb4$FdT6>yz_{9EK&D7;ptU*?C3bTascHlcflxdUHlr>ut5_~; zgeHz>-6-~bY1`x;lr)fKDXB}tP)eU?vxbP8*tmkL4JNf#2SUUUIBPZ4Y7&|;ruM=8 zc)0GrxX@H3#JE*Sqp3T)yE%fBh*dLpfUI*b9H<}ilk*-K&hAe8S|s-mogID0_x#`w z{lK65;lJ_s59i0byE`!uH!xqUL-6HdO-u-oy2)*Sj5}<<(M(N6R;x|yjzjYb>U%(D z>NjfzLaC}ywE7^uu0tSKYNzA8>20&Z$yh{H9Yb6!4jjXzNqc+eZXP@vFy&gB81W?; z0EC!Q{1+elWY@LyJ3#;4eKMJuIY)K}s7i!sGJE#c;byVA0Fgj$zkK8HO%L4*9EgdC zUMTu;0N@nYxjuIperGkAcTIBB-aWb3Qd8(JUON5Jr=D(O1O#*4ESCFc&m0`yVvdL? zB8&t;G7Jzx#lR`afDnyxbg2Q!7E!^3ve%w{_XM9jyxZcJx8Y1En+AS~C* zv*$1L>%3WCr*%8zJeloZd-}->_dL+&^{`p8mekA;X=l1;U|Q<_>=Xj5B-bi;U%Jru zwHe37d_EeDzeHfGs%b56ee=WXS}8CgG7~ccW1Ct4nC+b!HfvRpTH$5w<`La1AOeyO zxt0MVm0H2I>vp76CIo<#5^<+l49H{?FqOQir62{4N$P-zDuPa~j)3M4K;*8fCzl0^ zgY;{KfFW>fJ2NBS&i3kt4us4O=$fm0;BD8vxNd;}18@^zLJ2`jRs37K6@=3`RxAwncdlAPd{^fycu#198taB)70Sqim^RE6h?y7+9Qx=1-JP12YV|h89uWYeYXBP& zt~hR7&AgiKB+k_U9Ajiv!@y0HToQQE;BFz2x*tD#JUz3kuyvaRM{^)`;D+5{Oq>6F^Ik6(i$h;9bi+CmcW6gPN2hkC7vf|ki(E_S zx?&c@qeC+aXy$#{NeN6&q0s&*SyQ2P5ADu^&~&(Y^oBq1hkxe#e?CN5_0RzXfR8qiGgJTq*crnw4zN*BfDG`+2%g-) zK0rt?FYuo4`U}r|@*BZbe5VBDtC7i4%g!)6Uv0WNm1?7;v| z&0xNOX$y}J@Tw6Q!PPH5G5_qZPXT`6`@c&%NRNK_H-GEHT44}~1c1;)s7Fu77L0)% zkof#W-~HV`^uE9NUH9I7;a%VIo>Mzt_hn!A^~?G4ZM$c>=@dEqgTM6NohhvP`8eU- z=c3&zm%nhOC0H)()D(^tCJaSkHip-|R#iJA-aOOm|;64F>am9UzRy@%r^+Vm5%j+Rf$gnv1ErqpN!z3NTYQ9-{*Ws*0#} zdAv@MmdC?-vt|HQubLO7?C$MLme_Pz6}6ZIzY#C|nLB6vB~q`S8<+Dl@}Pau0UL?OgCz2(c0`QYg%b6@-AVvX~TebXf{ z9QpyNDW#TDb1n*8RAm?lh?w%wvxK}^trtgO=n3i0HC)@a&pMQim(gNA7XSj*T8|b3 z19%zCz}<#g0&&TbMiJc6ErgKLs8k8e{m}P`8KX$aCCf09QW*kpEHbpCQHZVCcCYO~ zE+q?-l;Q}awq-I-!jSbgi2>lM;JT$Z0BOr{Y;7O60SPD0hR^@S$qP4iQwQ=bE23(u z;I2X{RclqLDn(`cLV#Uskt$B8LQbHyBI%v`0S6~100RVa6DcA=q^ea!7d3YRH!uP> zK&-XYn#s)z)siET5lbx+qG)j^Kr<=C2u5n6Xj(;0x6;CwFbc1XSHeroJMQ3CZp)Zn z9%c2H7a+g#8+Ssuw+GA3>o>PiQ7`PQe0fpx^Dj=$>ZM|3_|j_T=TYOAKg$=malecX z`XxVmF*Nzg8tWGw5$?FKFPaffSU9uo5cWFs>lG8$;)B9p`<2h+%}UK@ySv}^HLoRr zmY|!oF*QU4fYBl{6VfX*=YGlW<>kIkc=5G;B{}!Yy!+yt?Mp)Z&v~|hnACzm>RwB( zCDoD%Af!SRvl{fU@9sE;7ksLz}pGe%+L&gv{r%YvQ@c>I|G>(adsfC zB_lEcNy*4S%y(J_Zt?8i$P z`eO#j*@$td-Zn5)V1o+40N?kszm)s+bGeRg-nMbM9-0s^@?^UIJ>T-Rqc$~E*Q>tI z6}7~Et-4tqZqm3NhP=BoD??w+(AXRax3;)$$QYtOuPtju5kvpR9%B6CP7rPOre)aY-0>?5E5)t?_ky0)9_?zf{6 zAn!C?Y$i?&6p`4yf*XR?Isn4?2j50a*B<=@G9vStv*+{W%OM6tI=*!?SD5VV19-oh z*Q|)J+H8=JV$0kIpsIpkwU<%X_Cp3$k*vl>OpM*QbvJT#5o=QwG54Y05MnzTfr$f% zqN6fmh!`ERWGFSZT?nz8?3DSf>xV}>$BTy$#n2366C9$u!?yE*AW#w$WR8r04z9p4 zcv7iW24w0+V<0H~pcctMb-+v^vN@QVm=RKJTj@7M1X_npMFb~qLkxjxf!mJB98!uQ z0V2o7O%k!2J=cn14!IfuRmq02=>kBgISWc8vKR@8L)@bJs>;kcS1Dz1ii{i^-8e=Q0W>pcI+)e7d!ShME3L2#`uS~<4F&^2K*)KW^*Bq9Q$ zkSK&8wG@#Q0x_kKYF`ncn@m8Z5+G5GO@TrJ2oRav5Djb12%%}Bt3e>BvQ^zy7ox6K zi(P9&?*tv;pt|e_0`!O=I%?CfUVDfkv8qeS>IfW>3IH--JK3X{9lZ<%tpd5!wQ2wW z4uBLK70evb9ho^7ali`3im6Fp;AjQ`LTm%4CaIRyx;O?TcCkc&K$A(UwRG($#N-4- zZmu!46fk1r?rIuh0A$e0F*uIARulZ>je-tsXhdq08UX?aKw@AqhoZ!83&bz1gPyu3Bhm7>{L7mSD#G3#q zHZi1Evfl|IJo<&FFI_k@3>gSO34!+ZcJ}v9tv9``y%}|zS|^CH39?zoNFsvnUj5+a zRRA1~N44hVI^&Bmeq^FXA%x$?&h#bdKe>Yy0f01_fP260nQ4E2_Uz4r?SA5(OLwuo zz;B1!^kUrlcfjm%7;#2R9Uaj3Kq{axw2llVMmh260PGW4VMT zA)vY{&}iJ<-CoMM-^O(u-MWFqj_%}A^ziU-JQ|sYYq#dWG@Z>NH&-rSzWA#1t4$AJ z-}1HZ`sL3&0z8!}$E#Jmb$Ms!)E6GV{N^{l9?=)KZcL`r0OSThbo1cWWHchL*REbY zclz96kr#! zL~KbM+%2R=YJCBYAKA9T{4XVoc|QE>x&7ryV+Y@k40GGQ7h_7Pp_s1x>tDYu|EFzN z!S+UV_YlLKJFj5Q1Q~)VfYlI^fTDOH7lQ}xy|musO_s%cX<++%qx0uaUA=m9djc=& zLAm#y3nKcmQl#hP|IhcQARyvmzHs*k9=IpxBB~;4Zf>4yF$hfbrTgl)s%tl*5E0n& zrfC{>ZoB3r83?I!A>tUDs_R^Oa7%3)9NN*|X6P9)*Fq;P7boXh&CINr?vJ}tPk7Q7 z%Cta{34s6$5*QSQgzE0trmkzrVXQ$)HFRW;z_|`71!JB9c;G6oj$~?qs8%)HIObZ2 zQ*y~f;1Eq~6$)`{k`^PW13O0MD##63br6$8G-_C|ZQ5liF|w8-TG_YGkqi;JI8uV> zLk(1O*EEid?jZ*c##;y<4jV3m1sGWpS zvx|7$YMato_W(d5*O2zzLr7IO)?l+<03 zEyf+K*Nf)hxbCNng$VzxWOLy=fAsyxoZ9XOzV)4{WhCDAv@rAYW?Q$T#|Yt(k9

OipjNL9dNrhw6pTa{9W)i!FXN`3Ic-s8_6DW})nf8nvGu1AD^*zE0e58QXpqmN(jYdxB; z-}`+(^0~*aoH={$nJbIWU75f3o_o)p8Z+plPtE_}dw=lOQqJy=AG&n@*FOD3$@SG2 zckbTpp16GNiR=B&PWRRa?^>?=$8Rit&uh+o^0QyOdUJK(#nb=f*VljS8{hhKzy3^k z-S7QRA3FCh9=QyT^JRJ4YwiYW2iD%Zs`qH_bM=l>++>dX6-RZZ#YWCU(?>;AAZy6QP+T%H(cC-08QK8eQHLjAqpw_dNVXJ&WHNOhhEi04oq2acQ=)xl9lS? z^LOpL>6x|x#4~9IW+D~?SoP7kt5rIEL>1?VN%vYpke>Ta(KxMfz z9-ljPD(&othMSbcG^Tbk_RX-c!D7?hb>Zyc;c=-$o>y}@wLdL`uQvT?lB#RdBnO+c z6ICaooTc0Ev=m(~0RYp^7I3GOid1tb8v!DAXOzum!wh18V5&mi5aDK1XFIJ`c}~#0 z?XBDt9R~({fgJqB{y!)3|05&{P3Lag$>Mfk__o;&9sCaepWnW!^yg%=h-i-P`_7eN zjoqD{Kk=9U9=s4zboVBPQuFbRYs56&J(Xe*RRC0xZaf8aQw^!LnyXe&-@=-r8e?29 zk88i?7{|M(N0W(^3>2RKe-Ma6+l}A*P48?PFo33QBRNo7tybD~Ln)5H4z)Z+lbp+8sE(9tiJG+z& zK&~i^QnJ({5VUTiFS(YC;7GI;CX;dH;7$fr)eu-!wnAf2ttCszMlXs`F zh6;!ZMqGv-97(yVAfmGZ1FDvxFGL7dh8_sET4^HOHlWlzRFN7(&3!3aVqgSAchp*j zT0}yUl8I5uAO(b3N_9p@1ZK&@$pI0Jn2>9Lng=O^l!_cw%?KP!q}D2EM1-bd;5Aot ztT{;;(6|~(%|xhG90CAT6?A&hcs8?IhP+vqZ04W<0`PZ!?U8=Hl3Ge0ZeD)8<}7Oc z;^4>L|Dkp?PVMO1-}!oifdL{wNYIQ%F*QW|VtpN88G10T+|=9~7=c#l5y(xQL&<$4 zHncJn3T{XajO1X3NL%seNdhW5G75Vw1A!@!Bh@<85^5O;0vHpKF-t8{3lKB9iU6X5 zg9$iEh3&iB8=vYOh9~Q?;AJ#*^5(jl?BWCd&V^Lv5 z3Na943h0IoYL+-aVk@rQeR94{F7fQsPpFp|7*)xK?Yr77+7hvl=#|lu}H< zyf{9*ar5xt>NBtuq?pFLr_5>$spi30Kx7lc^5_;~2tdUIB!B0R{A?Y1O7VnlGc&En zH?FuU5w4GK5wg2M*XefYDS4Z4>#juc&OEp6W3^h1$76Sov8^?~@G5N${~QtPP-7Ec zIC9-!>qrAcOp#LCh17=B9bLWhPyg2Y`uVl0dgj!b(=kv?eJ_)}eE{Y-_CQw6IDv_q z_ob@jE~K)_ZDd0@_rRMlc2^$xjkcQ}A09B#R&msg%6tFl@Bhm`^NZ3K3zkctQb5EZ zZ( za|j_ep=t4i)x;23%}W_nArNm-iqHfC69ZK$b&QwDyZ7r@*OEt!BbN7#x6_wgoUZLj+Kyra>k( z1y!#_N;b3DG~lihV;~M;ODDJ?G9ob|g1NbisH(Qz43Re+{7J#z*I{vZYV{WY}MDc?V7Ij>LHM- zApw)SdyFYWuEStkgj7Wsn$*=Iz=-HIXC-$dB3#W6V`^ZF_>>wE2+a(k)(qBkor^i( zP%1Mw+^KsLBQsM9ecuB>>PG##Z`#zf9f7GBATv|0u6eUs*myc&4iO0q6kXMr*sKy+ zH8OLp#*HHYI}Bw=DHV~32&&*#rBGl{^g!-L?Ceph#FU6oMG!F$m4mvu0jU&4;9`y# z+1sW8GX>)qn>M<7sfCywzyRp~WbMskbWOASpmWZ%z3=-iwccBI?e6JidREWovBz;@ zTf{L~#+bzkiG_j$Q6Lb51d2s)WRQpzp-8ckQ50kn5gcKG1SAL%Pi!1-A;eoe%#3F| zJ>ApG^j&ND*7tp%?VQ6OU-j*Kdlu{wrBbO%`s({iRZl(7bAGF^HBL#PRCEC$iLfP0 zmb_~USLSLE$QawUHIG9Yt+n1eW+*uVBP&?~1#)e(+qOaBa}P%0eE0nPU-)qP(|qA}*h7oT6RFO&s^ zY#=vr7pp}Znpjf^CKU^^YZ9;CyON9bjn-O8$-u$>mG#9bkTlIZLqm4#Lfbgnt@b}K z`mb&>0f5*K0B~?H7f~WYBoTSz&3lFU#^J#Z&~#{Gs^5$&S3#vBpauy=nagH7-e|`^ z{D}{&KK08>Rj5_8hOQgOao)}WXo6a6sa_S-7;DhSxQ)>oXNW*ViJ8dWzWMZWdGX5Y zZ|=4E;P@&47?OkiY3h4p$>Dh8_N|=7dw+G-zIN}ycG&J6U-zx+ydSq|IxQdj=!XI7 zb~9QVz}g&B=lwQrCkKaR`EZ@f-r+GTUu|1MI@9KBb>Jy8SAm-^zL?60XymJYMMM-@ zXKVS3Km6T4_Q{_~+a;2(wW!EDV)pM6!+* z5Lrt}rJL`gLM@euM8p~5%4ChIs1#Jtq5z7j#&bl?;Z+SYQD1 zw5yO8C4&MaMXYhP7GuoL>?o?cq`S8>?H~IskuhJ#Bu$D63a;%qCu0mCJt6`K$y)Fs z7-M(3AJ&9`Ii}hEK9X(P4vkB(H-^4u64fIz;d1z{f&ijmtTbQ>GpIJ+tz(`|rdJN! zW`FPg+4;~9XzaCXSMJ|GeY_K6=gyQzf3I&W|2On_XfBH|b7gt<_VrS#r~>fwPv88) z%dhTC0N+@rP1dn0at71pM9w)i#syb$F04{3w9Pf^bIhbNo6gQoPf5tOF2_V5rHCr~ zCVI`7=3!r3siuF(>)vUuqe%s{I16NQJB zEY?0#snr^qOsAzp3N~%Z^?7qYSJQQ=R<3m^;t4YYqKm1JGY7!Lyg?*Gj>I<;U_RSy z8tc3Hd`Crd?v z(HL51J%4ceYyZ#dx4+|0y!(5a54~`8wb~5Z_d+yeir=Pm=`h(3M`S81b z=L@g?z=xkYzOt`{pE`OrEB)3>_uliuwaDi{8wJqq$$;thT)px%Cq>BDuU%WS)`hLjY_wCQ894{8b$KQMP=3cv1yMNTK zQ~bUUU4QlNMd#t@nFDLwwzpm9CyRbEom@9G^*EOCWM&T3PmwvWq__x+c=E~iknhJ)TmSo zQpHrwiE}Q-KXrMz|8@K;M$#d+&$My2Qa)TPvq=TXO=mj~WIL5Dj@B z{*%A{cf({7nhp^NDWwrnOUguKLf~5KxE=f6I{zY}GK)Yd$pwc(3gr{lESFp7Fm%(| z!TiI{8v~o=_UyG+hP-;ucl_a6WbFGZ*G6OgX0t^bt_mFPPim>LLKudpUo_wxP)nRX z_{V-^jM;e))>>nRi+j!NkSsMJ>;`S)pubo&U0X_RyBTwww9`%BlLf2lLwm95z4NVe zo6Q1hZ1?y3#mXT@F2?$!liS9JU24*Ly8$#uSFajlHmg<1$stxi=i71E0&&Uuw#x*O z3|Zg&4?q4Vo34|lOZ_0h<$kn2AaW&_OENi#5W8WBgEK1Ni31-_{4IrZy~>$$A(wOu{)bnAR>fRRJ2fY*=v!XdrkxA0#c8 zp>Y>|0f4>c&Nw7OTr39x;JC@P@^pH3x*h=1W@QKj!I6oXxq?jkF&Ed+awB=%aJwF3 zF$M_08nf6I^We^ATL{4r5JH+Zt8Hu_-c5-^=)ii=08;zyW*DL+-ARW8AXh+uQZ_jj z?}^paRJ^B>#CTAJQUMem3C(x>8drz_fBP3dQ*ty2EL>8$_xj5vryYOB%)(q*Q0mxk zt#d^7Z~kw;T9vFdP1A&~`?vnkixvj+qzP&F$p{btQnMW+8xN#V7zn^RFou?cM6+gs zu>irY)C`aS1;{|tpmj9%3;=@QjESvZEyi8ViY1Dra^CdoObX6H(@m^(F~t<4Yr5Ka zsfvb*8mglqE7@!p7bsjyChLngC5}1gAN_AWRpZDacsU^{B922oJlY#$RjtfblqQpD zc+|O*>Z!fJKCQvSN(Jn-n@I}oO$Z0o6L0=v%A}AgZC-( zYQ33F+jcTdsetAOcTTTeKVEMKizH}b91P-+`Q&)77CpUKjWIoaeg9&)*+e}$m=Qfe zybD#FO*5TE{B~(^a1h$}r^P z!%41XKHqD+d$`!nyJm5AaeC*q6r%_~K8mEA4Vh-rVY^ zn$8RJ<9etag+qpw0R`i*eLH1XRYm=z15rRgBIm=O|K$JZd_#snK~&}kS5%dVLOc2M z-}OEONPF9Hh}I&o{>h*Co1Alw8vs-lgS0xmS4$QV>-}ZwEod4e0uoWp$ruX&{btp) z({~i*?a=&POXbc4@MNo_J~16DB0`DLg`kgC4*&u%?20;&hztQ4OWymo9b@V**1z~O zKNYtZ&iUixYrb&`t{=yP{S(`iz8@(VZ=nILs%0ER>TEUxkKDGT;Dalb+s>8KnRqa@l69jJEJBMS^y%`whfmAz{;G)!G}O(xE2*96i`ZW zu+Fz#mk_v$0uY*7BcO@>N<=2JJz@qV5jEa&VJE_#5*oDD7(1pBL`77qR$wrN zj6qc(Ao8Lac3lD@k3uLcVX4(wYn-n!F&A@*FB{Mj$I&>Z8m7}wDv+^#jK-oM8nDx8 zn`5rR)>5tFy#X~y<`Pa*3XW7Ymu#%D+T>b8>xsw&003)Efs$hqtJd2vnHeHx&S~UY zcgzq1l$eC2lxz*99EsG2MoCIi>%E9ztsywEHkS&DXvrD^ks7ns$^fWZN=1Y$wE_#U zDhx4}Qo34wPV`mQr(7F2>kOGs7KU5)^}ESZc-pH zz%_AIV~m0l89)G0Z>cgH5Gh5R5w>JaE!h%~_n@d!k<4T=5#d^y5WV$?YOO;HL6r~@ zl|}oQjO2gq6SvMH{)2z^+82NBZ@>J3r%>|#-n@kw>j+3J6_F8kNac>U36C29000Tk z&lX@C_jMzHc3gXj+pTfIIyc#yFU}XW)O!!^B<7pfZ<7&^pbSY>YK1DcA++8jAz5!- zaR$pS2jz(l03;;ie)Ttgr)?VirqF)`h}#|dKilD(muCZjg1&J3saj=cc<&70Hygvq zL{04HixDhUcb8Cjt2+x?RI7oXB4aj#dlcU znYrZr?)SWyV__CGUqjQ4h{jqUeA9%V_z(W{PyY1JE>7>))Yp=y`-hL5zq{q4>b!Gx z+*Z4rY4*vD3^5C9M=7KEMJXG91gfXFtcVC{3auK(6&zW|`%;o7w; z_wSz>Lysg}Pd{~|l=}OW|L^WjkIVlrjrwmnkVVAX&RIiWzg2O!a#q`wi00;K&luZU zXB?`=!Va-*n|{+u+hN!Tr}Bh*M?_PWnsO~gC`^*DB|#7X0syH(&Z;O`+EMw2peVATT*qmcM#&A) zSb&I9En?ghXv?J{pa=AbRc&Kym5l7YLjtFO&SoG;>A`B#05!*ZR_v9lSI!O9yu$7I zDDw35aI2}`tg6El!v)=eNo+4j-|=b&wTjq!Bgqo(VJjVClUuKTgsJ4B)A ztjR;g;uwZ1);5%TBr`iat_(RY_q-?T2BT9OROLo%?#GB@EY3BCS$)^|D$1oyf-72> zp*!eu9Gr0t5>Ck*s0ECcO2(=b^iQ|#{gk`|W<4}+%iP!87`4_;$j4k=*O|h>`Xel5 ze&yl)dlMgqIC`*?#;;S{uOKd5^s6h~{#dF30nXnX17K^808n$v<8avlfJj6i`S=HS z4uE4QkDwYvvW7l$XZ2VA&j0j}fBiGZGc)KPf6w+}oBecewm0?Ox$pju{%h0NfAuf? zHE%?2-nuex?wp>#aAmft_19lof9v~ipDkAJdHN`(oMebYzgc_e&)(ef_kH_&etErA zt$o&qtMfY->nW+XWwRdt&_|y=Xq|BcA}1#YpMUkt`zBRxMQ$E7)8JltW8)w@r?1{! ze&~hc-}}-7JDopw``XQ`)7S5w9q&)>Uo2jD`gq;v4Eo{=*SKh^HRt@?t!od@E)EYS zFUbDs`EoWnh*2p_KK3mKkw_ffzZl;4!tL`Y`v?2&q@~AEKmGUzo*7vltka9nU%$Uf?|t#)TMYG^)aNv9-MgN;S#knv_xCgdwX^w$ zKeW#|m6GF-Zaj4oy7?r{UGQ_P_s1T|O&WUY`rc}B{^Bzy*Y=zB)_1eXtP9rR*-#sA zg2m(3KJ&uyufMuk6Fhu4NUjfuC7E!t*Nrth1KqTZ%Y1lzR1v?@3(N58cHC>H&t03S zp;%?TS*EDdNf_7TY|?Jy;H=q!z-hlya$T5aT#fDF#821i%ss02HSsZDZaM$T5j`(Eyi}(%7Rh!PuG; zi;Tla)>177ow!}_1&6L#uNR`K3~d`8Zqlu;sf4ITRejgQQXAI@3YR)N*xPQ`&iGWa zA>azOZJlq%eyCN+)HZkoOqrEMIbNKt&d$y+9$uW>y0*T!IN$U)j*qT9bF+Z&I%(VX zU_M=qapHY)wR`&bmO?9H})Plmclvs!Ob%Hx>Z*7ZXP-V?}b+)Vw15S;Hw zhOz}fytr7-_x9T99_NG#T*cC5N5j$aek}|p72&p>2NTz;F-X~NSb)51Lco%$1ln%; zgX2Ri!&_ZBmlxq~G8u>AEu`TxE_o;ahsV+)zq$OMZ|IIgK-wi8bFIvUcUrHn(E)G? zGVVMMa!Jb9OCjoGCm(^Wm$3{~N(SLtt18q|jI~Ih%mQ%f0FcX!1!hKoQgSI-RBF!E z*_sm|Kh9_%k<>D7`*GX`A9mM-lp;Mw0En=pR7&wpi$uUIilrn`0YTNG&Ximbu#}Qw z(yGR4DYdfHDy5W?YRRdVEUYCZVr7AnE!WBwN>163)&j^_qbQE!Seyf6tue#uoLP*a z8a%U<%+_JQTySo4t~E!lQR28G0Gxtv+I~G$@5Q-(v(Oq@YrkAOq{!JA=Up%^fU=ab z*=_;J88Kuw>vb(}5dfi!V^1ih>=GyRt%C*0*dO^X|6WyGZu4~FT4#pUqT4^bSjGLR zcdj{Kt!Gmwg0r?^9#79UZLn?QZ8O`S&wU_JP}C4Ysl@^Tphy`LTjLOUu~_f#bvcVQ zs-R~V>zh}P7JWvmSLXZ7k~x6@Si=RT(I#Mt_fYO$afi+;OZOU-RFF`-GBEosxZT6HpSYti$?=F0K3 zCP5MfwP=B897pe5EPQ<9`rrL`zt?Q;KL4-$`}@zn_r|-PD}_rI-?m+6q*P;V6|HeV zg^Tmk&H35YTko39TN|d%**I){XkD<7Goxv`?(@I;sp}v9&d!+!Z+w}#7(#iJLnU&_ z{yi2E4_vtv5vh61S;$}r!8-rRzyHfNGzdFQrxH?1@sZ3%-%{!LwgmvKHP^Ch;sUU{ z0Uj+i&I7=u!6Hx1-*Br)a~M8=+|hhMSbH- zpFg;A?Sv#d;YaAeBt?bzq_LS(*OPQ*WUMShevyN?>tyOxWgqs z34FsiWRgC{dMP7QDt%XK4Z)S7C76l`0GqQ1+hM)&x?Qf(c3%4Js)yY4%QI_f)0z6% zKBlT6_?&sO*=lU^Fij~Vl+F41B*NbG}m%f(iw?Pjs*+-DybAt zB@2-P;?4(SRX_xdDJj*GrII|RVS7g=)K2pD_Jl9uyRO9X(M#5xnafU(xm(dCCRIT| z>%)KbKmVfh0m&Fc>x;9yZ@jU3cvqNn>=97`RM;AODGYp6dk4@3JB&pE4vw#`F3u2l zs<$T&Pedqj>q7Sp56{cZrNr?aDL@Fwg^e?afP}`7u|}BGS|rK>pa18d`|SVzcM7My z!@c?5w4F{b7Q?OM=LFsHQBzdHe6E{wk?M^(JH0n%IJ$DR^$jCI@K9@IHDua}>-*Sw zhmf~p{=j#9{}+Dymyb`bgFzMTx=F1iG5qB}^KbmvC;wi}$%dfKF zDb0bt`&({TscB5AWwTA)v#o%p8jH>8N3o}rtxvB_LH3rCdXQ<}vd;@~xW-W-` zc^4eQ&ZQ-sGN7V$1|&2SL;?b3an8DCN@#M)4HBa1CT*BZYD%Q4pmB(yZ9pmK1R{#0 zg^NLDQG}Ysd1J(IP72i;i`F9=0_0t)1t=@4h%#7jFNqa}t%Ds%q`p2^t`gnj;zOn7gj4Ra6Ed z;F6IjjT;w&rKY3^O#=wl1w;UPDF zsl_zGH?67yYE?l2G)Ojhq*^)Wq~sATU@fJ@?Gn+U=ipifCIBK^3R7cCt;%(X<9u%~ z6#-S0tf;;XqKIgAEr~{jj8RZTWl$)LnX598xy+Pe!-N8A$QkRbbF8?lUj;xyzk8sH z7Gh*&5D?MIg=?)v`h~kq*R`|x!QRoBwr4}0w%ufZ3V=dtyt#JmdZ`Sc-Fz}`h4;lWAFk%Ts@9ss(oV`gIzs%%%Q`D~6g32+>99+vyZ zCojMJyB~Pp!D4Y9`^~j$x2h1Bx?OFid-J&2T)FkGP2abwm1u9?xm32CA;u>zh6<`u za{1P8{pdIh!Yohzb-s!NaNT6un2R6(vp@2aKmD@`_hY~9*UQ}$93}_5qGPGKCRSA- zE+s?T7Vfn`;o5}87+*>*!om8+Pf8xVZ-@W^!5J&CSucm4xnu-_K+YK?YmKwkGCSc) zpdv{G(U7NEj02ID5(&|_jZ~?n)|w0#0CZ&0T74VY7kIq?j|lkf3oSSgwZ4@TehGpj zK4L_Wh=kdPV8|%Ibnie_i41}KmA~|3NAou341faCb?tW5A08bU?~$}tMg$_yoK>|l z{~y2jO9Eh>Q86M%xf*g|-j-C1QSz3AtZ7p|1IUs$X8#7()HO{}Hbf3_I+^N| z4gg`Xu5?XDCJXCVn|Asto=gO_V6vzYK_Vv%7F9q2$fy8=A_-Pe>tL)xsG18vLG)yl zM9F{@RzQcLNY%o{A{m=m8&cG|cjfj}xy12&eKBKiovoS4Tg~N}XWpgOK78#<43NgL z0X{O85jM+ZEM}F4G{&4Y)#5$f@zJTN-P|F3{>!g+-3){0SPG{*>+Rn3sE-L#?lu6OR;1D5IDoa6TD_1kW}(E?Ym z9$lQT>h`=FiXfA`JXFTeJ(qAzK%)*c;Sd;Rs-QF)olIFzozjK(-a z?F4*r8MCl;O<)xi2zH2d&-rzYmE6Rc&~?JAKF9gq{-)ow)<3NEYC8jwTZdOSQerE`{CfYoi;abv>4;|(_gy(Bj5AP8~3*_-a7u$oztgI=2`0RzH&Nk%;}KHH6MBL zNVeyH;uG(VwSM{@F4xQFpE`Ww&b?;p|K<1J1W!NsiCbl?&tC67b2r^x^xyvM^q+n4 z?CINA#v$j{Q{@}i51en_^TO>(XSRJ3$vJbd^q%KVDj8uuzIH9A_&wisy8 ztP)o~w3~65&1M~eR!ye(V6BJE$PbG_W)<24-}BZ1jhn^SZdDe z;;lghvfc&SO}oy8q3~z!tt${vrJ*XBJY=H!`hzuD8A77~>=~IP2Hfjj?UpEH2i@Ar=Wuo5t*j z`(ap|uMYNR>%KqSpDm>z7FE}DT^^IMWL*FQrE1fHu$k`96mT*b5zLq(+Rj*qh-9Ga z!k7xYm1Q|;?ecunwZR)$E-vN=`&{hw(5^1FU1Oy}Rb&=c7`7$X=w0(x!v7Ajg+A4J z2yj`0iU43k_y1S^&sX27r?ch~(opy&Ho82lP3Yhq-}}}1-H$hPzB3dZ-Vqr7&e-s` zTaaJ}2`$dgoiU0)Z?UR1Cqk_|@dW~l=vy5Cs0t#Yc$w+XAj(X;FX=6Ag8^Z8J9%VO z+`S=+h`=r~SXf1LXIbE#c&Xwp^uLr{Tr{fP)c~koQV+E-Al6!T`Tn(JuDRM=OC|+W zAY*FHhM=O>TC|p0ORWWwF2x!p3&4&5C?x?>$w|o6l4{9_SOJl2EtzQ7>W7c>J6uvU zCKnmD39}P#hSfr$4y)*^cPvLgVzqt&_( zo+KBvhK1r=1i(1Panf;>A*D9>T&o3LE{A^D3g;9i#)nkc5;VcpDtT;b(ZzD(cv=!8 zi2_)(NHmV4^FFhNF2p$6qH!FytBdv7EahCXxDZlDoU5^R7ehpd>x=Wv`Dtj{8XFrr zYfbF8F0|Gg$eGEulgZ-Y-S*+V+V~hp1hAI$ao^9^Hunf~Ed_HbM5t169L9b_Wb|@A zRYH@}`1ahp>m%3^0IJGdYPlSY!S4Po(O_^60Qx?+ov%49maE)0wN&Qny<4t^CWH`t z<@~sfSrwec%IJb;=3%)Qh7DTp2>Q*UX{T}6jQz$FWE1=4{&w+jv)E^H{qn3|o&_qy z`Xb;|gyl&Dq2|2nlHH97s#q=6S_!#iEnpZC5Ov@n&G{Yivup7x#33zui0 zPWJXT%jJ%!{zj>_Pd@*nEh~*%L=wCV(HG{Dq6(`*PI2rvbm^wG+r`CZakd*5iEPQk zj&U(aPc&-4lZDE%^V?nO>2{01l(I_!g3H-k-vK@BjvfGbA_eFz0zpba=XL|Su?7*z zQrWJd-Ro1_@4A2Z-~Lrir$@sY0Ipn&~=l39B;h)<6rpApSyB$Z8kdqfQyTT^UZtSeKfyv zO+eGIRhG+b(Rz*}f^f+pG-nSlW}O8JwlN6QbY0D3$((ZptN<{(c0*zsx9iqTb}93y zVu-A1a{YBczJRVnO!{+GpG<*gvzJ}4G^K|m_}42M_h6#Y`vd! zo%J3w6F^BBK$Hs-7&I~G7*o@<7LC*ljsTn@p(O$UOC(ro6{)!}01}}K);U{BPN^cI zGApS9#LdQqfB!0Wz`Tm5{M~TA}O)o zEa!Vi2DR3VDp@2r?+iL;R8 zDiyPargdaR6hKO5kRWoep0E_X9wHMYB|4H{}v$rP*)mrPjZr-Yu z(I_E3Se!d++7L=*zI4_6!3cmIsAQZMB($DcJ;NuyjoD;!_sut(rrkT-&pFnV+tyEK-M#zwoUvWktk-c!{d3Pg z^LsD9=6yR3Y0@-BYdf7aWC{ql(0F*|i!VPsTYl_AAGrVEUe|VQH!o6AaZKst_=*6z zt}`|6*QoR3J;!6tt@W{{HrU7St*XjZGfA!W8=}KcZ~*P3p)vmWpZ$^l;*@05sO6IA+f1EN{oA zZ8xh`BMmD8b9Kgs#yQVOU<`m7N5X=n&Y7GOB8dvbf)?DRh`u6{B7rKP0ew^fhyo0F zS&Tu}ODRNXj3HyNUgm`$2$9)k_`q9&!5vicH~#WpnoTD~s??M+?9V3K6c6?%dwT~y zCj=CbrfpPg({^A8KoAHKh%Az-s4>=(Q2^^4i2mxY|8{TPfpHHPp@6Su8L4H`7UnGXUzl@ zW|PjsF2T|Caf5*UdbK}45*ckX8HOzYdGB0s56|wu<32B}V@~|s4HjXMul}F)fE9oU z1i%x4SgmzeDVYU2kPHMCI|qFRL8%edutNi6Yh~w*RLD?SY>LS_OQ41vph+wM;;mDy z1SDF5HPkl8xX)F`&7v4HMb4_};a7BWe6|@8#aeqI{`BE_jJcK!BB5=*{OTJwZydew z{JUR%{=>4kMXO4$m(hv`r%@sI)j+ z?jIfeqfh;#>sO9Y?ZdMNv&l^IXp9>dt8Q=d;Os%^%l^^c!}B*|;>Nc-li%X}qMLL# zJBWD%DZllF-^CmogT6`;{_^KPdwl)oHb#wuYZ_2AZ4i~Sdv~v&oY;xqALFX94_*z0 z%2iEj93syVi?R@QvkCMggE(iU^3il}o6}TjU@d8Mj{1K4^n8AQ=mGHn?S1AOjoSi} zbJMQd4Q_v60^l9fj=rNF;%#;c3elH7_i00T^7ISq)%NLkozx+pt=6|s_Fw(V;_9`- z@A}B>-iUpr-+J}lvDR6t%;wWcETbqUmf+m+jg#eiyY9#JgYzad!#F(i)U}&4 zmxe)OzbW#?dyCV2v(MQP|MS;Zi{%ywj`rsd&X%1e-?fB63D9@aCu{x1Vokw4IJ+C# zxeb#hgnnQFa6kz4-u-pkG@xLt8Dnm3u4bZ@e6Ts@lvCkqEe>&OEDdp(&nIXaVTm=H zl4EA$5S_7>qC(eof`~R4gEgfzrY3aDK2}ju%sCTK#`>@q)&$IkY#(D68e=^GSyfSH zRY?_{9piw`hgPifCE=Jh7A?0eR~1Rtw}=?W!C04>bBx9Y14R)2U-sTC=CUli^IFs1 z`|eQJeUV0;0Xb0 z9)Jdk77t(nQq%1gxIC20<)&v>wC5NW2S;9Q(XDc+K;q*_Ol8_ODXCRVO?E##IwF>$W$b%QtX|7hXY-|bJiT|8 zi?ypxqJX(+4IxR_OnvX}EaL892DK=nn*(R21OU@GhSWAqGmb;R0X?W|-D?}jp`oHc zh=3qXvaAN+ZeD8zi|m{d8VK{x{QO_L_s-krr{|a>w=JNi6vlqrv@;UfT&!c)AtC~c z;H;%uhV|KIu~^hRdG)}En9k2n8F?Bp*dR*KyZ9GUvI|6 zY|iYZ+Iqd2b=_DYCCVPWmZob;sqCgTy8>ZXWR^Hej}Y`_i(`#9E`CuFaA zH1mfA0Anp)#miK5Qb%$(LnTGmQu4?`Kv?n!?nSWXspjlP=vs3wS;|yOM073FPy!lZ znZ`U0|I`8i7?o)xC(8wu)u;&W4^x?j%&2N*ngp!W>fj}hHIJ%AkR7}h1%irNtJMs( zc%8;F$>RcmqaahsBZ3u$T8pZZfoiR_lrq(vYgR-rOq#2y7(mS5|KN8R1?{I>aLl)nj$gYt34#nLf4Q>B+odc#2RBAAXhjQ?90`79$a!b`8R}yMFzHRaJkgq2y_I19)mR z6cF*PH{ZT~~)mwLT<5RL;|I z_1e|D@4idSMEosP1axpjtm7zqIM4fb(A?1xaoBE}ZvNyq@)QaX0Gyqk9vmLN7yFF} zfI3c;;^Xe#Jx+Rea=N_wY&VPdNBi7we9d3|f3_Fza7Yl+@y+MDZZ=J0n6HFF1v|gk z90&-zPP;HatbpJcXY*RKh!B&Zm{mYQAW%$gnufuQv*#dEO@kzGYv;|6{nfwm&ENjz z#eDVP8CVzz&;s9@>tGK#iGmt~F-_XA)!qt&RYU%+!hudE7iWMS$6*7p7@y+v74# z4jj5xP!zo6K38RQAR^}3`~aDoE-{8;ipbNjOKr+!L?o}4r$S7z34)}hxO+%#EyI)t zHzXDmv}&c+6eF3rDj*g!p^&qx_Cy4dz|hPjQqE>oYjxR2B&w3IVL|g+3V{>JGz_7M zf>g8+1wyE*tcpZ?$7Kv+?z{C+Yh~i1HH097eLt2w1_?S%L%%B$9>OB3x+x%%0W*cv z$U>~tDGx{-Q;S4q>d59Wn=eB%E8{TqYx8~Y0mhVKO0`r1Fn1tiMh8soj2uI1BqjvN zWh`YvWOoQ5Q3&I96G9{;W`X_wGf9l4?_n=F0h$+Ab8u5Jc;Uz<2bw;3&kT3)sCsdA+xak^ZbbzVv9oZetY`I#P83BfnOf_di zAOIJJhfM#eXlO!gLabV}mO70Y)BzQV3E4}P$Yu^U6(SJ7!!UpYr^F52xOMCH zYq!^Z|I!Z~U#!n}Cnxj6W7ndpp5{@)d~vW{pIWY}_WrkUQ>MpH+V?Tga~>T&RQ;cJ zJpvl~!SdUw|M$*LgUD_(eD&4Wp1*m$T74fd2}; zJM{gv>(|Zj^!$9*b?f!1sE<>aVqg1jx^}u44lZ3Wx83?YkHbDcX0hz@Zdjk5aEK{I;y`4>ZW}{#*E%T)u&{*I ztO8@?RCG!*Q!nGV9r^(Yhkn3P4Yi%MMN3tTf{ekdn%h`zjeLtdmWy<01;pq#+W()JU>5s$Y0uxZVK*u@W5mH|Km9@6A3djpP!#! zKE9%+{xs;p9ua)!?Kh9F+;F#Axro=YjWN1YE?TN?ck9dT<pt_T9~t_S2Y2rr&KC!(BV}wQbh9Q`YlNGoHSeZ8 zK6m5hvTF<=mzshY^5OCE>DieOO4H6lx_Wq+7K_89OQbrVcL&SkQU-b9h4ru-^E6H+ zg}7~Zc^I}A{qTMhcyNzcZ(P5AzFwyoHKwkPsh#!fU2u={<&`uuulG+*5kIUt{A~*W_>tF92>yxB z{OH;F?r_<@{^q@g;LUgM-Mqf|%`e}cH_dTfGRgUR+Kv6uGTlAf9xP_lR3A)32t03+ zS08hE=k(&_K@HvPQ$PFy>F|v=&reS3y}Ko*C@Gdwp1F2>a?#g1A`rVHV%x;+P?qyW z6Je^p8^^Y5ADph&XFH&3HJ_9LDVk#x8^;nuINuCoKY-V^Nf)PUN9dYH$Wds!?O6!X zcAGIJuA190%Q;xlY0UHaN(pPu=&sYy&Sr!J5Ru@p=>QB_D2Ok*=^WvO09<2kA0GeNHu2;VHyS`31nC`wkek) zA*f}ulE;A@@7;YT&JG%!E;jo1{fnDd4~CPAydI`(^Mhqt&Bo1I>y#_2(WcLD{?;%3 z=I6h>{n*ubHj?J3ct5S^=r;+Ogkm`YPbe zVqS!TaA-T}gfggA=yNeJHy7kmaxqIG0K&K)=kpectPG|Gsz*1kn(Dlb;7}YEi=fpE ze6ecFq}z3EnNH5Oi&>i|i(N$A>v4}Fa6)o_LheSS@16g%-&Bn3@W&~X|6u%a4}3WB z`|xtYKdnmfepwa#N#E{=nu6g8W%fh7#PB}F_9J+eKjg(v$d4axVSbY zan?O?3-WJQ5BsC5Dbjlu@9&?a?p+smy9vKXN&N#f+0yr!@|$L zeg4s2KJL|eFSGZdE)QcFQ%H|w`X|pobay|zeC6Ww!NbM(N1y;bhSKiO-mY8p!v+E0 ziyb7+W1cS;4pd3L{>q)(pZlMu-C9eZ+V01H@}K$UH(%{mmqY@vG!mJEld#0Y%S#Ty zT>~a0@~Y~YO{6q~r|hJM#J z9T5SuIdqE|A~3fcIRNM|#%^BnM5tCLt(60tYpo{WR@E#MrI6ad!3A<2QMqVFmSM`X zChayCshO*0&B`$`vS~#u01ixOI87PU-LBnW0!Lr4!F7eZLUO2HUI+aQyg zO=CY>9@M^swr$%E0H9WP*J}MR%(`ZNa1=vJ5z*a0svO4nSmNGA)s185mhw<+85N#w3N!c4_W{-XGV83+)JHc zCJcbFR3pS%m6_dr7)CT^LC-F2nlGv5Qc7`Wijf`5lyi0j2P6^BwKg%Md z3BY3rQJ~anRr623 zb9E(l1V&eNVFrV#6ou;MXdaM?Drjj^R~^T`XAv-?5F9`a>`|~PGLka_lv>7dm$Zp3 zn|VyaAtI53X#qskJX+2nB_ek>mbRAR;^OSNXODjRv(NuupZlFJzp;7t+4Qj&ZVj7F zH$UVc1{Pv)tA+i;p1i~jaT6oO6k>`W_FO~6ciwrmi7SXOZpXA*2vJo7qCoNXt1oXh z)5l(TDHk34?RuE5+-Rm@5NW^(fH&)tq6!3%9q0p(J@wSYm?D2GOnh&{nuf)4^Rb%z{3FU_2!LR{jkfml8~#pSuQnu{rp#6R-vp~REm6M#F-gkfmG7Rg3 z*jfs3a_{a19IuWT;N5rLx%|xKcemq@-MEp54InxqxU1Dt@(=yQPwmslKl%YdBndQY zrvLC?`?*@+7yj%2adUoJ_I&{R=n@AcLLxNZ1L6P)kq~_^P#`|e_IZTj#l1m(&%C7l znGa9AaPJIww4!=XRp0;dN9FOhxzkUCBHCxS_`Fu%)CFgEFk3%YIscAxpP6*`c7$k@Udc2?TXy3k* zDJ2o{9yi1S0M5cB|L`||8v%!5{JDSrFV$Mj9KowvE`{)Yc0;u4DCq9Bs=NQCAOCa+ z@+)8ba@WSI*DjTu?I{!f_o)B7ezQOJeLo_h8<;=E{!fUzT!P5$+qWeMBA%R{T)J|_ zo(9)?m=Rdj@|Z0w4%?&U{EfHnY^Pz?bs37Qb=^F0GIS;k*b?FS=5#S%)lvbdO`TSC zRpj@FgcBl(2-JYe_>>L+Cr(5Il<4HdhBzbaO~Da#1T`me00zhzFI~L}=G)yx8T-EG z7(&C~F^>HZn>M6|5S8)XYj17GA*B|;IVJ-P>+$^bL{dA|5e-s|#QoH7P>thpRsTNXj)!D7&^N4+Vv~WB8V@4?d9M7>X$$D@gJHt7Z|IS8iIscK7H%i zSMHts#uxv|&F629eXb?vJe{0xnx>hi(H&m=*v&fDYE=;5y>oA|m^Dpva&q>QKlPKp z`s<&Urb(%J^WLTry7S;(48hcV_yQi%LNfIT5u-xtXi_H*)cf0I>4v6G=Di!TwoiAOUGtrPMg;;8}VI)qei4;-= zpGx7jad#v{cM1F04?$wUNSJ{U*@JYZ6Ci^F0k^Zn%w=sXe6TuDhkh7xo!G0pk(VH8 z8gtvW?pSj5PzfN3lOvFa7>D&m8T-_>dANA?XmwU(v*{&;eN!gIfPmv}Q)=nD4yq1X zVr=R(O*wZdrFqA((OgRz#{CqTLu}hJPUv2BM3QlPF`KWyhaC^F&9UPQw=71m}a2|RkpLPSfy20o`67w*YJh70o z=sx01*wm~{08SD>-Pzn#Bmn>;6aWKbU^ge?T#Lj&?iiQ=yjafTteZR0Fir2i^X|0U zz5Z+eNPp&UUBA~q`@(A647=^RO|6CdsA!MZW{aDFdlac7pzs0Y2F=s zm*08oP6*9%vDj_axBu|=OSi7%GO6))m@Zviy?gKM7(&Dzbb zbH=zjf9*?OdgY6ZsAc%%&;2{spS?a?%<5F1zkcoYd*|J<+g)7TyLkan?6Y!$_{M*^S4Sn<#CxdcNLtO*0g20l;Az^E1!CfC#(Y z&fN$RB({Oi&vvzxrV%7TloWB^1e9?9ba(yoLC&=pZnhb8iu4#82JRpd-)ooM^MBmF zYyOYB&*xpvD|-S@#>GD2Jolzi+WFs|0wMO zAEBMVzs(EGY)||N&Ad!IfG1p9@Sec$^EUKjarllYK>G#iX0w^k=kM(j0wSdtct6+X z@Re`A6-8hEm0#MNy$g;ZrL?#bB)oCwba`|QW5YsTs)i29F|^>YoVEQlm|JnMsfsX* zFq&&dW-WyX)m1=&7=Qqrk%}pk3n7##bc=q>vo@BRKl7LV+OPeCzklV*6?acDn(A&E znyyP-SMzZH-ktsWThMLbHYF#?Rbz~~7DUeD7*m^?CgWtADndw|yR(Ec4Fv#MKrwbR zNf}hDWrrBK(V*xSV<1c8X47@uW;p5S`Q>sM3AbZEjs=;tnxrDQPY6K*uWAJx9f-`4 z0DwfwxUG3)iQ9`cA|D(rH>c+YVgbEyk)w=KQ zLgtuKneslX$-u2T5+eh;*Ia9vI0Q5_sHPQx2*7D?90{trx0Bh3(S9EMV> zIZ_C!6atoM0P=3O6p5RD`r#wJ`rP4{UVm`B>VEAX|HGgC>wjIik$`zB=tfTlzkaL6 z&S*k#Hro2tH)4WsQ`kN}yu?jlATT4MYL3M2l@SSIjJjT*&(7~3td3rIsXKXaN038o z!DGx0%srmzy9KtTbkiY(-}*z zTYR{B^_u-NKk*myII8M*I#nW~keU!8diigD;cx$)|LpJOVYhFk^M8KqNp8A`)3RriMjANPvWhRtFC8KmT|CwxP|NhGP5n{j+O_^UGH+Bf#qD5|O-l z_rc-u<=5Z7zgQg%;}Bv(bZ`$6ssu-U99iM-iT>ZW`7i+j5ikYj6yrW)_Y1%K)nVEO zZjtdX{^+OnWq_)-4_$aXIrr))XyC49R;t=x`E#H7+&}sK#SD!35%lPN9RL_Om{lTj zvRywClI`o?5AFZ@*#3`*n_TwZ|9!6jff$>_5}hv2&jy`ZaCOf^ z|Jwa?@_Oacm1cD`U+Kl!dFVoHy3&upv^+dkFO7vLe6(5}UOLW`@3t3R8|Bjko>0q@?uc-FWUm&ffi48t@{r53Yk zd3f!O*IqrobSx}^gChdDs@0me7w7BUZnL|%b?a8vEUN$bbHDoRjT^hZFU4-&y#9@E zeC_b?()rohXMXh0ym9;X@^DFuw!i3~y>)XOhu2?!>&CO!PwqcpqO-G2J8Ne1+3ER? zU>6hrzhC@PE~QBm$!1#ji^Icyw_V-1adx&gpxDg+;Oj5c^6 zZtEf>rjQs98X0TvCePoz^7S`2SLPBzNNsCT0K@ri-Od-+uV1pPBo6lAE}1JK(`?pmw?h+Su1>_$ zV2+iUNPq1Ieb(|(s3#rYM*6Oq6@?yP-A*2*$t3&hL_q&pFF66sjM4EX!WF7k{ zh1LY2jHMkFzigL zQ~bUE^S}CvDwDnVSN_)3=b!&)f8@C@-(5fd(ht9L|L$&A=kpm7Gzm9rGb0i_I~xv< zRu`LH2zYw$oI(PJ<)S@@+Ch7A)?dARXcd4+nr@No?DTxG$I6*GI1IRFgfxVJkW zUtZN|A}^=w?Yxuqc37>tRoC9X=mA_LTsoSco ziD2I-l4kR1w?lw$zch7#rt9px`Ys+2{f=J3O2%Rvc2dJZ9#aGg1icOx+v^V=IX0 zv~S_t?bf-}l$wyFjyaJ!5~0L4ZHEHnAS9ju6bPa2Lyk>YN^z6~polEOyItSS=HR+$ zn?HQz8=w8`k4uaf>oahB;m`i;|NeLXi=X@#{|1Yg)j(|Ss;U48ko&&o;o$Ic4msxv ztYT0~nIB&AqGOr7OtI@&;vR66^QfvKVJs!@rV!eUJuw3kV;Gd?2M1SfT**^?>(0GC z0|he(fVx-v&=HwSQDhKd0CP1Fc31RZIjgy8VUl6DDJ6%{oS*kiJ4;PV6d#!%YNo3xFF%f>=TlTHDDNP37s%W&N(%0YC7KY zM1ew#S_&edBMM3gshyQ^bTTB|r>8JQ1#f3vGi&k$UMH_QRa4WZ6-3galjYPjLq8#D zN{IvI%?{C0J7)<9uC8UOA|evs#UebrUOPR ziiF^xr2ugV(U|jY6VM&FZ966+;c=J@fXU5rmpV6ehgwTu$yP;}VhqUB&^rK!m_*dn zw32`pGeC)vLtqSM=8iE+nfiX1LX2%}JV?xS%-TwbF}Z4rDFz|ts+McsY}Va;9z$@a zkOCTlR&ZyA(6ophFqdgEwV09!sah%MZp;$qT`i+IpjFqRC38$HfzVYQ0ILC56(D2= zgyNo}bQ~oJ0%x64ipUHAh|V$YZRT3bSSm5?E!^tHh=FAqvS}H1%IMAz0uzFI*k5AI zQi~ais`l$G(GZfjF*gwaYK4bB>F6apYMGpo#uZm#ZLNdlRg<~=e63?!slCIGBn z&@Gq3?vCj0A`!(2mI@R?LI7lTbrwWK4k45hHYp{EbY*Hy=17y;nmsEw)nkf*Sl`@8Snf8nL) zB$9!ec@vwnv-9oNm&@7tb{!a|sVv*YAHMrCk$@Y9fC$38?KeS4g;5K-zK>0Z?qKyt zKJ(cW!jtq!K*Tp*d)-~1s{X?x^?&b8RK0>H@Z=#JVE zBJitU`{LK`oX=PDfI=co*S!4omoHtuRJ>3V_oNS1uU^ZPr?YbsymaZ(cD>zf?$2kl z*re0blk@Y72dA6smk)Qt*v&deueHAW?mL%`F73N{%*rqTL3PvH_bz_sM?drS?N?(E zr4(XtSFIkL@>Ca1>NU@WvNO8PET6SaK6!96HK}RF{vvZ{d3VsH{glAX3VN;8RNd@5 zo_!$_vxFEV#Ss4PfAnunyY-!m@}K?>|Jycp)hbFzQA#lu@M=NgIPPkxD1roK%w`&! z$RtSAq*#X`8TgDk|AEKM+7)NS`7X6=*lzIrY^M{+s$^pJUpH)R*50RgvbCOAp(F% zAetU&0FSy2{`d?x$VB_}lo*0Rj2wyai(mOh(fX60`h@4YuR4G0)X5+90ql95Q-Qzw z=Rf=TFa16SeCkcW5vf6H0%3e+i$}@jX8_ETCO5=dhg!q_&9J}&b#0H=4~s}`TG2D zb+Fy;NNDQ&<4afF@r}3Mx^#S!V!VIv0kW^=hpVI2*~z=lJp0@?UVi7!oqLxKFQqos zqAc{_^!{>}4gBsa??y>iu3SM1C#M%>%%^AP49*eFJ%m1nRKe>sZD9xyNC@1vo86!J z?2oO_&+gq#ue@^mGoSwSy}S3XUAuC0bg=8Uwe*LFi$JnnpQnb#v0ojotZLtH`f=bh zQnO1(D=og7&ncwEa-KqpsR6%z>GGBPckdI?rQ^eK9H(J;{)b*XJGuYKPk-|D*I(B> zb@T4#&F41j^D9@c-@g5d0nKKKiNA|$PR3k6`oaqlx4X5ghr<=9r%128b@u7!uKv!~ zUi;zaukCj0T7ArZFl*N5YZMZo>h21cE?r5ni7Oa(V-uy+a(r}2%>w&&vkf5-;rw7G zF%Soev1QOm2y6rQSDa~f37Ax4cVVH6OK(DzU zMViIIVi-!Cr=nKX+eQFl*4)l!yX_Vn`*DyE_Xx)jq6pMH#TY{1am?OP8)AdJ-fWkP zg}bY(I+kgWn7Y{vkjgObhKZS$s|8XpH?)1lgizJ0dhj;JDpGd4sbl~M6#DHJgILit z>!8{=^kpjTtSy5Ja%f`H&di|Tkh%`ci&p^X76~Z0LoQP;#)#D>u8CSqjWj~cf{5fq z#NA>so3*uCwTeK*4WKf|m{pL7u;yvl4TP`(5HW~e`w|smYzBp4ta(yS!4Qj;+E=Zb zx^|dsd2j%3MO6Y#I~9uRs#;9Vz#;@;Zo3&lsDy~#wySYFrFLHPlxUWk*rZF-IFwSW z+tiQD)c0$N&1|{KW3Q^};B{iAD9scqhr}F!$hDL*5K#z;xg!w(a|Xds%H*oWoz2iO zg_KJ{5oQ#OK;*21=z%U@zkz_Uoi7t_PtN=GS+l%)_{@zrPKHmv1Pah}GjkY*5s5eJ zb=P$we)afpJB&m$43pPN;Oah`wY%J>6zB8#`F5Ny76I{hzWmJt=@BHxZg+7pF0L4i zi`5E{7W4V?=-}$S`=#IdJ>9-J4gCur`-H1DNq_^R5%aLy4E^W`U;ov=|III?FF@Iy zpZ$e@{TGjqj$V54+AFW$nI{1XlzlauZO+bC%jg76;G%YTc@-rN)AaV;(~HgS#hX_{ zEKX=B^R62=Yfi~9ob9R@P#HiO(7_!M)WC`z9(0en0mloO6v1^jj9zTsag5zXuiNdk zSadjxQ=YVx^>(BX4p;O2GHjn63jH_~gAE<}E6Z`+;4uJ230`%~&r&56SKOn+1?o#R=ZI<@WR|GJErs*U# zMB%8Vue^5p+UI{~_xt~=#k9Kg?C#yW-EswS(X|kod1w=w12P3>bSFV(D_KJ02x?9s z)d5mKqJWMeC?O$cvoelgL`021KUDxT5HUw|LsCEs z53QzD&Falh{d2?S?1w)4=kI*ut5;t7cyLxV08dSr#wq}5HV4#U7=j2zksx3oA~D7x z@4zylPrIH|!^~!TU!H<95rdHBq82!~6`Pp4*(}WtvAOc#%`e~lkiN0t1Q!~ zh#{oCTpP%mHl{XunM$cO=cb#R)jSLU9#T`aAPNzsZmzYoC?aG?wG>k$W+qU@y&I8) zU5gdX6>F)E6FL%8v8?XxYy|+NOhl}cMv($-V68T|X)eWwT(k%Q0!TnBUaKNeYEvo2 zv|x;c|H-35&|;+f9$=Vr)~bj*a`40DySd zt^pa@IVKmvPAjjH8K43)01^-a09I8K@!l&jd#t5SV`{r-NQ?$x2+lL9)T-nhnM%rI z+s;)=1qC%gYP!z3xE)6%TI?-rDk8<8iXagO=go{ApmRMpE;s`;1Lp_{2vBQbABiZZ zOjuME(e3KxoW^E0BXz2kaYuD30_uHab^=@F^$~=~@4WS+CWNOO0K2c(_sek{02IJN-@~7(|7fP{p5U;4k@|1Ue06$>M2r3Q z+u!|@-~7s#0rgj^W1gN$LqcZu%tTM-#6RAR;irnFCvcmOQ`0{2WZ=hm8iuE1)jk!m z_DP`5Zg7R3PF{P0lKkXMKAm3lR3sW2;!`h~nyQNJHn1YHQ~&=AH4Gv$b7(pjnx<*j z+k5}*fBv^N+mZo}mu_`k?>u|_{)eXp;O_D4@?tZa&m1W*gDDU*`-`)41V9E=7&9Cl zb%CO?GWsc%<*d29z67-?m*rxKNIUkKsO}Iy4zM72f=3Upn+8e+?{Phv0-PMprj#AK zz0U0)-xLF)Qvg~X9<%pN*QWyB2lB!B;GAdYKH&y^zSfz~!xw@(KoB!CBOx-=AO7&o zU;pwe8Q=-o|EGEY@CmsSK?H<91C;-yy+zi-QAy&Xb`2HwIeYj$l+xish&^Z7VE zUfwu*`1mZ9vG1dw%}*aa2+nHK*tVZ}37!w9KO?#v%%ES)ADv#Foc<*x!5jDCep*H;XQ(>0r6< znz#T*o@h2tIj1V~&UM|al+~t-_uzT^}s%OX1qGTR?FZ2?)O}v!^4|r7mvO7 zF}Qv<`|;a9KE84M+H0@8^VT~)5OGY~?V|6mM8JC=-0|^EL!I^W?YJ7(>G9e5jT`gW zv_F3RUDwe5-a#5S2S@wc>%pyto2%`13zBDEAD zfN@BvR%TX{rth^VMyy#&8Hpo1&ZTOtAqEHj{*T{{rnkQQ)p1I-WJL_@yTzVo%xbIC zQ}V>%)U-&Q_luII?XcQqq@XHzmvSX8Qc4x6RoQ?df$d_+2$d>mv)E&xY20$-!Jt${ zz)}VTP*XwN#cEZR2Hh}DRnR+2wKlOat(|Ys^SIumJOM!0&51AsS4+)O&7h5b8YgCU zzCAvfKm6#PLo)-ZIaLcy95#iJ`^DUh!IXS0TF^yQo2HR55LiVeV5TZHi`t^^$6Uz! zlF~4&&7hVN+m?`P)mm-Y@wnN@xB(;Ix-upMA!cwGqcs#cB8 zU0z^sPI;-p-?Mh$fbYkFS~V=By#igQBoyJ^IKMdCle_4zqD_eBrjSLo4vaU#Ar zepcaO;Jq)Ue7-l-C#?T3?o<5y-w=uDz4tzN_Srl3xsG0a^0@d{)L!|yU;d{90DgWC z;FqKTE&JJe*gly6F#E(t=I&_vN;4iqdM6`u!W8qXkcf0)Py$k5EO;$T0vhJKHhA9T9sXR;*Bqm{ZGv zJJ|)@83Q7KOxrDyLqbpkX7AB}6sjgsKte(g&4VFUb70j63%)f_GxY34%8Ot9R@z>> z<>90IAKiZD4uE<_sHzHn)*!h)_G1}Kt!!9zs{nwQtEN1HTCFvWBd5gC1@F}`PeTZS zW8VN&DV`#cr=ZSxL^i86U*EZVi`2B#7jDe{=)()j2D~PbR1Y(-T;@I_6a{^>QMRo{a z3e9Z6%rz%OXC}y`ss84R_^SSK(eKpz^2&a)R4Z^SOtl887>V{F@6tEz^k*@apV zajh83 zfCSjKVfV}v04JDaBr#?-r0CFvKwAS~GczOK213fUmSLa}wJJp{sWRh~1ad{D=sB5` zA|73g4SN@Z%ejC6d7RB#RV%50n(ulj1r0q1cH})W^LD%LnpPEyTI)k8b)2?=Ia_v) zoVQX9L`^ZqC}@V1MHwIl%4r(6W7D=$GMZ8onOLoiV|E1Idu9?bbQXdyRq{BdRDyRd z_@<3%+^V5-UQG~y2tk3pGf^WdNr(b5dDoUQ?QUgq3;=B#&455uG6JfiRe?~|MC#5v zF3x$!RBHu*kLOxocVZC$4b2n*KtZfb)4=R&DW#NM_Cpohu|7)9CgPmiF+V`6n2;hm z$LN$m%D7u`K!u!_lpsJgLu4#z9HyH`d)JriHqzh!gZIAnrQ7Qy)9MoY84)|@48clL zkk70`5m2Fu6#!VRrZAc4?Qv>;V=%r{crr%8}EM5we4oT zx^d&x?&#pi^ZW0->0>|?B5)x%@B41P*{oG6>=GkBrT-H$6EU&-R0aST0A638HqBnw z#mA2yhkiC~w+M)Y2F4!y*oo>dq5jj==_LYmiwx9V?$~_L;!L=IOmA?sZI=j+NNMX@$>&%1?_Ij zPlSkn^!l6MdhONSx0avk0gxj^B&Of}$G_jTtyI&Waiw|h&L2ORFP2kDX_$z;n5wC& zHbk=HYdsN|ke;&tf1Cwns=C>1Zywz$wW#T*T13Q3IF>84)Uj#Z<_N*AMG97>}I`ITMz44%1?Ie5CG7j|Lj``fxBQ; zlEHj=(E5lFa~1D7m+gGMUrS9|Li9D2nx+9$+qX^VE-oI=+8H`<1vD=8xXoTkcKM0L1gXh4cR8Xue|cInZ5bWj}G^5qTn;P zZ(py@_x2A?ADut*%t_z2A3KEbm)MqlYK3#hH;;d%2l2(#g%U;2XRG14qkTWyf9uB& zo;_aPFX{MT|7^8woeeoH8h?6rzPE@{aklK8kA?=0QX0Hpn4x2zOGN^af<&F8RIKr| z*{r3)biDy6S6kgbTx?g{TsJ;6YEX?@-vqXr#XzejGpn^C6LD0?SSIhii=h_TY=*8~ z0&-2oIWiGNBCx881{gTF&Mfs^JErP_XMk?jt%uc<2Ea4{Xo&va8$WvYUw-H7zwMUcI!08!3U@Ug0BNkj}_wU#Q``^FF%o(zlwV$C8Z zy9o#>l{_;B_C<2l-87t4j-C_&UE3}0-+Q=PkDK-8#TV}W-uEB8`ofJDPHwo^)M;QQ zLPpcstQ~UQKR8TP!O+L1Y54r?aT|R~Wn4e#=S|Mm&F8@J`uYMvUw-b!Td%+U%H8<~ zS7TOgs2I+w)Fw7n=adj<1v)+3~CS6~TeIJaeWJUZbz=8^Z|3#9^Uu0a*7ZU)#lJbafz5)26 z2k^!5#qo=Gl8E{_k1-*_P^1s;bA8i4zZ~GtdFTK0qy+;5=oX8b^Uq(cevwVm>{p@y zJ?TsR=`a8y*7X(7_fQcKbIu`zor44&0der`RYTW1at|-APTzn3t^f0X+&?_Ib?4Ow z=a+Y%y}Q|@B%xn+dpB+gd+z3_wli3vY84^JhyW#lDKzb_0zfkWF#u$*3aUmBL^R8e zhd{Jbz5s|E6Ovig3Ke@F2;CT=CQ)JqbB?M20U)ygzW>2T2M7Bve(A;c-X4cXZ^H{O z<7^M}1mK9NkL`}RydKs(!eXz%=$v{njcwE_QZg|O(;%f9DzSG?(MpW1S+JVQI4}|U z3cyVhkP%F3t=pVteb;u2M~~OH7C7Id%Zu&3EizL@n9X_vQbZA*H8BI%GJz^N2Gwah zx~8i+l_J$jXlLY`(3QtvewHRmm|Co9KFd~|A|L`FVs02ptyOB<&qXT{N~tb1_;F4lA(?^J!XY?7(ORWI zebP(YMO^}sBND-)V#82M0eBKrW*K7Jkg+o86ZkTV6g4I1nVqTx@4&^Hl9mJjj>!ey zVH&DbPpoQ=U6raug7=eR05T*Wf`~ZJ!_{hWbWo=W9Rwc?ERESmH;t+F9vq*aUM}Y? zfrZAiV?$s-Gpae8Q>PBl0g!3-u_ZD`)407Jr(v;w)HRI@u9Y_DTtp)wv8C0zfL5saB@l_C|9q$+#QU`Xg3 zr?IM%6$uRmj-s`ekvI}q$pbR)BH|GsPf1FSF@l!y`T}RO5L@pYsPi!h)<9TmVZ=Hm zF^kcO0hl3@frtnqst5s52xv&SqhTAGO=a96UcL8bN&vcZ#hUmSr*W-{TJn@e=Yo`t zkDiIqJLiHCAd;zx)ONPeoW!)9FVnC!t;{Y>b(*GEXLfHHE+&2d;l+RSa{tE<@;Fp9 zY~~9_mYN4e&-kgd&?h`UKtNEaDFeX4LEp^gO#IW;su`$AH|s>?wJ(3;-n|bL&;dK* zdE0oznu>|lnjgIPZUJaQx0%*2zVOoh_dmiJrm?m`YppeBF;)FkkAaEAkz;nupUwa< z18BSD`uf`Wy{-#2ZvY4gcIv-~>M!N}f1>`ki&#p1=Hw)mvQDL8#J{ZhYi2v$Uqw`; z)>=z`{-u-Miu-ZwrAjTP`pIy^XKq!Wt{0yE%af)(?f^AT0SRmeQgc3lL5NL^H8!n} zZSa#1(S_)I*fjvq6o{P*J~l*%gsR}Gx)2BoQ{O{*%+9$_?Ekw{C?e0E+?vvK zh?uCo1bFJcI2rj<)#*e=A;%i+; z!?1y>^LalGtHomPYJGisws5@It~W1#<<-!)d-LV@SKn)!*tE^+YW2~*d(6)8N!d$8 z1f-ydxV!01O|>$&?D5w8*4gQK+b=e&Z9i+LVaR1vB*)y(8&$o$ULEi6-@1MB!ykNa zm_{;pef@COH~RJ-Kn)*m*~*tBv=5*bHbjn+r_qVeEQ;b(MgvviDsCAR;w{ zP09oii5{O`x86^aI@XfXY~EUxtLy8gX@EGgAI3pSa?v9(F{AfItZddz7iO~#Jv(yd zL{ie|Ni9ujXF2b?E;RErffWhfkeL9-VHG$c;ken7!w`C@Fh4k|0N?&!{_e@EUw3;4 zWK~P4B^erkj^l=ivS}WNgTq7T<92=3bPGh1GQ@sH#33{wRTR)Hr95vN=P9S;y&uy^ zjsrR+2*|s5F%xAM0L}YWEsxu6h*3p+8>;~-HN69H6dLD!-*;(PZ>PyQRFjnQ>gvKo zX9own5cY9Oy9}1?n2wJQx9e4|Rnl~H>*kcidDqS6HBTJEA|7X{R@D(H+oGMHpIx*~ zbird4728gkfTn5i(JP=T#ptJ$oq-@ZACa8TIrej{l0iJV1d~V|wmA>kh0sK2wMsQw z%u#U4**6WRX_`h65h)A=?8r>4_I;;27H%!<+%T+}*lJOLCUhkwVg_%eR#V;0aCu^> zN`O^ORYKcX5nx4Rt;q~(PBBDP(^T0G!6OY{_B5y z`%7OfkiBOll6wE8f_|BjFv%Ql$=At2@3#vj|9C`7r1Mi|kLnB^bOf`jBv05~j1CyM_ z)po67)$M)zfB(BC<2Qcew}0;+{_b!8XaC*7UjOpTFAUr5QRp1w^^jMh^S$K<53lrc z+cti=Y#%+k1O*r48$W#S#^L;}cTd~iH=*k~Z)$lOmu-9hV)e}3TS$lo>+4N>Pz(Sm zGNBpm7T$5%#MoY4Z%kk|>)F9(JB0wb<}g_XlnOIL5gmtZ2=SLOlspap`NEw0|C1iT z7ZU(q9Dm7_dP3CC)f=_j^*p}+_~_Qr=bi(Me?B+%Q=?b*xu0Q!KNACJw<~MAZXCy7 zxF9|KTWA_dc_$ITFH--}RMm)oH44zjAq4qE$e4ehpLP5J*nX zE{>0n@-+PW|KWe~_ILlu_rCYtv>iReYCCm{nSf&lAH4ncbFaKqYE{+Qtcx)K!n7HQ zv1#Mx>S9N@WOGQYvQnH4`+=JkFLX1<1D7*X?pi=&VltY+g#qDKBrF z{L|n6M}OmQ+CDXJl_x7?7Dv)tqZ)GZ8V-q8TbwnhYWtMi>PQYQf0)pjWNbj z1dOL`an99R0Z`Q(bKCUQ4AE380J3KyLPMyQYtGxXiH2?-L#OO&o}6o9Wc2LN*HT1l zEvaAbo7E~7ntjvaW5iv|t;3qZz&Qg%0st3WEd@-NP|Z?Geb;l02%suRT&67m`WQeN zz`P5{h(HFWS{*yBdAk~7+lmx&VY^xFhXx2$b$2<{oOiva>`Duo?_`IC2n(n0S~*LR28o%FNR^nu%jqK?yNe z5yKE1frS_W&7^8YADo#2(ar&e#0rXLJD9a^0s)(;^Bw?dp3s{o?x_|J(ol{?}hU87+G6fp(nxT~aB1%I^3HCLJ-n|9^vRdOk9AB(<1`xRrzZeF&4TlLhey%*T9lky z%>3$V?L4X4tm&)NUrGJHeR5JtS@yk%;!f!O%eUhI05Gk!mYmIU%3przB`IYW{_*rO zEVY=Kc{T$yBZ68XxKONmifFvp+b^}|T$gRTS*`9o`~2zYLjXdwQWCLWuh*L`zW&zx zzy7UneE)kt3em+`IXOAWIp4eYVGREC^x-sY_Ye2)-@pI-%P(!$TkpEf=5o7UpFDdP z3?4psctSneN1?M9F};q7N%Fw19Wr(gZr*DtTm z_xBIK^6E=c!SB<2G&gntd}PKx2nSITsaK?C-Cyuh#49{pGTP zt*)=}uI|N7Lv?;mn zAMX1Qw<-PRum8r?<9pjww%Zh1@11||{r4O@d}89zDspmiB9Z~{pZ&o<{nodBql&6N z83G_915MMWWq+M&CmFGmG9Y90y+Q_>wV_(B=#-2BYctzpCNnhAQYv%Xw6Wyrv-(ts z2qnvBGyo6)uv_#Or;lf|g__kY5Tv9s4Vw_#5Sx-pN*f=0L^VVOH%yyZJ2&UFDilndhDx#_g~Y?;{}+(q_GG zx+XRun{GBM*EGR3x1YHqnvQN9zx&qP-uYbf-REAoTAekq->$b^*S`Pmy9zq%=Q2&m z7$|J4aPT#iEv*eS<*A=9*)b?0A)x`$Zd4fviFh{)f>dJTOTl*5Y0>)+?%%olEGUA> z+4cEeH%l3@0wLYMfA7Z8jl;tw0Gywn6I(x@AMYPsTs^+NxH^0ExInplv>rACfaW0` z?C+(t4Po)z3(r0N=;7hXO+!0A+B-kJxc}h(>iYWY-}uG{?|)Eo5rxJ4`27#wMW7$Q z{YGf|t8_(?7K^>b{^5J?y)z8stsA%BdE>3c!Qpb=-G25N$Bdsfm-ckR86rMBd;E0E z%%wDbsyp{{cU%C_bxj)OU~jn@u7C7{H~U#!_H9x+UN$Cmwc3zYW&jh8O+W9=IY!&8 zwrCb(H}Bi37ErBf7CS%RlvKNU?}OWJQWHGKFy!2~?KCAo-s?DJWydK?(?+Nj5e)!p zqS%gUU29&vq(aPE0gU=4=32XMc6fA?*}EoO zpFT8$oG0gk_bmcAA1Z*z6xvSIreSTOh6t!l(|~}Ip%g_xF{#!0z&`HCm#pl)XYWl+ zvvTxGR@5At0!yhC3pt+6`W@rXd4G807Kl_p-{P*td*0oApwQiEg%I%?TLlG!>EAvhCZbT1+IyP*Y*=JECDq-D1!C zpirH8QER$caB)nV<$f4aAs;r|bqrpMmYiqHy>Y!7hGFk;KTXBC0;XW#nVsuX5n?p8 zoW(od0r~{YIX4a|dM;XFyT)Bo8!-az0H#{B<`SC@RK*NLyz|6tYO!s-3u79<@;D)0 zJR_;55Mu(eg~mmr_4-wn%@24_rCO%uPK=cIJRjT)i95#?_ATg47%E8 z9R~sc1x6e-5xcX?!BIuo9PZz~xK4Y$PutN|F*cD6+BVMSGf@u)!3R(! zL^TpqKyr={9kDaBxPRnwlA0J0h(Egj;lbenHCLPKZ8s}uZo65Vrpp3<@IU`oAmtw; z|7(BiztsNZrIY1i*@!vs=++?;+57K(WGc~z#eSUD!(!1rx>!AT=U}y(#?9(*@95;H zld2z`Zsv{u% z;PLgXiYYC_?_{szduzU z7e|C{xxatC+PJ3o&2qkXR8B00<#)o8G#s7T?h)Opn#wzyvrvj#d82q0su1vHAP~7czm2nYGN}E8v?kz z+PwDaD_7@dI$Y4ab>5R^YGQ~H0CK9ONQ@}Cn3)SrDP?CpL?g*Vo-!~35Y&ojCWazS z^yES*({O#&&F3nDj8byZY1nKiwp|F*G&CU`^uZjHi%p2zNtzgkaTB`O`GuG<6QmrP z2)GMK!YWn9!H5~jyb%BcUsTGLZ|xfgyR%3L+^q?aW}iUB}w6 z_vBpIB?^KTF%jWh%@o=efRQXlt~DXE_g+Lm1vun75jk>%z$I58Vsfyfu}CFw-TY8R zkN^l7cxSmxMPw?$R}oV+^ifq2iAc zh<8D?A_+0OK(%tsnL~%(n}|pSFdth0NYm(}15@v#%0E$EaF`^ilshabRqWIuUH1xBy-GG>A z7EuN8A^HGCg$zw(%9E)w10u%QvUe#ZF?si@hW6^McOM>g^jBVc@r9d zsz;KKQ(kv4w)MpYerzyC=2~kSw?{W`EDnyH|BSSNUAOzq*I&PT=fr!o&iC_UH8j)N zY;kq`lAgM zfWoUUed*iZ{&oxvJF*(hl3D{+MYW3jO5Xom%A)H;6~MNocHV*gCCM||nT?2$4GG|d zuYK)Kt)+^Hr0sT>*;{k|iFyD5un2hvW>w4uVlopp5sYEnZrF!z*3?=-cdD*w%_?Ys zwG<>G(r^6Qmmhra-h98md37eoh5V4-b#e&d&A@4h=0Qdi>!>H%?A+E^V{$ zK3-j34~}k}K0b?myT5mEar%fLEDmnuVTgTn>eNK7 zruD`({n^Dis;;lE+qV7g_kZ}+FTV<=F?fm|%|xw@A&qwW=)pJ+i{&1G9WVDz&mOYp z^~GwrJeY=QwzoG| zV~60$cWw8*AHI3_&aL(OI!}53aNmcpdv$ksGauvs^_@TZ>%aNysgzu@e5}6{qI3KY zfB%oV#lk!OS=BWnlr^Kn+IizQn++H_j|j9g0e~2hpYPB7 z^;$~FpyU{e?C&4l|KQ!{p8wL63Xslb^Hg%lRRC%!hRp0PF3(RNp53|gOxySG{P^AN znD5?w_Wnm_&z#WZ)vCRH+q~agUZ?a?-*<2P=tuhpH^yOmaD-FN+hIJrymHPDV;wf5 zkr5&x-VDtSmnEe#l8}^~Oo5$u?CO*Z^u~>wkMG^PbNBfwc=PbqdVOK4DJKJZ`NbFR zfAAhToQBfGCU$MD@bJ+iGrjZtOCP@f;}^g5(y-XJz8%N$>iXjJ^wGhM8;>5`zr0$# z^75~zVh~)ZyRVIVwv>CS6+DMt+!{hczAet z|AP-_v+j)_{J?u#%;rD-@mu@z@((njAmalPI)jZ=kjJ5(?-bqpqTUC;&R z6<5PZ2&&q2Avhk3nn+0!0xlYtRXEbsY9xfNi#5TldlD_0bB!T7f@wRc=2^?D^}6lb z3WR{uG&x2yL?4+^)d2F8(Z|M+8t0};Kond6ATvc1HXw3rPz;?TLXzw~A(|fG9anZ9nU}#nDpqi?Z zCwpRz1CLgUB1fG@Y%Ioh*0o9;Jg?W+H76haut{Cp?8at0-)2xS*K}M(^DrwH6jyQ8mDeHFC_zWhDr#jK%J(xY1Zo%GH%va zF?L{je)gcB?Ul4ugSP967^4{xnkQ0GB}NyVs+v}EP%Yd4!`_=US$17#Vr$rYpW%)< z)`%GdL4Xh`4r;fKQ;S&nenev;g6w+FdfEs_!` zk|IE2B!B{{DzkF9(;4=#*7CzGKoB@cv_ZQS#*U1PsEoQdPUgAioV~uWC|5NzB~>C2 z6H=EXA!-09mMMgOyKUz)M4n7*q{p$FMkIjUX2s+wFqk@k0?33-(_F2$(^-AF+GyOK zEGH$VRYYV)=brq+i`$_iC1AI{xNsp%>ZV{CV`0X=>wFbb_GlDZXNJ?+^!jpl^X9>y zf9IXwc>d;YwL4yf2j?qK`p*0K!m~G(7j+fRA3frJb^opJJ@wQRtH`cy_kn}^3DaQ! zP}|FqGy@P8K<3~kVvuvW`_!|dRyR{u^+jS+g@>yjXGyQT_}qsNAHMSPOIPdbAN=8e z`N93G+s6~xbhrQA|KxZ6?r)x+o~*A{|KY#!!jJBqpRe+2GX$pK402hocJq0KRKNMo z!+Bd@UR~cgnIhw(>+Qi}e!1@3%71WwGo5;7G6h5^Wi%02)dn!1P4-E6qzY(N<@<3= zF*lX3n6}+^82ohR8F{_w5T&jgk;2SBd)u*3tj~7O2LM-B*URPn*UAArE&#Y*)6WJU zeZGDHEcUpK>+|*b`hOk$2ZQ4qH!dGN`mB3^_dxw;Tm+1WL`Y0#D)Jd$GYa+@`*41p zDM0%$YWsiIFuVuuC-Zr?-Ts_|G&9r5d?}KDAxW^esr~h~wqKS4^f4X&*fsLeONiXQ zq!0j7-@B%Y-L73Ma#6?J&Ss+g!`B|%`-A_?wG+UKrl)n$N!!-*IfB1={3IAK6FWwA zU}BDeT**nnyhi|L$AGFCs_8@#KoKCBp$nB1QBcBQno`P4j+j&p2vva`#pG%i2(V~T zPzEeTm>dA06)EPtpn{12+TOFTsz|`dV~&z^`Se%D*S~dr{!kGv@4a<&bo`wky#056 z^Tk(R{pstkzw^7l_YVP!sKgknDwHA=qiPCGHFSNBUCB{%QN-zd$qrNmR2@+PU`K|v zSd4Kba_l%Xtx4&-t__623&60u1ab$}#3t zkQALG1W+?1GjSZ;q^Yu)^Crb&S)AM~<0vs2(XiXK(?uycOP7Y|oO2=gP!mxadmso^ zV*o@h$3Bf^dC(x3lo(amdnQNDhsjjbkk}YO)Qk`a6aaCbhr>wVPz$g}CbGw$YjnuS zSo-48kX*$~Oh^>_$Y^mGn4JM3GZR#mXXGqGM2H5&eLsR0L#RUV-cM$;Vb}TK5G@T| z%z3_8A^@7jVF2QiqDrPv@3%fGB{Yqyn22+nA{a_ev2Ev4B#o<3H~SPTM;?(}705d# zDmjY@01=>>F>(O`097Cc7sAKFNi!2O6LH>~7_!T;!?p$BPzOh@qyz|tz^21y!`>4b zF_;p7I6`A4;#dkf=fFe_0X-u)%-I~9YBbRtduCTub52E6)h2;b%!uront?(ch`e(( zdzKsxV7J{l_NtOg-uLG*6>?}vP%=1grDO%~#QSE98Ij!MG#jadS0ymcA|w`Eg<)S} z$pG5a!4NQ75zH#{4 zYp*RAZPm138AZg;Vi^31I}xd<}+4blH;Q++IvM#L_ciFbc{DS(eVfcMQJ z1aP*Egm7W@)*pZ8AN-xKnG`J|D!jiLhLCf{PfBP306*{GcoyaN+Dv=Y!FTe6)>Y|FUckI}*IEQ6Oi^b8T z$z8v7RU@(VV^5B@>$R9jNz?hH+iaZoj3z*#^$ZXdeF&mJNOetp>V0uoh0UfvIhkpx zK^49B{V;7OSTXHeM2HYTV|nJOJ0~|zt}o9|Z=X7HKY8s<`b6fULH?SrHctE%~5zV#v7gUQ#&M7=i~|yijb42{X*9cT=&I1PZPV>KSGmURBc0U|XVr1& z+4H1n`*8@N)l!JD2#FSQGIa6m(IfJe_w?w|^=#VIyWQ1h+`RV2-ZHX3wv*$7oYf>s zpQ_zpNH=cY*lxD$u&(Qq0pa}7^})fkq(Vfhw(a)f_)7pdU%j?Js-{BcLQEw% zdT{TaZ>l;}Vml+vSya<(KEHA6h8CH={IUn0FBT#2t3UXW0vsM5KlRj8>-A>4d-Lqk z2Twl#!s1|hes0XEynXBF=-}bQ^SgKNO4czY$BsT(8}rde;8S+7PmOr)@?vFX2S-Pr;&?wA zX+GIeW?&FYxp{h!jh=t%#?{q82=88OLvUl#@zDe0$}N{?>#Z7=oI}-m&uA8i9<6p& zaBbz2;HawExT)Exsiu^2$&L2{c)jWz)4Z*RE;=e=j@d6JkD05@s+-Ij=e^{tx-*U4 z*bsn2M(>n;jvY`S0MMjHTC$1wrj<0-6E8r`w3bwg!C+EVO$f|{pe3vAHY+p=bw%DA z(zKe#ZY-scqaXgSe>goo`K`bI?_AygAjf1TNNQ@{S5gWf;@;w2q84jrlaexps^sE* z9dj1lnwpk^RRxwQG$vX#EvW7X%VOCKjP?W#ilkUF_KI9rO%1B06z}}7>)Powur~x? z5*3j|fK~*V!2pV=h=~A^5!pTf&NDFYjgF2`Q*z`Y4C4^n#R3RGl$3@X6*Q2GLxg>M z3IMPVJWFaWu#LJnm@&wEgeUFYitk=Xh7U;XaElV4~TQ_8w$i3qrA=8S?3hZ@*Hj$K_X7xSv$B_dj0M5?OWdiaSvB%GFu7&A+lLYxvs06 z)e)*0nt_N}Hb6y2hlJ474G@wV)P7b?iVCZ}^zv6WDb5dWP8TOb9v+;pZX6vy`^-E^ z!m7FW7ytP8|5@KoZcJbN-STh$?$xzS<`Wvmmu@w0Jlf?&>BiD^Q3Rg5bF}Hx@p7u7 zn|?e#oKNd;elhe(Zk^2TJ-BWfH=WFg&PP6)t<56*AgI#reb8>jB$hk*U% zX~K^aX6^C7Xw7W;X)annjsAn#FXv6nEL2sB@vo);ee|gY%sF}=_P^KAb?sz=L}&_# zIc6s8w^v8EpYqfBIKJIX=b@@fwC{fBd++_x?^m;WxxASWnyN-BzMjpGZh%=mn};w_ z&8Yw}8A*!j#SjWRB0zTD5t1ShL6CjqF(88TS|pEyQ6fShNbPqE%fP zn2L_6ILDfMat;vp*favfAtM2zLzI2wIuQXlLMC)o17N9UEh2A@_M`2Ts>>?`szHV?7es7a#2+U=3UpZ zt185lfsslQM6d$5pR2q>+EZs}mNg{;aA9KXAyfnzGRHV_9?^)1!O&Few#`z!58xR0 zMGvfjILrben5c>5T!wz?lTTbL1u?xaoEIh)SQr6C8jv!IKb?HD{rPH zWh8dY&IKt&iZN-?66z^AV?@>Rc*;UFLvjSFM0*I=(lE5MSxKoN21Uodt^+blF%<#8 z)#_0hlMA(T0Wj}X^CFgW7AvL-h|ZH|)?Lmfl#$U)p@<719piR+uuy?glzkm6smjpr7}@qJZX+e)stUA7!w|d!hd`9$NaRY%h-ivqE{~%K z)P}ADQ0KjOmGds9%=k`&3#xm>dM zluI&EQxGi9Q7Mtl6B0TK%v~IcfcK8kim7wRNX)K?l_G{1Q}R^^AxKK-{T|{}DJnvB zty=c+og&&yCwoCpDdHRf7>8;PPn06w6A-b1stFd%j0mc_ufUa3kO=_|LRFgxh$%35 zYGRJ6N)A<2MF}D2QgTEa)5C7pU#>3JkFJX; zqi^f_!Py6!O{b}F+Y%TUu)?&OY&NTd8GDf<-)SO^~O&? zA&t5?nB9HiiOY+N<#HMGaD938PJhJo|08#kxtkXK*4VG&Lilxi-|HX;Gn+(fMXRn+-XpE-t1m zBb#x~D-A@zf*xe&&opAg458Za^nDra(35pd&d zz1yNH+BPJva z-d|l_AD-TlzJz7{;!7|5>}9-9cP~Z0_xf93d*S*0PrP^k^pC&W)O9KLOLmfoCPmwJ zo?7FFgOPfB9`74`!-z^VY3W3hBNQ#heQw!bG*N zNKJ9i3XmsvFk8HJeHKEc0Gly2TAb1PYO^>z=!apq-5lJw!72bS%6R|mEDrI;lXvew zIO~TPe6{PkX;Vw_pZdl3oe0iXKUa&h$8FGXGHI)d`*94Ru0nNka;wA$K$E6HSAnIv zKFuO*sEBRTAfof(@Tl7Dwy7jDBOuT0*k@2HWz+T7>y78N8F)tz&L7YCPd<5vJO|H! z^u(Q8!w@U)zxc&xADx}e=f|LmE|}_MGTE-zReO}iUcuP=;KE`)JwLy=b?bPy>kg0R z>~458_AbWZ=;>#b%67f|;JpvO_~n-#-v8j{&D(Fh`NoZ-15|zD$=eCEsjJrCbd|fl zz78R@ZHwelz{rZ`^NVXxSRO8*06IE6T$o6bG@r~jyDb4k*%yn(Z5Ih(*Y*8%i78JS zF2!c^*)vZ+{o%d$O3Cb8<*N`vZNW`_8w&@mv3zXIx)zZ{DOF<@)M! zxtRatji0>o^{>D4&Rba`GNvLA&(9VIi|eb4&1Uo9;fKdZrzfY!=MT?+`sPo+`t`4* zlrAo=x^Z}T_Ru>QJnj1?iv4ODF1N3iEA}|_Mkdvy z5-~(I6RuijVmC1Z$uZ{9g+|rdN$q__Op=od5aGrB52uSoGrvph(A4?Bi$=7hVO$(6 z7q_3izW+f#tX&8tWmRDxOf~0GawdkskW`E15dF|^%s^CF#Suvs_5p*hTp(t0K_OX+ zfatu>F%I3e3oTWUjTn$Zm{qf3y8dHjdT>Bk z)QG5Ga;ms@;++Q5rwwOF)Hz-UBujX-L9(In6s%7AXf|kY^WGg zN}7hMnGD0$OjfIH9%DTXIp?OGn%QhNU+=bc?MwCuwp*=2-IC*>8?+>@yhF#8ci!

5->_>Aa-O5PT9K{H4Pb{5Ct@I?1(w0t`3ua9P7Gq0knXkb3`D9jLru_ z7BMSDokLZsT9d?xh$uO0%z^x5wlsh^_7nnJ8M7=74s3N@H-35NDYo3!?#nOTEiod8 zJoce!+iCmupZ%#41@9b^q5x1;`BIdil)d=K3Lzke?RHCGZ3U&|qj~eaAN=?$FFzOi z?ak8zCdW{3#{A&nWsvQ|v$L09dLhA-eIP_o0YvYJK?MY`LLx9zQ1-RvOeUJe9Aim> z=v)m3E_ja&QaDsKd$5>eD#P}xhqo0{?z?WY@t$|P-c7~&?dnH=@ZZ1s2Sm`e)7yXd zKLURG;o0yHzWU6gu{=Dx60jkbs&?DhvQIXPcF?h16Fq?|>ZV?;k} zH^)yt$H)P|vw#2n^Pm22|G3|dVOlTmJb`Rn10>H>XM!v4BJ0XHnNC5i8+OfXNsidNqH=w9F>PBHnj~d^ z4c6@p2?HWR(Nd&DcAnXjYk(|FXUuMOeMLwQKX^X?3PJV0cz1N;Zjn+_an6&gCKGRH z74ge-e0Ex6nQQuA|iLWXIQUrDmB^NUS z9?OuoU8q}P6fFqIzOKFRb}KN;eP6Zn6h~w(!`RGPL1HFC+{I3Eb~O@%0;8zx1DE#S zi5O_iV-cymLjnelV`eld`*>yA>tS70YstA3$7l*MM?^L=W(0sx*C`G;C3McQAInA! zN{qg#&8QRwht7o}nLJg^M5Jui*K=e;@Bpb~Gv~arZ>KH{{VtabVu(oWvm`9E*I_dt zFqM+j%&erSE`$_^;Jx=%%m@{l6hZ<9L}d2BkVa)hs45dfCdvSy%vKZ}si`4>lwuix zxSrOc$r~vU0`4^^k~Qb-CXGb3l0&GvF*{eVKve}F+&J{azK9r@iI6F?0XQTSFa(x; z7l>LZ%C3kAF%whH$qbFzdr~b$0g4tZrjn#Iv&oFZ5TmagA;~c0lvD~MS5524my$~< zi^Ib>bba54x?-Y~B4eqWX$Xjvy?2O~Q{4LpL?p+=feDHhLIh+4Lq#Fo_iq!5Y5`Is zP-Ewqi^d zDQP5f99UEkVBhY$uWnY8;Js=gbiNACdlfJhWMpEIVk*x25b9D2*9->8u8c!0Ua;S&Sn)^3Fk_t8IVx=J8+LTmPfqxH-hq zR+Dk;EFiNRy3R2JV;KbK=WbGA-yOPGvMP^nQ|IOd~z3+bayI+3kmEHBD&31csed(S1CFpjOYmO|`R zGg0_R^=gj;)&Rg@mlCMDx|nWk`|UT`jH@c8Xb1;~hbK2q;xN2_@8PXGPn?~fmoZJJ zQ_&I}TOl)K)m3p0D@sR8khnOL!Z{`fOP-<{pX*1Zcv>~X9q_M z6%FLG6a#S1@0of;2+o^`%41uABd)8-;j~$gSRYV9r#Iawm z>oi6~TP(by^FWBGq+>rI;@7_U^|#-7V?LjB-8yAWS`HQmNk#h9#rWcvzVxTx{vJ7W z&XN`nh(riPN=HZY)zxmXm<#19R0?WhX|yqo)A>?M@n(T&9HAdm8^UxpnGu~Foy4)M zHmeWsKiqD9B&OwjQL3yd+)rnI6P3$ zX41wF9w^Ao(;E-ZALcBUw<_CrJj2CS za{0q=|DW@w-3kg~6Kbl>4AK}KbKr)-$T>|mq$p}K4jh82q!@h_46UkKEd>>2>_ez~ z$$`B?1Yhy&SW!zZ%uLQzb(2#f@?(iLg;GW>stR>82TLfvXi42#6|AHvq>zX_c}IkK zj1C{4c z7!gcmBt=a!naz9Kl++z9?^Km9sqErlh^EFq%<8%u1}V92nh;QmD={OJnGq;e-Wg06 z&Cn0dg{rAdt*UDxSCZtMOA%FY4d8USQeMRr6;7N~NeuBb>+4U?n#pqS=a&M9_j?EBriNS0WN&>#Ib z|M@>D@a1Q3y!WH8Jo)9n|IF=0Xd5)yZFfh@sTw&BPU6EytJ%Drgef!KdvHmJ!BJb& zqpR-j&BLp8zc`p;5kxXD0Ca3QCH6HS#9;s=c-$iO(Jr=>(X0vq0FWK|s-7)~SxZSn zcX{@~;f7$6G#|7Yj>CH0SyRARMKJaIc zllHGRM7)3he6d*U`tjs&USb)ORjy^{y0{gkqoY~B+r=2$rdqUhQ7}Z!sSe@RjU!iA zE^!eP%e4=Vnb~{i#$l*}i^V)U?|j!Kh0+9{L~$?jB-&?1`%pdRFaKtzcyBkkb@z$0 z2OsY9I`Jd=f)Igdb$Kyt*W1hUdb%jv>o7l55d>-4_UvqZ@2x+(_`yHncItfVTE}$_ z32xoIwb@>uo<6xez3n)pu`@u)*)^7GOglt+YjXPIW%&gf0 zQ7Rb-KoztIP#{Z^5sd&<_xndKr4TWZFA|+|pjov5kO3125CIS=767M!1jUp>$bBCL zd|iX>1>9s>E-u%LgXLzs$yvB+yZ8V6ORs#D{S&PD;^N}qV0pD3Ui-n1Z{9x0DTk_A z9vzJUo}6>86eGv8@ASbD)Y^h83;Y6^&^*i7e^hhYRF$Z1@!H-d7^> z;NIK5YJAleH4e>KGMIsLCK0fpD4LX13VPoZgX(l`VdrAMD`c3_l}&e z>q<>LSI8WyHm6AF3C+|H!8;G$k$2u#dliToFf$>G01-Opim9NAWKhX~<`A@)$v*BM zk-$JeVmDU477_vu?Ig!RWml5-Ri&2W06BKfH-J_(p(q4j|E0Ozz&SE7#O$4uB*dI! zRLxX0CCxdSO%ZH5pBF_bA|**2hnT01W{c%G_P%Ptv~hJQscD=KWD4FS;S)t#)Nhu66aKsp`6YK6@?cFZiuIY(6mlrm%@HUojACeAri zBj?owh}AUZoMZ7JAcI4vs-Q;fT&U2{$g~I`pr|Tj)!-ZeQV2PYW$a7Ng6x@1L=0RN z(2NVN$||M_qK_BV(?iUJq{k|~C&fnN|< zhZw4Q(zciD-rTtl^(X(^$JhxGrkwBGxV`PRIp%^zO9CJ=GXV5FTTE6LR{?o>aCmij zA=Y`{Ixs;?MK$Gw3BUmufIQ}q_m2nw12{Rku_ymNd0>R}XMg&g`Qh@;6Hh$6_pm)Y zuwqr){K=pE@pQJ>uGdmT1(|5*qWgvDf0;Jb-T?7)oQH`0zrq~A-iNm*^_kf_et32j znkj(+bdI@*ZC9(=a=EvAnpqr%x@`&3F<}UQ^qud&^o3`a^R|pKnzV|4Y5dUgF)Zwe z$hlz{iT&y6i3`oq;qkY=^_?n&x^BCn3!bacmXeq`souVQ=fU}Xrho_v#sn{affj_lbW#~~(-^V#B{X>#mEVLF>da$?1l6qG|ft=xlqAJo%!+8qAm zM}JP_mWK!P!{gwq*lnqrHFY!Q;;ZVko#rxr@B2Ue`Zr$5Ln)GodAD1kF?e1s4jn>2 z^pZ1rrlNaUYEhfE)Af3-r8ITx9IUq6shXM8P1S9?x@|*noAo9ERh3t@eq4JDKDcpA zp6g=PdY6jyW1dc$l8cx)Un9hl%sEm4Ltlyzn1afn;1vuQ2m(0rPE*MRe!=#b5s5tm z|H%*j!px9)Hf@;rmkWUQ&Ob%#)|-QallcPk*wb=0t!oufDrj0t5;&;&N~-avl0h|e0Bcl!?5#JHTPabiAhW9$I*LV z`7rdmqod<8WNL^Jjd>Wxqk{tl9plhWr}O1j>Z-9336Bb$#!HcMlf_tJSs+1OQS@3B38M-NoV2@{KoMCjv$^PzOXv zjvSCC(D`(Fd9hK@Ni$imcD^F-m>uayj)+f!lbE(G5R6btjUCs~s-Fn@1n^nJEy>Wbc za__wlZ`?Ri08qPq`}TY9-|KfHp}zd(FLr%Tb+z4g&pr1-Dd}o;b$NY0^y4?a@wM-N z=Ueq;zE~bzU+)`henkhsr_ldTt%G?$03_ISh5!V%>GHwB{H^yci>#(Jtk&Dfbn?_w zw^r-jcGKs+Z>H_EZFhYvF@-j4*F)7xRZpvChD4KTwOV(Z-Vh6-uUcnDh*Hd^lR1Ee z+Ff34Z=NoOQO(Rm*4tq|Yr5^Oshy>iBu*L^kf{kVMj^@t7|=T`3hW(+T5_&^B_I?6 zv(p^ODb@{n*FaM@O(}z<4Ex7FdL{;f;p$Pp+b)hzO^Z4=TOQt=FR`6iF3n{2>OcJ- zkH7Sl<>Be&hws#j1Me&6{Me0vz>W>g4EOd8CN6}bodP1HNDkDf^)-91#OQIaq?%0U zT1rky_I*|gLn(c2!lCiOd%VyHffw&*#e=3j!Gw zA|e782rv+{Z3k3jUmIu1l2Qg>MVQQ5k$sA69=aG@sONKL=Uo6I6A7L(^K>#RB@f-Y zYMOesV32<7o2CvvWGz;*AY^kOl(ckFrjvG;HYJYZ&hS@)g(451ah@kKUfvL)t#%aGGNxh-kGLv~|@F z<7%@Cn5AMIjgh%(0nq^&8nP!X`!01L1Ea?}LqYNZK&^-}BD3bi==VELV3Lvn9Xn#j zYD@u~i3=VL0NvPaeVMmlld&7SZNIyoHFanLB55uUfBet4Z-4)XGD3>4{0ILj`sQmd zKYeRi{ZD`T-o(4-o;)dnfce!oA3SsSIClMZh$T0O_`!qg5C{Oy&oAc(Gf{3EevInK zfB>;i)nvZMYd(@;n(Y&-YC?9tnKX;z-~W&Q5j)5O{QLjKf90#@^5KKS8@JHFO#e1Q ziX!@X{Lild4}Sh9_cpRHfyQ7FV?0Af2GOO0tIm{{<#$76{mA*to2INm}p3U^r&g;MW zA#`}Y5kE?*bp z;@g@l=j+P1uBnc1Jh|R%Z$I}6u&b(?eGo04n7s$plCo>7q6X-Qi}RI;l(DaxsrR9P z=G1v+$1F;|;$cjrTC_Ms-FL7e1qL)LfC`1kDS&eU005OF8zB+_xW~<6B{EVWhh%K~ z2^>*@i0ZnIr68KBAac$TfDaF5yFQ-YI9$x%AIEsGSU!Asb@!L8&{fq{-OZuf-JmE-pkZ5vV8F6h2DJCWD+69g{x4*24G5lxg<;r& z>5TvZwn>oPqGZ~n*s8AK)%fbYd^z4JhBJMi7dKy3HM_dmq)3^I4j}JMWCk+h-Wze^ zoZo0ITgyZyD^}IRJ16h|!8mNz%lpUojt(UCSGxf<8AD(^h+1cc?bd~ff|$_EeN%D? zVMeT3H_fcpTw+pGLIav| zEyUJa(yE#ZG634pPTgcmLRbrugI-E)EI@TpoJWZl$_%&r)7f*kT*^=WvNv#)@ITG=n#`3Q%kC)lpNzY)>3@% zdx5QrGE4haV|_j1wq)it+N0y z4AD5-7-PtEyKSn)8iQC<*X_DZGoLdW>s&CvZjr`pt*?sxZiPwgtjVgA>0~;esn)%+ zvXp%nrLC%EECgj7V~Mfmv0b*z?1{BjMjUey#IorCOG&vjrLk@@nO4vy_>}6cObW?) zXPhA*B~2;0(748ERVg`UEj22FZ>QcH0P-PpyG{^@Ob9J9ma!K>ATY*};Sv)uDv0+1 z2%I&s9|(%In6-e20>@Z`^MGX-qP2|zIPan6aU9y&WZ3m=*&z43jttilgR_8|OLpAE zVJM~S@1ewq%%~u;w+F$k-Jl>#gUj zuf6uQ)0ZEN@v*U{TW=1Ij@MT=FTeVRB@RBk^vdh+eemwGp)^LH%r38{^Z8=2+-}#- zQ5}fji*gx4GQ{8i{tv8W`r|>~IA6}a@n>gGY_Q$BpB+rF=yWkZJ-lNLj9nHe<8Cz8 z#wyJGQ_%m4!1`4p=>3cQ%T@;P`OK|~s#K8rt=C`sqaVHVo8SMZ&KjzbU8At?*HdQR za{wTss(0_-e|~lr_DLp<4F)f7Hp}URm|AjDYRgG4K0K7kc5&y{#z8@>R^3uI#(#B5hvYE7#-FDp#Jt*8gxzkMB z=g*#P`~Laa^Os(EG;OC~3;}GnJFSJ7hi;5xLBsReoRH9<6uG`WZ>BRqMeAbh$C9jZ zC6`Y=czkklmkeoDB$X7OuUA=RZv3v>{OWgq-I$uj?2PeEgLvn&r{^N2nM|CwRrKoO z`LF-luZR$OW>jY_SM5@s&L-aDZr$Y=$vHz@D3LM7kQCT;J0cQ6(VEL%0|I$W{d$-+ zzNC~1y!9f*dB0g*6QXN_fI15mG3S(!(pZ;^>Gj3gY;mXnxgWg`b|#X95OR{qq`A4- zfmCB1AtF6*3)Y{#7DYf68B0%O7~$#D=Kyf$?mZE4 z1`=4s1W2G-wbm>Mm}B0qN9N=`gr?mW_UMbwJ1JR87O5}HqQb<}rb#8Ma1wFO=A3uC z{@$HCqB`Vqa_1fZ*fvO!aTr!N>!FKB%jIIW6e)eou9gs*ukge$H^DRWPvXN0z?LmJ zfqM7!~k#GGn{GN0dPWFd8)0qFR6xm|V5qS-?_2#RRDw<)EnT2mwu<6N$l z0ibFH<9vv<+io^TN5?wUQj4Ngt$;FZ+OFwSO7rD>KAn8{@rTxiN~^ZD-L`YiQKmFR z=iE3BXhYlh=jWF%zx*JyQ$)Rf{`_$6Lp!ZinlK5|)}&H%K0G~4V>h3-0x%3Q_1kZM z`&S-+@Sz}CZyA}%5*c$#iZBuyL;I?aP1&8?JBr;{YC1SN-R`>QXXlR|J{)pBJUqmz z}HMBoP%|#G8*(e)jVH(>H$kwX5r^L4~ErH zvyL(U&iDWEv<+j~bTJw>x2v%~6#?+m_P>=TDJlR8%v)ORA|hDC&z@W`=)o*pTx@5P zCXgU%aF%3f=kro|wb{BRAOMP1q}DZQ%#&%@tgf#vcAJZ{qeow>+02@D*Y(~L05%Q_ zIF&f=Hs1QKuU*#}B6dg?W2{oMf~k^`@OsrX!8!{->L^HxXh>D9Wf7l>0HRPeXhopp zQB@rUU<_d*nqnHAwY3U@ATc0ZUY@O=d@O)@=oF|g<<-NZ`N_T2%{53-W1ZvIf8%f7 zTs%Af?1TB@#I@cUFC}Nm8i(opfgz(PRcx(QK^TpyK-DVM`XD)`T4+=RZR{kIs#an~ zqJ7tH$)f;xHxZCpbBS3c`(_GN)7~WZCXr#>Sh1qFQTJHb@M{8W0ha zIV)LDWJD36Fwtf=)LPomRD#KTI;PaNjRHtX-Z~)Yb7Xd6(xx8>M3||RzU$cFu-oxs zIhjqzzGpPnavXD*K-KD<(^9KoKUQmax7iYL16&0{K*uS!S=3q!D!G)@_ujYD!{bsi5H(>| zrKYiG11^M^qvTSxI&_BoYPBX-vz#9;mP5Z9*5oHgBbJ9p&DHs~Su|4W&DF)z_kN@$ zo2Hql`uU-;VRpzd=QNDYOCGan(OdQ=jIk=(XHTCEtDEV}kDF^34!-$~uYK~_+4&{p z>+#ixr(Iu~8OLtdSm`Pt8$bX>Lq?z?vXo2!Ko*dsRI-RbWDOJnt$Pm|0Fi)*6e|W$ zD-L;_w@_07hIX`>$$}6vY`s68-xp()K?RFq* z)J@*`NB>1G!yo+jtGE8$zw=lB)o=g5@12*SNGYr9)oYJVB$p8Ew6Op>Z`m)sfC?zI|!5&ls9i*XqIV*4|o|2wha7jMKbw!Z|c$-fXfP|z^G zz|ViGw&+jG05J2}*~PuP$IL_|UqS?KlWsl_3({M;JrOC>KKX;_b28uy0sa?9vz*VK zJlnqi&inHF|I-_*A`8)t?5rt2obgtqM?`7rBa zxm*qR?;hV=ZJL%n`=?JodwBo;ri-ifZnI8DN6T2XWSzI>;BY|-DW%179vWYJJ$t@6 zI+|~GTO6_R2q@=g>-!InpPsGSK#N6lcCj%)-OwK_nzPGo8`y@~bQ=0tiD-Q_ZfLxJ z_h{P>{cbSUY=(4va*)Tg-FCBiD+#3(k>YFvOcQHmR<`Rdv~Czv@FB*mwZ@c*cpOs2 z61)e{<-vTt+8GNBb&RD{n9Zg{8slIp7d{M#wsM)g-}?Q~v5HK&?|jZw8Kr4(t}P;zCXP1}MB0J+eB zMj=T#r<_U}(-0Fvjyo4-WDGzt&^1W*PO_(s+K7Gs>WtA zQB@{X5yPy+26SKRq9wC&M2w)u7%6oxM%G$#&LD=31Atw*+jcTr9M98`4cSD( z&Pc94%o6O7**WLDL)08o?1rWdD$@5OGZIlQIptwLx+cL;Qb9mMm0C(QM3uP2s3q+i z+y#V8gP>B;SQm$gSbQ6-HE|q`3Cz^Yryx>t8T&y*44ZvLVH%^gtfDaur4(xo@8$dk zYH=*!gHNSW(V_*jhTw@=0iZ@^gv!IvS7mF#5?6u(wT%7c<@)H({hN!=UU~g>7iKYz zdvHIeRDiAb-7vI10Ff&CrbWeeI){BLHYzf)F*(PY1wg7+Ydj(vKqcB6z$yrq3?S@+ zML=dm1_dDnAyh46uC)?s96M%L`<*c+rR0480MLp8#?owdKn6nyB_|*f6;*{)*{eV? zY`mdb)lu6vK7{b2XBWTm?U(A<|6AXE`TIY7Hmq)}!5EWOvep5c@-ypX_ATwV_tsk@ z+Wvdm+u1I!H-v~NvB+XEba z?){gn#ZN!|Pyh&w^9|7#vj!q^&Q9ku@AfSqUpgvP?;8Uc!n|8=C-W8+hjF*L&Ihx@ z2sMqvkYZ??afoDib$$(qU&{S2v!99ne<2k3OH&4Lo8u=^MMUJm@!=k@&!wsgA@Aon zT1K=1R1q=e>Md_qtNC*I`RXr@!~EzdZwFP#P^ze5sH%jdpTE213kqN?#XDQ2Alq%f z8`mqTX1QpZ*3Xv@Q1R)LC&#BpY(gw4#^{`1%$J*PgQ)u&hL>J>Y3zGLlwxYy>8{`O z<8F1ce)-i`Qy$p3e(1&+FD}>r+Hd^Tr=NaW1lLzrZLp;%qSSp~3DI=g8s}A{Uw65V zZ9C0HN=);`0s&)=aU29BOecNpJvWMKtlM?Fk3ad$8;(ix7#~0W7(fxZs-%<`vq?7$ z-dbWKTDmTV;Pt~NzG=Gk&B5W(kkfY88#1NjDymwD5TlT>E`)I$K_I0>hK`O7_CV`q zw<$$-+uf`UG3QhTr0jNSKAEjI+pgaM(tNQb!m;m~*`(VHU^M44nKyYHn#rPRXIE#R zkq^0MgN_~N90_!@8z&*C!CEwzN?6hGG+3yVh7o?UDC4KNX?^SI=a_;cVyU&YGizLt zdbC`GHbl*)N>R{Uv}&y?Le{y>YBgUjPw(FK&QSGe_-1vzSj_fUjtJC>Y#SED7d@av zyqrylwDHYm?567*e{l5jqX*ZkZPo-)r)?`BhCosx=61TAHqE9RLOcK9gO5*64sLF) z=d*dOUjc3qk+T-}?Lj|rF(I&s08zn1t!LW(5`D{!B zDCPvSCPb}Q7taq5kF0Z_efoh5p~hlus5Jul$)riO8qipyLzhzOhQZr#eR;859&|%z zj9D&cu#c&cqO6jO zw!7_g(tPiG-|fc^0A};~#ntnN_g{MV@q2H*_4Q9b{`B(lMp-?vS+omeXWV>gE}x(G z{r1f_Uc0`&^wY^~>RH({wu{-rhYue=e*dMHUU~NHY!YUxtLv-vwheT2bQoi{&N!pH z?e5PokQx>J=@i))&w{v^xXsP^wzmh1X0`4&D?V7ZeUhiwJJar_Q(u$!bDv{gOxkBx zn_A1nwT!Uowsm{CIJz^NE&5odM-PJcB(UweVBLDVt+Cv_v#5QSO3g{E<;BSoK-SyA zN^We+R?|S&n_b&9WQ?^11acNc1IDTrteTjtP_ETkW80<{!99U4$hKh@RI5O7YIsilUtnV;M}VIu&gAU6 zCdW!7DJEu6(KL?x^mAu}qgGNfZL3K#i6tJ#fvrJeAcM8KrU8^(n2Ct7#*(!XaY~s@ z76q*lxglp#w{zA305GLI2Hz5aZyXVoluC)U#_sZ(3s8}@O?|(< zvBBl+tY;LQv`s3-f^@s?_}*zP3aADQn2f4`(1hvr_QJPr+-}M^n4{yI1|oyZiZ%pO zt0EcD+%6YG7i%5U*hxviK%``-+l@7ii{*6a)@iiU>0D5(^>OGBTLdI)s)E*9Q~^sF zqE=BT091qx8Q`i4DfWP9okeD6oKCoH8c-c$M9>PA3H#kDl@cZs)MDA>Qhj4fuC>$} zvr@IrD%39T6jf^l!IbKgr>h_SkN*_{Jo@+k!)Dg7lYZA3Yn*M+du9WroWAx(cXLzY zpa{dJw~k6GfT)O$Ip%S)Y%iXkK~C4Jo1Av1caLAaGkbd7`)1Z}*9Rx_^NXv+@x3?i zwjVvaC|VN;kS|q9Qr3b*i~xiJN(ic`L?ECjS_KS4sfv}!iKwV3ism8+=z=Mgh?rOv z1u6<4v0+j)psKXDrW(^Y)e05b$?X39hwIhV-LD;CEjO!+L%)#X)j zlAnKeadbQ-*NE)H8c0M!2)B)igk-F1=l|e8`S&NsM=mr{G8J5OtSV-dwC;@>81?kI3yx#7EU!IZeEuMQo z(-{8f$@Tra2Om8-n|Ob8v_z!fZ58ed0O9KF=`Pd5NB6h8G^A>2Zjw{Iloy?W|O0ZHOS9y#;Ktgiz8TFUon>F&-!LEF>V%1+^jE+n}iAP zb~_OY!F+bUQiVqk4$}45PTDk#3`mCB*4;Z@RF#slW$K5NhvDJf<4-<*esmCw)~Y3h zaI=n!KttKDkVsg$v#liA#OuTX*Qe9~NBZ)Woe3hcVh zSqnnv&(}vs3y?wpAp`(01WI)O{+-Lq&1^9*IfoGXF;5y!Ig#O}4VP!vt~Ir2Ey+2r z-V!1M3DUl&y5x+Az{VK^sIbqJ_?#g?-fga&pGr|+YY3cmHuy(xyjgR-e)j3}EnWPx z4?p^?|5|`DSYxL?Sle33RaKYAcMV}zstavsCV;d&I^1qMNwF5KlD+rdTI;NU!%{03 zXIx1YQBuu}NWe`K`jkNSX|fCh4b%)k#H>O9 z1VkbLPy|gZm52?2h!h|Ll4~i7PNLzUNMdYoOF&?Y{g_n60Hs=w=aX@e=Vuppj*b}f z%_dIgONssI!Q{jDKkB#r$?*cw1jngXt<_pL#vOxg=gZCIrE3iUdTXbyiLqzjf~4JU zZEYhpGkUaEb4)1_Q9GTdl#FwX_MP`W@*#BdH~-qhCYe zDY@DZR4QB3?{@8U%7%=eqADoV6f0mYDeba=5?R9r5Fup~oT5sOK#Y*tI$}})sNzD9 zT2nt7wm?{7tTkI}<*m@xfZFA&mPW#abjpVonr?m~tGuog!Ff zGHjedB2+C!h)j$lv+mYg>jF~)s3Eurl2Rh()b&WVabBu|RW?vkvCcZ@peC`@?RHRv zW(*Zd5#tT9CsibJO~^X1Yf4Hvrrl;EC26gyDn-YkuQ@4d*F|r=pH5M+)|yK(MuF^$ z5Q076CRL=Ca@$SFSSvA+faak?6zAJgYCD-)>xmhvP@8ks#a#SX9nTduVZ z+a3sjupgpv###da!!SZgDP=Y!BHlYdBBXA&LnLEZfC-VwfLBY#x-h0X-dr@3Mpc`p zL6jmwV3@6MOf7r+O0?E#6*gqqmr_AXirJJZ)sb~j$yy7@M5w5>01=Y4xNi~{Atmd0 zA0k3TL{y3p!F+KLb1t=1L}rGP`?0japys=GA1Kl=^xk`9m&zcyLo}fYt#j5HRdC+H zt>REcbgu@jRZ_o+?@kfsy5wLHXsuin}F{Ct`9hN2wkcg;49!Fygkxgl=c|<^qh~ylrvBt1bqQk}f zAN~HjQ`YZruplRM`*at_VOU?C-+A~l6V;S&gSUT*AX4@>WkO9LhQ zA?(MY4b5h~ULG7EV$+1sPE#KR6%bV5!?W|RJvep1LLmEID1h=My2VvOC4>s9>(w>{ zyF562aPQ^acJ=X-GjG5kTwJg3-8;H-ayM5cg2lnXdb^evt-{wgSBuGln3<4J4;Dv2 z^3g}1>~@>;^Rv5mAHMzW@x4KyaKoMPUH>g@~m)B+gwBB}z z*p(O>Kvn1LIL7lB0bn|vUazh~Ga36VGVFGJO!14i#j*mFQjK9|E44g5JA3uvgO}d; z+QXy6-}}QqTrQedA3XZ-lTX8Jwpp)pH*|eJTO17Aogx}$U}`3l-L~6LijCnqRxmCw zU0AG&$?`G{(3IWudve;q@0YXhh5Wo-#gCXZ#R{43-P!JJw0n(r2Bt&No zBfb0hqm!d0pbBDR+-iGch%!KuBvO!=RM?uP37c-~aY3Fz>txdGOJw#0fGASUM(e(b z3P4filaJp6pts-o;j1sdMnsMGD)RV)4<9|e(}X6d&qHckUsF0gJfU#`|yv-zP*Y1oYiM@P?|e$qA* zW30+}y}D8iCntxtnUEqfJ2$n~8kMmK1IC!zX%O)__TJmJZKcSkpS^#4=PoiYmj|WP zeRE0Q4;yd5{?hk+X2fHpcO>o{ZoBiinpjc-&yH(>ScTewp z^5pFC+wZ>mwbysM?&#i~ZgVqfXYYRS;hV2dyRi?psWltxPnOf`n;j^+V4goa_r@GH zesQ$8yj*Fm-~8sc-hJntvG3a8&d$$IPfy-`_niumV`es!nax=*uh+}vgn;Ms`Ln0b zvgj+Xz5ML6C#6rXy>@4eMWoCY2QkO<^Xm|rT7{9>GNO9R{aEi=qk>S?HvZ1N#h)QF z!?exh=UaFKA;sy*#PQR!^}%9(aL~N{qi5fI>k$(lEGE}C>w{VQ{Azpe-a#y7+HkH2 z%vfML!BJ1D?kl_u`AO{R?1q9!CG>ym599c#(Sw{$Rm@n4DEE0(wO?r1`i2S+Bxft z_XNa5+_X%lq=cxo)>{fUrqE24wB{-~-xlPll$?ThxhjB8=Zmo$HAt>S{n`y+|A7zjWOP8$z)wKoekr*+w2wx2W$y|QZ8g_+lEwd+(lz4V{RrB z)w(BN7>d>!rZYfpC$piCF~%?r&iG7_a%8gBFf*IrIcJevODS<2wdV1Ulx(1iRhnonyAX@qIs%I8n8PV7Qq~ zQQ_+1deY9_*T40~ul%Z*@O%{~i>Y%)f!UhV`;Uh0x?LPfE^!!KaJg1MC1&s1TH|)z zEe{Tm(vy!qmZ4|ooNMzai^cN2k3La*L~QT9^y=fspWL~BxLD4R{l#^+-BzcT$y#f) zh!Qg90ss{aq97mxDFe!$?;+R|1Gb-*xRngsM`_h9uo816F0P=as zc)uNO)7YkUt+zfPV*B!U(r(ShzWdw1`RcFzjamyam)sdQ*(WR`A`ufa3cr|Z@15&k zSaIu@ zDu@W80^DZ2sP4t}w_^h{0*c69|MO!@V|)>@gS5KYZMxy*hxgB~H(B*?8rG}6i}~K2 zgY)b4y_18S#>vFp?1q=_9bevT4;PD6>xZ9SzVh&>>&B+>{a8}m1#g)2le25KzVVhp zju%rTNO3f_`RKEY)8qNKzVWcC8H&kW$Akj-&DZXHa(3-S``ylvGMbkk&d)Dav(|;+ z+DQXyPmk@*cDL!v+}M7ocr)M()efMOx-Q~s6GRFR3J`oeVHQoiXZrkl%dT2@#xN^M%D07zLrNch{Ot8t?wy@qJ4fF6 zT7|7$t;WOC<;B%{K5wsYx}&4ncH7Sn7G)gzU2Lb8OsF;1QYu@ng`2jN$^;;qV$@og zS)@j+s90kbtwbcLf=Go@OI2S9Re68^qFL)=(wkL0KfieIxBiz(upM?MC$HX_&V_4C z*&5p}@3x1>!M9RMTLd-NoUCt%-D1hR)eRZ6*0b@o7DQqIGM16F?xiLGrJ!|+qG~3d zveuf55Re)HMG=)uK%OxV1BydHCBsCjA}9dJexfQ>6-7Y+1dzoN0h5Rjfn&DL6%hg< z<$~<2r#yo3q5vXBAtfOaw$>O!L}QGAxZA8BK6=Gi_j~{NcmJJV`WvskeqYM)?t8n_ zxqI{LuRecz;U7Ifg59oTYo$s~u?cOZH10ODgZVHFlC&BoEuonpAb@Q^`=PHj8^Lk3aZu{*70?cMCK7^n8s4LfZh4pwSq$))JMBCECZ+vsS90 z-Z~Ws(`hNfi~s^`EeKYsd$3AM8Zsan=W;4J56xt5Zo4j^j1h64MIk`s{nR)MrKD1r z8JTDEqrTtnHPk9)?03d_L`G#5wLYM6B}MNoC=eOqm{V*gQw6M0Axn`0ib$Ml5v`WF zlxkc+05&8AaxTcmBN_(r6EX-`f-^N&>svsqwHV_vTgBYA?QXM8{ZMlXlPMcZOj)Gl zXpCj=wbs2bxt+F>JzD~R6bD2NZ7V98YnF;*Z>?u*HI+0*>jA+M0+JEcQff{^jxoh( zy*JFRX-Z)!rD)E>F!p0JnWi`pvUN~JN=p0VtZ78!j1OcORS~h2h=^>M$)+q&1whCc z08|76kh8{=eCrWl9Qw(8F{GrWswe>h;@I`I46Y@ul?X(#GkzcbLqyKuI7Vk#mD0F_ zoY7F#k|S8l-ZxF#8s}pwQVRi*K?F>Wh<)2mh?y&aY)h$3T64~-H6~C%UGTE0Y6&n)b23Oq5D7M8w9MCf8b0RuCpbZjbcU8YwtXRAeU9e(ZyH zxu_vyy@`X&XLBWX&Y%{}8EOF{V@%ul&9HTiNjYH!au#aMB{2{%!7c5u&v}Cc0sy&W zHVjHCnhO|0=b8$-=gL!#4xA7W8zdD`Ym9NO#GzEIK!A0!SS*fC1Qe0_p|@1K?Jfo^q~LN^U|J@ zkBAUJ{dv&Rf9XL$d#t}o1%OgA8iRnE^K7#cbyMMN&UJoje5Ocaq)$~V6L^>^NX ze?L8w)RS%YpQ*K>AIG+7w(IqWpFW#U{Jel~d>+MEE2SnG-+uSwhxd<CsWm<@oUQ=H}|r{lk0rU)}7kb2o&gnat+b=g-o_ z8Dj)WirE?hw7zM!o3)$nZ+2uuAi!MGW_Lq7axN%HjPc2nvwL@s50@uTo}YQk)A@9< zn8z5as^pw=SspG$WE}ge>+P&5C5 z%D26GIoF)4VXhTEee$$vn%7@`<(Gfy8`tacM^8SXQeT@*W=(T*b8~&O8v70nA`lS` zU6(;sbnkl6TEKD{GX~>Bb8~s&nw9|O(>C^_AQ`o6D<5LG$X zQt{_o6XaS@@aJ4Xbp7_FhxaZnp3mn8i)NBjG-#B7fZEXHls!?&YS@l38Xy%RL1V%o z(OY+03#MY2Kl$+eQj1oZ9~_DZ5%ohR!{7Vfuif0-Oxr0TfAZm{uf6ta+^#6J*10nF z)*WuH&r8i8e0DYrL)Q&2zxC$T%@qiwR0!j0lfUxP^iBJdpuzt7YMY58$Rb1r0BWxD z+5Gv{GjGD-$$e0mI94n*3K}e05ui_9YyEcDS#JTNVhG-Ln{5bTj46b}93xpnF&3ym zrWPT?)*2ukHp9?$lj+<$FRG$-I-Mf9lFF{G4-QUjV=vCnfDWc15J3@WOp|jO#<-j> zk>K!f`R@B4zVXJRuIn7jII8zniWHGC_U&ZKOx<=@wYILEPFoOY7mMHj{r>JKKu0S zwb$RwX;|NdjCy4$R$^V#Cy;GOqAc6MTI9b?*U`soZs;i_P)jeA4jy@1Na0T>|RG`St2*{owA=Q0wXOLDy$z4U!r9(NEY}TWVxOsg_jn zXt7wYZ`M~AzMafG&hAb(o5Y@_GDu=D^Tlk4yK&sy+-yyl93RfHht``S-1xfdM-(y+ z5nvn>W(AY1wJtQOP-`{T*P4t$tT6UFKn1XD92#U%<18sM;xOz=Rm+B*-&~zfkMAAc zeW)lo#$L06%@4JtbutF0%LW~ z_x&Jc4DCb!Qm)oGKq)E4ahGFlnYLPXcL#(9xwj3a9SAgh|j zX%aG~@jee-KMc-=$#e;*AXG~#!yo{q6z3cvf?_Qhs*D+?^J!ozV=h=iAceelD0H8SzX>6JnttDfmN-eplGMkus0@}pFM8^A^BfB8O z06F!$jmvZEo1w-$_9R8w0z$vJ46}vzzKqdWCUQ(gi^ekSiI!R-8wO(;NeW^xtD)~w zeD>}Sf9bn_eMFoE3f}BG2`z>uh|ZZ!E%oO7TtPvh39Y5%r|ovNA#1eeVd!%jCT&=c z@!`F@6nBe*`Or%@_%>K#vsvF9A1|!)xzu*Cxa_s>$5)mO%XAZqF<==%*gHzOMktm& zh$4T1iwX#`B|rcrQXojB1ZQe3nw6Ld2n2`(fB{fyF?*qeBC}y@0RUM6ok%633e`EM zY6O|Bb%{T7lYL2BKtyXj(5QfJ+iNZABK$K;x(?Y^+r>#tzgiEM)tGi6oGS=G!8B_#(E^JrPf-Nvea6}G>n6>?2I=A zIYnnJVgt3tT=O=TG%%7V%;v4ai*yZqk)x(xJpOc8a?d}!h~&o4v$^$!xL9uw9&cw6 zNJPw^M`6Mjn&Q1uNfDF~1Qk%}^BnLO{hPPyt^H4wkQC_);PZt-`9(hX3##LD=o7w_ z9HK8AxhVS;kf_QF4h3#g!jW!uuwVMKKhu2nmG9CQk|_PL?JM?wkw^ZQ4#fU3i1^Qf zV}E{T{R=7SiTM`M-uu~^i5Uq#?`Oq7cC0TT_#ZoI|JXVF7rY+4ow9e^|BtsfiIp`? z(}UjW`@VmQ=?wRrJ7!j9c4dvOuI_5L-E!O5&<(;ew%8!pc!7i^kl0`Z5?-)CNMHnF zfk6l?8-W2!40hWF)0W#{+-|qslWWMTtekG%n|bd&_Y84j_=j(JUlwtzy32GMw-X8qAPK)G%s*^9EVsL!K*U%3VZR%u z<*Xj3yc^S(e%DX_mw)_U{jq=c55M`NKk+~R=l{tc`D6b^GCF_w;4l4W|K6jo{GPA= z)E@yY&py38S}k)bIp?-*Zf_?fUj@ihy#HW<%KI@sI9t4Uv0m@SM-NUaFYkZw;*I;q zFRwO7$K7tTYo%Piyj-o8s%4zwgF9WC;$q(B>mmeiy?*lE2hUE9k5G+>rW~~-L|V)m z6#CY?&$`AhX7$a@P*v$mU;g~X<<-+?H)FwXzIWjny=Pz5_s+O!>&H(nrE>Fm)sOk< zi_KR)fB(~q8#C;@#c_K2-aB9TqksI_d*8VC;@t=T^uMy%#haVkx8FSZga6jQ|L8M! z`pxk8=}RYI01xk-KEJpMO#7rCJ$Z5O&hm1*omT=DhcU*>^}VyBCm+0c^K+jaC#}1h zNv>~q*Ejv?$y`(1Y_>%F{P|Ve1_eG^)=!>Z-8t>9Z}!75E#}>e%gq~Yn~fjdJJ}BD zXjNalNN0DBw3NP|9NMDAPd>dkzk9k|EQUVr)391Jsu6vfHVs0f}?2AT?KU5&E~V^DRQX0me|!*g@F69FDZi-7T+vZ1ei;4fzx)BrYj{0 z`*G~2e(ziWRCdnLFqs6)fLt6oOeq)0A_9hmyg@;!q!x6pqyhv`6igY}$kc#=$;{*s zISH68TN=h#RpK0Gg;KI2kODCPNCp6M2AVY;bhw)O+B+=?P;$;y2+qm&>BswFz1eLy z``veb>Hq%XSHAjd-~NC}E-!YW4H81i$vfA!?Jy0@EaGmrx0P=Un8cc@i!yn3sU#HA zlCYE^#hlWtTPktMvE-;F^*VwXlvH&y0&crDt4WF9`uclc`SKfen=~l^NvLhac0t2- zk7j^ck^zI70@$?MI$s$Y7(q#~hqXDU+m8e!q znm|FkLlZ&;WppmgW~m?d+kL1SW>!M)LXL%<(}Kkmtw>#!QVgt~&8U=V9FVD+Em|NJ z%G1>EcIZXT)Qk_}i=1*PAXImAPuh>El+4VBc;I9Z#FrHJ`yu(dowr2`AgW<0Y20n% zH06{GGH5EL^xJKFe8Pa5)8U`qN-4!e*f+J)fTn)Gm* ziE=4sR=1037*&&%NI(FPbHQ9BRO}oB0CCC5n2_8w>=~_gl1YHkg6UFYK$?|wG}{CGzAkDE-4aNLDN!1 zm|cY>rsBe|-?OKj5!1wu=c}W!?-9_~fdEZ4 zk3(U>1b`^cAyFxoa~6`Q0~(f+hXD|>_zDY}qVrBm0aYi5Bm3OGj$SWx#n z=w>rT`$J!Q^kN_PyS@-Cj*i=|1|rR1McM!6a+Fs`B%%S}$)}eG*8F>?_8$P$a?w@e zm&@7t(Q-Qt^I84L)2EB0Zu?<#GhZB!<9PG(=FZ*Y z)6a%aY7N?0rfMUWf$7nz~M`Zu;^Go-@ zm!ieACm|b7KAo3@7@5HIZaqoibH=CzV zKJ``bM6ZAD?G(px?CY*QL`bnX0xB_rSsEr{nJ-VqVOZZ@+`E5wIiIH#os*N}<-Q+< zq-$DV$uv#-VPHhAs`K+RhWFn5{Flew7JxRp+u-WW=B5<5-E8_{0stmXXFVT?`|$%nrYMdem%@qP;$AtxvYYB-i6S{F^&W$M~j$MhAGCL8RlJ6g_fM; zlr0xVNJHN=%{YultJUKVKSbvq-Z}g3H@~A$=JQ#<>$@gY&3qVc6~GDuz{{%(=lt!> zEfck~HfR0dy?23ZHVdCVdA2%P5?AZ(RZ05B+i$)9!3Uu5?zg_#Esy@*-~NR=_s))1 zM^8R}e0F}a+YB-8>!u5J^M%j3_rLqzn{U3^@B6Cq$ETn_D5wsx6jd`o@^!`RH`h0waksmbrb#7!^qp^QZ?39&XJ*Wz zCkpK(`(iDl%z)FgiiVGgi#L1AXs%tZ40})T`hMTLn<27lL3W{O zoC~39fB~{9763@atmKl^*Fq?0MuGs4qq1XFvotbMRx?$CtV|YjKaQX|PJ0AoPy{5$ z#@x<27wR}hVPbZ|0$|R$VL!P5f!X=G385e&s1G#|l$feIXqv2Kab7~>5P{i1#d#tI z(4vOK2vk)PV}5n(G5|6Ftb8S*0@HDdQ&tfPbwDFHR3|&}zUjKoaR6drW@NKeN+GbA zVhA-M84(qYW3K8jTP|{emTZ0V>HRm}j)fKBXgNbdHJJJV7y+4us=9XGrCgkI>|B~s z2;wCGXrB6hKkWCth#&jiJMVscx(eHg6Z=Ey-~9NrYFaf~td5T7_45~(>yLhQd2%kk zAz=xP2rEEQ1w<%Dgoc22NUrkc-cEjs1wNJRMA zv&(zutG*vDZ+2BB!Asj#sFbvTrdYBXx!?|77|;R$aY_oA31)4hnul0KMAfwDIQBpu z4CeDTRDlHdyB-m?+r0=P*ls(tU5kj~y%Q-p4gJ7Gp{@{+kX1_@hoVK*kRX=A!kRJX z1jzd_c@|_5=j#y2H%~u!w`$rqzWO__oyUT0m{4mM^TQpv@NLX0T{FD^87*xYW@IF%S3*))!X*mm7^7k%aXK9*G2K_Nd) z({>lVbC)+)v-xaubK@lp`+Yz3%7cM33_Y)H` zBajc?Apw{ff{2&_BNGyU76oDy4=iu z-8PPhh@~hqj#CmwD~gAVUGEMht|?{boS79>??lZAU>sA7la(yukU1A)1QAv>UpXz- z4^!I&RU-mGWMm}DIg4{3VR7f~H~zQ(p3-#uxgV*I&z7g>#twj82tJ6Z5|JTT$p|nE zeH_MavGPG!ya<<4m>n^qDzf;xzWn%u_UwTZ*7B+#@i!;B0L(z-RfnpoGV_6;W&Xip z)mLS+R8)x|rwj-wO+u7S2}#5Ql4?eT-DU(~Cd^rH+}&JluU?)VueSSmwcd7cJTDo~@odUtiyD z=dCxxrVhnGvz?tS?%rASyZHRs$D7Sqb+x7<&adY6Y8Hy-tJ~4D3Q@}W-udciF@JV> zJN5h5?k?Vca$Smg1{*ea&z9@;mZ$aI&wure-~H1egjK_*N6p{*^M7Xf=yS8$Kfky! zFalgOJdN2qj#IqdZqHBWyWM04x0|6Kr~CKr1d$Iv{HO_db#q&H%d4yHlqb#L1cPu& zSp*kdb+g_X(5&%Hgk+oTIQC-`WIk)UE(}v7c5Um5W{r8d>If;Pm~yJT*HXH!Ee0$k z!cGK?oQU_q41EwrMg~L-!B1mEFJqsMkGgSl(@$};AA(TuWU7EDA|iY!zbd6{cH=Ze zL^aU;X2;CLf{ae&K=hIs5P&KiG7}HW9l^NYw){aU6*Vn4R|oKr9Lh1Gx z|MyEsfNT(_+Yl>vqjyf86oF5<*FLF7~t zC=zPPQ!z^ihXer=jeYN{I$I$_B9p3~wX?tf_3!HK$5_yE{OZ?!C)eS_?|f^0`MjRZ z(Eyo**o-u%Vg#f)=Q1Ye1VcbW0MuN>xsoT#W}rF8l2x1_3o#*~^P!|fMC3g)@2;;x z+oF{zjzXvgahw1Ffe$UBY?if5L!V-ghU^0e&%#zr5l}M#I7CI6hQX1Tj;fiQ*KB4* zQ=uSL*H%@nAP1QZGNNfVU_?Gd$P4FOoG<|}k+3f*l{kjlBU;HBN+xE|Y^qvHn#P=S z$ywEW2)^>&e1$9}MHUg~4b+L`qOT-{pezo|h)BdCF%y|88s?J0j76OH#7s#Nz9aV=^@&AtrW=NUA_0OwQMJRd>$0gE{nYDL~O&3Yd}? zAwfn1Bp?8Dp2zLJssos*0ssLN1STSJWW^9!yg2U&1rZNok^^yWIjh2f{>bAXPRI~Y zh|u{e)HS;b0L;pvP#v`#P-GD&%q&9U9ZRSxat?q*IHf7|69NHY$*RQwp#WM|CM*Sw zFr{R`O%-CCw%b1E45|{UstQgR$un6>DNcg{p@FL!X39B%0W+0Szz$OPQGBhSDJCnW zs7*1la233&?)zQSG$L*s_d-sI#_cxeQN$YnGZ!tw5~mRlzJ@~#kmgqzE&8g$frX(c zi3oe=-QiGi$Zcmc1yeO5oQ8dWb6rZ#r5LKFtXfjZW+uX*Ky`DVx)IHhXD=xwBm$!C z^~<`Q*Rxp_LQYvtSww;t=e&3#02C24vrtucTKTo_eEf^=zI<`hAGg)nB4p>(ShJ1e zh**rBy{ftY!9gT(&1~_r|I>fhRB}KkM3|X=;~=7%efF)_=52e}&F`I^JMX)CcJb`l ztm|S*ch1jGPETK6UzBX(q$G1eYH@Abf_LL?r#V5vR}m|}LE$2VPoF;nFx65@{{G~g z52_~=K}8}csAO5lc|qUJcDvnfx0SZVl93S!;y5vZcm5!#(chL(1~C@(-#e=P1N1;4 z5=28du#1w1r`LNI93vr-b8>Zg)wFF0K|w)n+z&oDc4DeIWdrb`8pkoliG`0>$4AT6 z$?U0h#XuGg10H_tDx-g^C!9klMmbr2#b*^G<~ z#D`E<>)l#o&RJ*2M-LvH&*!tdXZI#8Xy#dpl{Dp0Rdv->ZGCinbm!i^SvxP5*#}k2 zDH0+vrZEOzF^jn1o7xe5`&-{QS*>=PEsN`BU0sLyaxrZCVHoPBEmlB5i)t=tplAo1 zJqvnQP1A6+SO`i?alhSnv#yk>s+*Y7uJ4@}FkG~)Dy-L=P`MYMytw%EljA%0s^FPr zzrQ&;I&my0GVf-q#cZ{jRo)?D-BhL-RlBAkSFym!$#EU(P*o`xEvlt7Z5zBS7fUp} zyuI!B!@Ox0tNF)Io;^4_mf)MFef;>lNb=U}uWiQtG(-guAtcnS3b>rl_TyNEDy1AM zS5i>~P$fhlj$ogo;{9)bU4iPE&!d`U=iCsdu4=b^|J5&l;rjaa;lq1m zS;!vVe=x>83_B+Nbpimt-%k$Hln;*69~cBUfRo@%F;2ZIg&@VCX=ZU6QiM=B&7`Qo z`J8gfQ_?IVh!*Oa5%#;AoHIINpfQbgRWSnsdUCD`hT^>R`z@F)mMZ`_J-cHFRow!j ztDF742hFqjtnc?#U6+!(u6zFclk>axzy8g4=JPhiVx~FgP;n`FK40u^Z$yNIpFVkk zl;`v1Zrn|~zFRFAoNwx3Kb+jT<0=oOblp7W6o>wJb=r3GVcLViFs7!RU0q&Kf!f#E z0Lv8W=Aa_GzS*>upZW>dz_@Cw?d@h5#xzaL5`5#lfa=A?OYg&C(Rm-X>-F1T{Ni%4 z`o+KZOI_E55aQT(-AYS3J3AStoYMq=T8a~Yc6R5Z_dk5_`fHaL>yy)y=g&UfZ1?lf z-0b?=S7REgsv)DZ^YiQLt4FWD{_cD49j(rekCvO;+p(YKvu3l~JbLu{yYGKg*Z%bQ zco>IqjQjn5zwi6s&hXnm`g_Ni{}HAPQ$9PXuWq(htZqWTOJkhwpDq*dlTU6QoG;1* zFD|cURZR?JFvaP1y*0$T3O-bMnqn&Ad{Xs}Uq1b?o*g&AUtHcav*ppr@ve`nc{3(p z;vA=@s7o zN>+BxG+Qx5G)n}hGDzDA)UcOwv_4W^Gfoj%uO;yzuAe+UhA9Bo0P(Px?)mQHZ~UFV@iRQTJ6kS3_;kH!{g>W4d;9+B&`$~A&Z_(PVhuoJ2FDPmcyW1s zd$T<~J>HHb@7K4F-w|wv&K%{bXiSN>y-brDUDP z)OJm%>ixc7be;2l90oJYDGEt0%AO8*%GB>3|LWh~ynMO7zWVY{{DGUN-}>-7-#tBE zA_rCNx^O&ice{9Uv-GgXAxgjmG{n(ftI=s<8J7>T5~Cy7RyDqSai!pNjmg>H?M2)n{7V~ z!)(^>`+e7TV=TAZu_R*`Hv4JTg~k!G+l}RTz9^~`LhV;jdb z3_Tcx$^&RhspNEWyt-KT_s;LE*PEuPV@$i<=qk(^Vl1gdM_RRhyP0N9?L0nvaXn3O zzFdq$y4milKyga_IQIK=v}%!M*bm1i3vuGewOzPgZ>KR=L45GOYOby}ZR584Y3SoH z#ik0TxY_JeDx2LDr_{|VGjI%tKU^Z}=IwgZSHZ8>``N5LETQZ5X1|ZS-4uePlvI_( ziE~8kJf%{IP+WLx;kEd@XJ4c_U7mJ{V0|Hxj*}--u&86 zvS30%7rycHf8+Vz{hL4hQ-26SnTd#gqeRTitdy8joT506Q*utePYH~}#KN0hZ)%6v z%}Sb*sSy$iG7B0?RRtdmNde6m@l}4@IE+qw-S}yURUMpjb>)UBPW@EX!7L-d6sPOU z>*c%w#GJD@>bE_RJ2^fQAs@IH9Bu;Qt6|Jl9onwBytt`@kNtIba(8v-gnaXbuYGNH zbn@5!lkUEBapICUk z9qYQ<_4(1+{M`?pCB>|mOS!z+3DFqK$IsTGX-|%3mGE{uI;QKJU7E&F`=dp>-;OB_ zQ@=YtIs5J>8!#?K$7J2SIbF@NLYQ^pn{M7DsEouc&nu~F`uflQ#pmDorQ_f6Pi=O) zX&T)4!cg1LV49wQ%q5 z>cz$NZr7ilomN#SMTwCJLS37dem^;p#iGf@2*EqIzU`4TPpR_0r~&YlBAYtrr3yqm z#Zpy)h{h?Jme7RTO)qkg@mkJ>#i=P0GO;infF~_^d-LM#{Jdnlx!uMwiHHJvkz7(P zy4~#N^O_mbl*Cca#d*)prD>>q4WIP}NMLjnM@oC=X0yk%;J08EU41_}oO zLAJvop%k^E!eoemK&V#AK^_hOgv88Q)w9H$ESFreFlk0FWCW&>3YvkbDJr8HupLOs zGAgi|6H=4P)w9i~A9bBSxpNjgpFMo@fC`DD71&r9CAQgp_lA6XT<}~j2dyP}oR8yL~ zb0iGFxuiHv!*0Xu_M5FjAtGTeR>(>4!4$grl9`AP%#vfI7$?wTYAH>G0)R-UX3l$d zUaeSGU?9YUU+@5iBNGCak^x@5$V@q=QZkq+C=j!FK+_yUXnd#;k-c+1AUj{x!fXeJ z0U@!77ZN#~wNy(^spLe$gs)72d;mSQ0MT%J(=3jLVPNOj38891WMuZvdnPI+s~Q+d zRe>pq5CZW5Rz~rT2x6QJfPhQMV9G=y%q%QC^@C{w!;(wP84;L$(Tqk0=one#a4bh9 zASfvT0D13xl~N?4Aim_3ODe^R709WSEX-rfW8VkIO;a1N_f%BXh`g}4VLzlaF%zMx zqG_InXkZMGOc4qqh^s^0IFXz(6IsbD4k7!hIjp5jqyWM~!i=!Jy=4~kK~qXOgC6R= z2m#nRA1W;w37r!bA?Jw*38258umouyb!QqVPr!}^-xG^``ts%5pLyeEee-?Y_nq_m7Z=Y75ddANo%2J# zUoDPeicg<>jAp7S=K==ILZIL{l@#OD)NM}jpg<|Py#3n4qKW{7m;eKiK|X}ywRK&T zUS8hzX%u21-VQ?$(AioDw6Zm;lY!Eer4a z-M7B=?tXJshwAwFbi3aR^VQ|$l;iQqL+_>QS_a9Q70ikPkq~B3QxfNWsHbVHn+^z6 z^~J>tVW_%xeSMR25*NB|24*a12B8X7<#+qx@@AV9o75> zbdLAK001OhOhGM8Lpz(N6sxMrYB{F$dVP6wv$?%705DBzC7X9VmFR*mxomg+m%i}D zIF9eU_tES3PZZ>}v$OX;di>z*^mw%*!rgALLySf-AS_nu5Rw^YRVxK3hTm zDk%wz5Ax#qi`jD4tnU5dFZ}IhHZy&tYhZMBaP53`bAA2t>Ly!yaC%BU%#ZI)!}#9& z-v*@MofCG#-bu>8-fAA|Ce)#-s!)Yc1z-8Yld7(-uCA+)Rwrk(`D)nTkgGwdYwKv) zRpJgrB0zy+sYs|wDM(be4FRSM$YMFUFi)v>>_8O|OD-T%a!M)Y*f;GmrBYROIf#{V znbL&FpxJrn$fJVyqN-p}iiyyE-=Ez*Ip~Hu5Y@!OzH0ZyW;CO4i_(83`0L(&bIyV+G`I=O3l1mE*CE^ zUIcN(m{W2-WYy#2)yE$_xwyRPL^NmTT-`LzNgs!CKa`}|CIkR0qw4wj>Dcd1Pw$9? zhp#>O#@D}oe*gZl&DwgH##tk~ew@vZ8PZVT{O*~sOQkqR1|$qQYrpGBP!*BDg?fsqseGI!647FW z<{am2Rb9Cdh{=mfX#!PWg`6`H9D12l5z)L0b$G?%P1EQcvjB(YgJ1c3(|)6&;#_XG z>$JIvW87U`tY17mdGJ~(ImeiD8ppn5MKoqi3C1B39pVI73#4gK%dsDGE)qNw5CS@tu3;_utr#w%gtc`_~`6h6+fZaymc%%<-cidi>6>eekVcEg9~-{?>l|qPHq=8KS+s-Y~=QYLUjos9r3o0gDq# zrC2V*kd{Y_MOSZj`+mROZF^yCyLO7{dOfiBc^a!GAo&+Jd({#gUatp3*UhS%o88Ax zKG|<}!&Fu$M@J_oF8Fa6Ts@o3X8o8{!8sSIaJ}9yx@x!IImgpf+9s^mH+d?HdDS){ zO|hzYy&GqX`R#Tjf%R>FH1Brfxas5Rs@v@PVY?fq7z=E+Jp)WB-MO;fT}qs(>QrA%&ruzs%na< z3a+kv-;d11M6+4r9RtBQ<>jI#g#EspoGxx|hbH*o$T?S6p=tdXb51Hw*6T4ih%r@; z*H(P(? z?oihyXETd2f8POsucC5^MF?!z4@`{AoAn+LG*6+fn7OG#DOsEVVxA^INJ-Uz5CM#k zhy@9Q4^>^)brp*u;Qzzfd&O$oX7^pIT;*<0+3nqL`P!6k=9}V)3+_&wYD1hvk%C0v z01iM(M1l|q4iHHMQ49x&gNOq}5{eQ9V+fA0Ek`&e#_}*u9LM8KY>z$Pl&{X)c6s(w z?)$#VT8o3{9b?CdWAkW9TiS-Rf`cWM|CuXYRg5pSoGxl)%7Mu$LMy4vCI>DH>M28LmOfsWY;av(Kp}!r~l+1`8WQp zPyf$<<@2BZv9oXbJs}0x@WJi&2k+hK z$zr`4rl~F$O(}AIvIL;BlfG|4-#RquA}b(*rj#E)dA{g9lRm!Qz5MWWyB*C;)Y`^( zt=rAIUN&bZ9eYpgPL|!_FonQ#mhI-bC|zExW8^aCz6*!_7*1arw^wkuI(_)+5c$co z+x?WI_e|QvFweDV{cb8gxSZ?x$?A5y1CN<;`853;f7m`^%sG@gIEt z-mjkBe=sb20B;8C(~I+$-+1uq>&S zz@dvnRdLS0`PrYox!WKkA=c@@&2SiXzu%wVzZWRnY_@0`+X&1x)tu(G4WaE7tmKSn z2q>jS-wEh^n5u~aF)6bf592VbL)$>LG0ngPW}kZb>=)mDIzIo($=Su1zVOaBeE0W! z?A3cuH~X_yH&-)Y@7*-dQghBFrzE8UqLEWj%@xeRu^LQ=Ju^wIIpr9ARfy4ncLJ)4 zN9vI$hs=nIKxQg>yiE`jS2Hasy2i}FB$skr=cu)MADEEIkt31nLNHYffsdeGk&=>{ z#Mm66g=rQ*tGTjchg7o~y#P`-WW<*mk^^Qv}OctRkmeB)Rn=5$ z$%t6;>|6u_Q-GtjOr+Kf$CC@9nVPCdMLcF)eDI#x`52km)THK8lpPbHR8g&FmU5~& zGqdv^kr;{D8zK_{q8U!x%{WhJR;Mu?4vt9Grf~}1A6XP&qH4}L7Xu?85Wta;r$of; z5h15+wW{efj;0ctHpG^FFcT)uqE=L@90gWHR;x-;Vhk~mb0UHWYUVuUtXhh9$mCSb z2lmV%xKdL|iI|vpnnx+sOhrLOV-pccRl2q-DKWjkSs18_I&xL@1vd{2RUM-vu2qi{ zJu?+B$KaZlT_AQ$emopr5HUH>wE2 z3%`kLd~lAPw__Uh_!O$D7&8-@luCrEa@g-38URDpQpLw;DNC(Lpf!~_dlza+BGtu! zhB;>`h1qj#Obtw>ih(k+qM|AQ9RcN1Dw35dCk>+ypZ%40zv08@zwqVT#WKEf-oJG- zvUhc!?yjC583T6wUi(cCV($CJPy8SMt0^FnDyZ5&RaK-E{opIFX0$GZB+@tS)w5@5 z9>4g7FAPI3QqNX>WPf{imr8LykeMUuV%+bxWu6zq&=9=$-up2`X2-wQf@BWCKfS$< zZScW4&%ajW*&z}0?&dbO-IOLq3b7%?Zn=Ez{Pf+Y@702cj0oeHiMi<`%oP}bjF46B z{|C`0iH3h_%k#HA00<$7iBvu8_QV8;rPSA7f9>>S)rBCUqN-}1u~hkWtQKsWcABRn ze5sb?eDiDIpnE6l#bSB8xjp*WOzP$RhtHlq0fdK-9$i0sdf1N~y=V9AYIAXZ!p;Zh zr6g{hr)XeAWTg`Da=B=lrU{L6;rwhd=UPRosvri2T%?+U;j-_6-COUz8Dk#;ms<0j z!E`)~fE1d>%ovG?a-9)?nZ_}Jnwo;~?bVZRwPeJUismE&eb*7;&F!t`DT}(`39RiR zm~FRrAA0R0o4XqZBc^?xaw=K`5!D1hojMMVkeG10-L%8NM6qk4<64b~hoNJB@tzV9 z71@tdEh3`J)#B;X=KwH7ymxu}%4@IXRHtdzw2PdRNIU9HRy-cTVMW)Z~VQpvoF2-WV^q++K!8p{_1*r zc6!>j4FJybj0jZ}k%A|w71YSPG^U}CyRno~`(dx&eo1$91l~@ zqT*dRZs`10569%(yx$(JGv&9cTv8sV(Ga7LQpz;VO$?rifYw7_N~x;gnb@IY0*k(D zn@9+;X%?%+H11;)iIDg>*E5by5v^v`Knwur#~jvcd#wL>$HQ@>skVB-Qgs#%=pT#^q_O&6<$V~?iJa}(N} z=KBvGsmk-~tHbVa_54{et64-X*V@GR{OZ<+Fs3ortcD2g>9gm-H9m0P_eJF9`et{S z2&fy{!+xB`ah&u1u**e!j3&BXE~jx40?@32ZPV-zcf0*zwO)YY$;mzT*f)#idiB=Z zUp~LM?>vsX{rY@Oq7Na| zlDocfu`y-#eAsSEKHOaIS0}5RtLFw-fBjzAZ?E_h-}s$*&i~>{siYE|MekRuVY|=6 zqOWsm`|#f5n_&nqJ-Vn_rc@dqhN0Q+3lVi~8@h%R?rxrs^PyDX(4avVqj6;CYMPHd zRzgvMltvcxKrALer`g(1J)};2e98%v1$Hl*x!0Ou=li9H7>rAG%=$ zq+J_4d1M!3tfIv1fYl(xP^JWoWB{NtPUPJEE| zH1R&f7bZ{x0Bn~_)9ONdRD7tZkBy5BA}AOmi-B{dQffkvfPmxvfCz2Z31C34R!T}z zm6?g~s3kQKW)BEN$7>Eqm3%lL69Svo*mlQXP(&1~^L``%1W;n<7{pAmma&cnNxhHb zoX})Wg#Z{sm5eSJn3yu4h}2rl3aZtTfCF;y%*?3h0Ktr0?Bs4+gOAL|`%GvXMGFAA zln{O6!`i4D0igv(>{_K79ZFBjvU`IXkX>Ts*k< z`Wqj4{N%>rbp7Vf{{0{RTU%J)N~h?DE?)0PnP;SUaXw6?c5S@7+wG?L>eD~|KItbH zVctI3K7VVuK2Iqx&+qHuMowP-#y{|Vi}mu^SKk?To5RgBQB?GQ|A+p{Klp+F=_7ye zk3M_v$xr=nf9>mk_wUng{mzg4_22&&{>o4N#eetWqn~QHrb5rIHUR30*UP2zZa+;3 z%ETfTo7naJT~k(%*GzN1yjbTn4MVR*6}5~0=5`xB)mjO`0LL*kO`NCNH9So@ zc-ORHo^s!X{eGXb6w#c@l#8lF0?`7s3M3TUSLeVS5{YG>G{f3*U7szVT;1iO%Rb!gCLiOy zduL+QcyT!ah>L9nzuQlz%QyfQLFvA2u883Ny|aEfTwU*?r~P&->d^VV@7m7QB6r)l z>Dr-<f-uz0HjpZv(+qye$mFEkNfQ|l{%*yV|Z|}20-saRU^l*JUBJr zlT{aEGc25^@ZhzVElumy&^EpuA~US|F3nj@rZLC(;=t#lH-Ub+AmWn6JMO#o{Cqvl zIXJgJ%!qulUXF9>+IW3?cX4l3b6u`_1L_)ov)QL{u0;fGXdCCkm~-R(YSj}_N|l|9 z(IHVPWxZbP4ilkCwQdM8gqrheIr!M9=%WXx-f@iHF|l)pIn85k+JK0MLkhvyT8^Yw z=XjnoJ5*Kn-1Qw8G|>UTc0Ub$gNXb69D*~$Cb->xa>NFj6Etm8OBJ=7+e3)F-_5)2 zp$SwJ#wlOkTOIG)*SCA$#*>rfEdH1N(x24Q^}5yoj-Pkh)}9I zCNnU@&^QFmrG%y-W~()&Z?>woJXsy4L_{$lfiY7}DR?Z^9zD8OQUc=B)72r_y^FJyYOQmOttxrX*W1Yv zdQS*SD2M$-o;P>nvhykD^|B+x!#MRrKacbE=CEFLW6FKo&bf*h`M@sj4|5ebTQ84X zth>9->9U(sedm`yC)+2FKKS}!cevf`9bwLCShNPXc=XW+uYLG-H=m!awB)O+n^#|X z5S+Waz4IOc=xp8Z$8xq_Ufpii%dQD62R~O^uTOk*UE7R@+Oz@DuAbjiwe9BW?DV8m zHRj;?Zns}AT19Y-ATk}MsusMjxe`JVS}Xz>m`Kg3=^HcvFy~zr@!q95hd?EjG0kbr z-4L0>em`vwV#q=qJYdsx-D)|oqf)Y#T5|O zocC=%c;Bo~)**KN`u^pk*A{2zC#Mg<6wqp^q3wpnLd|?=0R;@xv||@aDeZFEEzgwm=QUrQUL+Pz`!>V0jkLHFmP<(st6J=dLYnZs)EeHM^&n2&Z!(VhqcyPs&8CL z=>?gd9U+T|L6uz9#CvCeo}FVlt`Ptc5P4=K6j4N0HAJdn$7m;8?mAaW^)3KbL@+@! zb)=X?Wb5kqW=%(?0DIVJR~LdDl>I=)H=iajH2Xu>z=oV`ofuRHYIhfoW1p&WQ-g5dwtRn4uX~ z5CQ|uQYEEIo&j048X%~sRL@k+9J_fQwW{+F+Rjo!#{i&5H?|sr&Ep6Fs?~?cF8bhe zPTog$j-B^yhr~n(W>OVQkr|0jW zWX!IniG45xt(A;QP0S4JMQW`%=S0YD+nY(sh3p05s^qzr0xz1e{&>tVm2tmSUC62Isw2H3ULKCU!`UyRMazT<}a3VoQYj;u%L~lwt(R&a-Dg2daUY7!{7tdjgeG zl2l8%s45c0CV~p1sYsPVG>*i1s8v4j=mK)drGP>k`1Io5 z-ObJ7^tA7meZNShM(?KWwi$+b+^gwoeTGOS&#TkZDa&TJNz;sEhGwA00yH9g{N&mp zqv6rP{=&qr=sfRs+ttZwN_R|bh+W$uyX9&%-EDW{Uf|gDGm%nsZo}sx>@^J_8YhpAjrrtSF6GV~P_AMwefmLYQ_WI_z z2sBNLfb%?;REkzc7d^+udlw!*c?JL%7pIr^A02b3rAp2UCad*gPBR$}%f&ROx8HjA z)epR~-QI>6wbXXeZ?B(RKKQ_4eNl9&0U9bN%O6skzoXbiH%l`{;f6Ey{V{wB7#hRsj$xr4)j1 zVqkKsa+uP*7?!4n0BRaz2rk6v9JySp)dB=&>M5X8L}t&e_k>hTsY+J8d47{} z+U$1Mw>NX1H=Etl=hs))H(l2~dHnvn??1i0+imXlSJyXpyYcze)sx51rfJ^o$6TtE zI!$9KC8ZLgzj}712)o^svrai}w+B$W-EQx;yJydDw%hGI7c*E4Jvq*$JbiXOr&Owy zs?(hJQ+o3JW;dn%ZrW_8o4f6kXICjp(|X6@o%fzSe)9DB^V_dJc`CK;c89m#ey^ml zidHqxK}}B2&Oo>ux^dpV{l%}GKRDlS4j+Ew^?MH<{_-#VN*lx3y$jJQrL=v|#7z@R zt$o{n=}T`mO`p>A^!c+imhb%T?{dVCpWil-f^$vRA&{||6{$I;lxMxTd_ZWb>FViK z(=~0oXu4)-x_&jRPgcWXSS%O6qvG%So2F^2cQdb>VbK6$!rqrbYDcH{iu z{%X;8huuhEP1h=sREd#Q3L=yOLpM~lY1~Hd6;MSEyG?A{{oybSU8y#wx#VP`9GzA% z$*c3Tmfdd3SSWe)pFWz2+ezc7^fz7{m?ixKy}W8iB=?HCd)M;mRbuM ztLhPCYzhdVM-dXz>hx^9+tw<1KGd3h^vixBp$j17TdBo|;Ml1aBNsf1F_DS^s=3Gn zsAdQ#T0-oYn0z$Q=pzya=M0e9iHKFHng9ri3{gaDnnKfZ6I6+PjNX~bG$rr7ngr*O zD5u#B%;XrTF*7xBJ^%o|FuyV}F~6{#5D}6KE|BBnE;h4c&nk7??^O+ui&RHUj7)^= zLga3-==(Od%bcrPfm%(EYp*C(W7~qNY9jK%vs6WdZm}3vr@O1iu3d_z5CSnU1yf_D z=vwsTh}pNus8Z1dK+r0tz`>hn&6%8wA&LsADO6Mx6U~AQN4dg0WpED zWYGeI1e&G^U1-_?khRtqR5LXfB727n<9M)It17BYsfmGBK45|U)F$qJ?%3T<2It!joI5$acXE2tF3xYS@L1gwV9lO3jVaqpy-N@!izdFP!AsT3waP{*tQbCRZQ7;U#7 z2~DMrQw}k7eFrL4Vd%QUoK(!Y;DTplAEFDs7Ga{Bo1JHDT3?bbPx`0NH)t{^DPqy% zJkMPl4NyU9njB~|3^%v?Zs?xl2eua?r{I|Tn!BY5s1T7*`YC!A%KYs&0^U~mA-G#a2zM^U5pM;b1sXn-R|ep zli~L6ZafGQmnya9HioW^sZ_FRwOp*blat|e)n9L>7#tEV`gR->F|U?OMO-Ypngs#U zG{5)uTg##Emy22jO_3cj8*tw@)0D+5#%NWycXz2~HeIa;cCH$YbMlPWoALZ~iA+9* z!&r!D)wf4uVGJQ>DOF;_OpItDgp{orVnAQf=3M)(agL|`L-uxoO(a_)_c8 z#Zq)E(swauQL~f_A%@@q;IL0;XN#N7z7}!r*ye^`Q@tHO_MqsU2ZU*yy?3=*+k|7F zJ_LVcg&Ka?Uv-*|Rf z>t>hE&sPS}Mlv-O8RrTHd7k<I4hpZ}S|Klw+0`1}9+pZvkU%0#bz z^y}1wom(uL;|#mhT5^f4-|a_Yp0cc0OKxKHZZS0bLq6>0vy)+ayWj5*X)bqnySv@E z?4t9;9B!^RhjGmF+z)*zNlOWy&M!{UV4my42dmB9baA%WZujK;AxYOX1{gdW@P0pq zKq*xOaE{kQyIi)b<2-pOGsyY1|PXMnbE7hM}#|L(g_x$JAHE;Pj2#ir?+Qp`Z_Hv4<$r#H9z^Ly)@ zlV=LSF%bZYVsLnSbKAzy^=&__4WSn4x=@pyo~-x#F-A|wQ<}wU*R;eg)f$5Lj){;7 z@AkXEWJXOB;3#xPs8x|ba$)bam?${U*SDL?d#8QZ0HBEGBaNM1a0CQR)5Nx+Ff7-n z{h|*(Ai&`;*IJofnv#OWwnem@X01YqqBA&-ZpZoFg`CIMD2?to8KWdvrGb{;laen#W)sI{}co{h~O&gn_ zL}c{{(O~l684=rV;hB-W3bcI}+C|Bui2xv?Hv}d`gIYyZ1Z_U-Lem^`xN0UUKvbq_ z+~0yCg@__%W+Vh`4jmmw9f=755!oSFI_#VyL#)-9K+)7H0UPL?Yw*soQ&R&(P#^>| zG63RI3K67K0IX^`0%;^`6ReBT%oGg49EB-QZ9Ak|z4uZx5;_-q52en;&3=D(|AU{r zzMe1ct>?q;?RTGi_=6A6FE7N%L~1S0vs5XfsC3*9GEhlH4UnnSoTofb2dmXkehuaz zX3OOY0o%3%j$irmyI=m9zZZrm)4qG@>%ZxZM>mt+?GKL@@pdk%=G%6)UV?}rm5QPk zLQpY6Ff^&+To6#J;v3J*-US8l-aF5R1ct;8Opf1(K#XdD3|i-L^dSb{5fZaUM<}wr zy#hu?5{|hGT5IMboyRnsY5>MgSyYL_{JEqGBbZYEdn|B+vg_aQkNa2M5 z_W0f=A^^xKIUnMpW1=d>6o^RFL@+dth{~K)im4b{nP#n}%yX&50s5{JDTGMOz{k`( zp-R&aK$zzlKoJQ+fvBj~lw%W|a|p)H!BH@v#@+!DF_~30Ktw4S32T~6A%x(aHwAW1 z(GvoKDWU*^9V3|)0jp$WLWkZ3W~WxNiim0zG0SNxSq@Vn6wmH>oG`0Zw3;Fy61H7C z&l!SxwIU!p0(77-9u6Q%j?`Y@c)cfJLV(!y zU2Jone27wOndh7m8j$1IwoN-!Q3FfUIFEZtl^w^f1pp#6(^3l5lFD3jsUl=X1kN|? z{gkG@2_HUfzw-R>%1b9-d^{o`8Mwt_$`wI|zMtori9-koK)<;Vopar={E5H)znq7(Po>9N`hui_fk%(L46; zjn`g1KV852%EMf06`AJwI8XXD%+T?#cU(k&y=%E`+v5!2_&?|4v9GD7|I)X8>-CeT z%f<3`bEB&3sja=p#2n`@aH;=iLI?eg_ ze)Gq3siJ0}9-SEyR`1-H#d)u_?svD_!wf31X$ip$l9VPyt)=ZcB7$mDDMy|eJ7gCe z^Wm@?+WzeP5>OO?k5}}@#}EMs)RxPWp4@+|NrFS2{_v~6kQr6e*U+hvUC5s3J=aJaEoKg&N z&be!vW4hltm$Ou&24msCUlPI93arA8yTqw1+oo92=#j2&&7kcVaCFk<+@&O)yevZ62fV<6I zE;AyXu2!4PZn;_=rb8-K>KsB3-k7ir9ESF0vyI+==+#&Iwlk~C_38O)_1^QRH#Zw* zCZgkb?1jMfg&dM!e7wvI;NI!7Yol2;sDO2Iw-131<7U0SL^S6d5wRywV5Zo$IoD~r z9=g>$9nLQv9rim4PF0wY9HV0d+V2is->K=%&Fwg){XC|zzWwfdXRFndtLt~(dwg@V zd46-d+aIdPG|dX8VvKAm{jxthS)&;TcyRwwWLvF>aIso0yC$~F{=wzty~~T` z(4JkKPvgAX?^k_)ae01u?_yZA4&?s*2g{)$#FrjExPSltJnv6WhDVnVx;9QZn`qy* zm-jC`(=dd-YnMY{ywien&y*uYc@gU-*^JKX~{c#^(0s>ZO-n`RbF$o}Eb+1_#SZONq;3C`^ghjC244FDigOG*^o&<%%aG+@WB zZ9-^bNvQ}dhvv!SXP!Mf+TCqcA?MUby4&7?Ixxtptd>fZS{)Q1im_>%fE2uUMkHbs z9IN_|wFnWLn3+)Ul2cW2&ds~Mf_D9a0949hzcm6-t0k3` zYnt;k?{^ym1v6wsB6e}HSPqK;yd$I`;MG*W;e+?>^rg-A?u~Eywg(r>qchXY#H?!? zj=_q~d1iU>aDhvZ`@sk-Q=af}XjhbhfvIneIn0xq8d7n#|)sSs)(w`RG>LW051+uNJxxkKzN+u5}}!S z=TsH#g*NKQu08J30Kw4!21bkoj7N7WJICzMtZJ>bs%nT1kkJI}cwM!l0NfN2HK*dp z=KbhUT?qZMC*r1U4cpi)DR#^C#rf&UCqDj$%+u+EN1yuCr#}DLzyHOb|GyW@_VE0j ztJ!Zh<7(kQ{IQRJ?q@&E-TD6d*`tqtmkoVhn{>eYQ z_~dt8z4L|r=JxCU&>v^-KKS|@n?mZ_ANz0r^Xn&1f&B0KgMaMFTW@{j1F!zRKlA7R z+F$&SzV&aMxu&l`^|Hk4=EQ#UN8FHe&>$zO=KiG>_^8o&DwOnrpnIm zHg_qPq47CoAHw!9H{N?90k}9_e)Z{Hs(N=fpPdW_`sCRiAUJlxVXC@6?8p5)O=%d0 ztY%=MMMbRr&3poZc3$TJR*$ad^~Xx@r#WgfDrsNB~=Z__kmAKYwI=`n31;LEAq&Oz9Ut_xu07Kfk@(U4G!B-qGpl@~gk{ zkH7Cv{reZMz5dE4J|W22Y;k_cgs*7P7*_;OX%Qtaq~Jd!{V zOPZ!}2Cx{TssO??X9n?(UG%kT-*Tf;N$;T_I^M+y1!pQJu`4*`axUUj*-lYT zux}`A<6M}EbKw+~gC-&)t_ zy*TIWy`E>S|L;cx&YBSX?xt(&fCSStZm+u{xgW=QeM3dZG4_4eHlY-;)=txyQ_4BU zBy|W=h9ba*mdj=u#zh;DiJA9ZB2ZQAhtYYHqpp^<2-I!+ zqrdId4@k+XDld1DN}@#aP4X-IH(dUV*2&p&@xz#_nE-AXRT(&cpr zK&?ra`zciJ69Ish zt9^fRbhJP8Bq`+t8TxT-TDRW~DP~gjl~XqJmHjhXUMV2jPgB=NK+Q#+GwanNr847F zQxYJmoGT^ueLvh>RPAz%WwB}iL8a^tgR?yMQB7NwqTYHY%#wrks*21h#yk$~Vj&>L zIyQmXNY2I@CJwHC`|0-o{mmyo{E?sj{7?Oz`|tWHi`4D+FTML~s<6EM{5wx>-@p5g zSL)TOU7z@7adzuY6&7r*3(nUIi#&84Tf>Nzig-SMAb=3W*V!jVTgK zR)etHZ;fGVJ(DG43__lP6eb0>&~KXIVwb zpeTvXGCd$7@0=kP1t0=NdDfNy0uJNgoI@tVs3J@#KxR$~5E^697z9Zf$Y5psq{Z?x zb@Ft$DyeL5o}QkZ>~Ai*-OY<1_Z)yS zwl~(9p^r)Ol%fqGPiYzt-OV)-v9X3YO;ajSR8z{J;zPxj$-w7-{%6)F>uG}f@Biix ze${i2cjIo7^Ib=1imJ6PXN6~GcyT_In5U^PdGet)#^p5RaZo9)YS;uMn)Ww9wut6w zMCLf|$FXN3MMWYYR4EFCps_?_3=)bKCotLY@#I#|e>V_j%kYfMoERW{aDpPDq@*Mq;A5D&6+S$g;2$vKGH%Euh*X1Q6kSG#TPs(yD3 zOx`dMTj%VTKF+xis_nk7tJ?eEoc~e<=lt0B&V}pqOC$=Re){w&b8ecNiH?tMU*DV$ zQ&bToh*Mg$tKH3hwX6+WTU!$PohIWyXc5ftSM6hLyW+PVi>YA5nA8( zL&|xa((}*Vnex0)hl~J#89-zPpO;cn2&=~zkArWKwI92xZdHWI`rw^2DUCTx>L)Th z!yBCOsf_FOu?=>ZB4*j|cDWRhB3VjG(-3#VO{i)HOeIZO2-RAW%m~6IzT|cBGh+vs=%BjSjXS-@mrI zx~i<>?$Dt%DNezMNm3ch>AFo>QZAsh-CwL$ce=x&q{%s7IcF^96qSu3n(uEAkr1Yw zw}<_qJM8*yf7p-H)a`GUi{<6jMaodM&E|NsS+;M!{a|^tw2mAzh^c}tQ@q;kbDZA$ z-dEGq$5(36#~Jy+gTo~0BiS*6UiUY~6Dho;#S zP5Z7(G4_2wcEe#9x^6h^_QSYG_Lo;T=a<{ZPoCUt_shEN`okMCX}Me- zcGqvb@%A!!H0*qJeRXNA@l`#ye*~q75*EXTowH2S7;R;$s_C|e#j+*R?XEw)b!ris zy1u!-eCNB~wb`sao4dEqLZ!FPZr!_g&#@jKA6;MHyzAwc@7=%qsbBfb?c29@+pVwa zM^DaQ`{EmKKYVh%>vo6U8FRhs@-)VN3X8Bg*|bf?N?8;MLfvk!wkqRc*KK##IYV1} z9|AEDKRe)5?a}$;M?>Gg_~Hu>-g*m-dCx1ay#D4FMd5|#p1(N1xOIAFjrG?3OBKKR zhyG~0sF{&wiOI9VXT{Ho46;GVvfm!I+rxTM?+=5u)DPn{P2FKSJzgt8UDaxgcWBv4 zPP^T{2~MRj8}EES#^5-(s%;josnRsXn2e#D>#c|YBnCP@-lQa{6hK`pmPE=7?WzUq z7K=LPGK~`h7{-{vIYZW{KyWrsJu#OuBmX$1)E~CQmYp}mfNVoWWKx`_H~=8ceiqe| z3xFDg#o68Edeh#zv%9)po!)Vk*DPZZB4fR=Ca_`Wyfv2D8pEkfkiiC%Gvq9JOrqI_ zfQlt&kUVw+lQ>ta3R{FCv-1N~iV|QJK*O%@_H9!E6U=QLv0+Q8n%xulz-8iL^%QTHS z$^Pm*6+F9pw!7Y^Lig{UvW2z|b=_EvKl@9c<8)cT+Nxz2*cvhhkR&E$Bp_8lP(%O_ zKm&$B0Fi)jX4i@o5Cx(+`T<%9fswLg0AvK66M?7#s-i@UsKjKf1*3A&Klp)VvZxyMOIZ{)N99470N~xGcEc?w3bLW7L#W2nM8x zLen&TKdHuH%57b#%FTADykl>mNES3zy!eg|n6oGaEtZc9XSitr1ZrbkJ=fA@R-weMXX zt@`WBd-rbLbSYSOv+oV5HKD0((NYE9R1Fy_D$`UDkyv-zt`u0WTWc*Su2=Q>^>li& zE`q!LV7d6J8mF?^Y#v|SJoxl4yz|xfrmW`|yE+(VGzLqY?%%sLPU&#yyftl8l~{~n zRSw=elwrReQ@(fSI9S^4$Ex;S*LPz&Iawj{u8YPovtKM1yTe3)?V?UfXD5qsm@c-v zWm{d|9GcoI7Si(g(NpV;ajsb|)~n_D+h4r7yx1IXnx-y@b@0}5ipdyKDaP`CKXiwk zcdo8OjJc|+!x+16*zNjZ7*>ns>}2uq(KQn+no2>ZINjVFj#kZbxoDSl$xeHwsLh7s-`|#g~M)l_R_nL zH=C*3@3;GZP_x+h~ z{mwu2=CA(pM}O!CzUklj9xaIo$0U`--Oc{?i!ZZzruGGdXUqykL;$2v*WP;oP1Aq~ zDV4ge#+VSeu0zh53A%2WrynY%l%xvAnUV#W45HyV)P`hC$;nz5Du3AbYzTp@BWr9G zeDGEUfY1;b%WT*hm!uHD<>j?Au4=1X$a#Bqa#AnaQc~ZiZWs}BM4<1$RrG>*{3B;#17I4;_1 zdAu1TM#cTjZU)gewYj+L;uMEr@Xi~flJlZzoa5bYV9U+`8}7QeIcf|SUo}G_@9f)8 zuTbQAdvMM)btOX1+kMwp?P`kCro!HzlqsH`Ec*=3*tT)~Sn4_u^Rfv7xLP*5Z6CYs z)#a8Aou1w5`xu-_C3|N>aMw2n>o`qGO93fW?T0Qd7F9R)wX-T2RFYuZHjc@9Cy=)n z=iTMGufm~=q4tKjl&SAWAQCAlmDAJJZXXxRg>gKyO{?H%$ozbLP*k_u{jJl@6!UV? z#+ceRq$tcY{T~gpwJe}gl8OMLb&k;#)k8NL;<|RsH1koNWl<1OS2@UBv>-vK7pijp z=;7k%2u0af)_Fus(}9e6?e#|=`^O*s#Q*wt9)0>}^4p*N@OOUq;^^eLmtI}nd+GS> zZf1Dl=D-DOoRj0-A-5s*LyMFcc8|i_?%*N>)AWI`3Sb z{Y#~kVJM~C+*}!Bm~lE>OF?VUICtmySDsw#SmpF|bF-U5+b-5^RW~W7x~|4)Aa>4& zl=7lorYvdfhanQ-{(8&Cv=>6Y}q;u}wdGG5*Dp^IUrV#)_Hr7%wtl*mk5}}HK8f!pwnqp3qLLuW7RMS*S zj>8zovAO0Rky$ zLc}?#%!V0^tE>-=A}})`_@-%=Yhx=FMUXfSr6f=ap(;g;bwCKEs7h#RVw+L{Vl9c7 zjrGQQA{Y+)l#@z9!y-jRjJ0g6%nLy5v}7eBmA=~>w)0>jWkD2UEh@5eq%d>`Yc2a) zN>(gHNY)h9Ql>cNl%iqIn%S5tG(}ZG=Gn78gN6%}ks{0}qU?}xS%_WPiD`#CUG7TxFoYFKL_Qo(7YmEf} zL1i+=d1j+10)ogXm6Ea)EvU={grw+0@ZMJ5Ln&iS){+Q#?+8V50;MczMjLtKh-mhK zr<_%a0uX45;zLbLAVnokQzA<#OPQB`U^ai1s&W7@#mv^V?Sh$+D70;wCXhm?rGR&K znj#{kQWONi06@-h90n#PHl@Vf)fEtuVFh5sS$wGgpv5q&WB?*&XW6=1RZ1$N0)&<+ z)J;`4IhA4R$9|lp5aferKQGvqQm~X52WG3HMI{cSrpQdl&KPT*2R6QGst^F6o+GSHM>+pMPQH9N-@xdXn5h);#9$!rHP_K?qp&$F(ckY)IMU@$f6jHr)a(mZZ z<)ls9_QOGdhH(&4(BHNTfGQ$>{_|gm<2dwv-*sQE?$EWXRmr(oESwGFxOai6aLT!^ z>!u0gIK(N&EIFm7TI{Erx~@>lV$nzu1TB(9%fD>tTv7m@UA4{w080df29OC&?A~~~ zd+A;8ShQ{1R0xoBE+SF{iDtRNm+xbP4>3k~=578RSG8FX^tZp}D?vbrK*ad08PHeW z_449q6G&2=9zA&d3$MRkHOI?kyI!_8SLfXr3rOWGFtwwKZ6rE z&t!}g5=w!8IPoQuZMv+1web;UKezj^* zwd?vUdb(LMS!Qx%T&PqE6QQ$dN;yu=a`p85X1QvDcLYFeciY|AcdOMAvxzCD6s<9r z7uTT*NRXxph}d$;NzgpJxcIt1{Gr3RkFoRuQlfHrZnJI|i^DYj#uwhWeRi^}n_btZ zNu*%CTpIE!81q!ub&AojO(k1vM3ISH2xA{nfC+N}HYUb-$ou=(-CM_-qxI%!^)IfY z_0m{3jib!L6t>iL}-Fu!08&{25hyV%hp4=G^`zKE>P`eNpBN_FL$x;i;styjwwv-5trY>$?U_0ej*Y){rlo0FsUvTd9C z_-MUaEthSxTrGhir38eCT2=Ms<@wQSU2=An*O-~iIL4&Hz|177G3gs`z5TxTz9LeJ z>d^I7Xp0E3rXph+iS4XiJRJIVy>Q;|uCI27-SOshyS;AeDpbwc*-6eLsLqRIbzQyj z=EM8X-Q6E{#!#9j1UAm+sXrVB^7hW1J4iV8y)hJ;);QZ8x}(iecR1X+cfULImzPfr zs2H+bPyONHTMyph?8kAOQtl6jcC}1JFRreT@MhPGq?_yOE~cR$;}j2le|>&+dh6Dc zr%#_gemo3GseJy|U-MOsYPxQJd3C*9R8t&Nno^E`@Zt}C)kK z4~Chc!0hR@-YwSaIAtm6>d}Ln%gZY8a@mxztdExns3gXkD)_3ZQyh&8Ijgb88<$IB zLg&1%s#3CNJ5I3*UL;E?NG8VtiHS%-tTCX^)|`zs#H3IF5Cn2ghyaT7?L^5br-THg zSOi?v5OR!aXpWpR8!S1elmHc(39-OTf&^w`jE^yvJffG-3sOl|^lV*|Nj1-~SqDV-HDwzS;T2yAXWWd^Lxmhn3 zD?s#3>#Se4Eju$Fwl{CS;VN&8S0p7^FPGN)oP?Q-G1ePZBBa?VhM>$wRgp+a8i$eC zNXZCLRGAQoP!x~=ln_u+Rp(KN0!fN9oRlr2aYf2Z4h1u>bQ_p8IEt!boN?ZX3L}G( z_11%ZgqyQgCrB^3oVhRHZKMpdgi zIOm43JM6mKckbEB_4^wjDw0HCi~|B)o-ue?9+DE zIqy^;6)|k4lqBbNRnO;DKtLscGWHW8y5M3K$$5VmQ2FF^&BiR2^*G6TQJ0+CwgRR7 zet&#+)Q$A9ANd=M`s@G4kACZ)|Nfu+@Bb@H`iH;gzq$RvZ@>D?&pr9#=kC4q;?1rH z4k^Y_%F(jD>C^W0&rq{Izt|gBKX`h5x>;TA1~&r;0W?pW<5kQGOg`}A^R0p$_8p+E zmy7G|AuFzz3lSxD%d_VMP35WIU*|Zb0>-lDMAi>6-#S~Ua7Ia~AmT8Nmp6yHF+d-wF|)zPx*`lyJ9{jgdz{WK0kx^ripQn8koZ8J^DdfM;0rvw$9oZb>H=IN^#06`s8AJw5$-&Ib$s&;bKu) zXQ~kTv1hjT-ucQe|L70j|C$dwlsHb~6vruTxBX^W6Q=#mejJ8e)N>j4yBFX2j&J!B z-+S2azUTXYxa;F^{^nIbeCV6LNlJR-*MB`uWG$xQ@olU6_0U)YC%4Mb^37|E$2v}?L zta$`b1X8rt<)Q#kw^hGSfRIyi&LI-B5y?!1h}Kw`=lnUxI9{KhA04d?F;VGvz44~& z6BAZ-u+|LyASHKwAp@1O1=v^q`0VamuYK;pYro-x|A9aI?|tGUe?L8b`_6~It+o2@ z4}9?Us~=pR-F@|IzjnVn#GF%{+GT4Ep)vpTfBwOE*xrBnJ=^Q;$!3{R8t;c;IzBrx zY!y^h7mMcdVt;bfy!Gazqod~fdK(K=RZz)KuWsJ);@u+U&`o31${J_rXjPLjhT!RC zzihmhLZ2aZrjRKKz%XPE6In;HH#QR+rg7?8I2wNv5-#mSI{`kBf zhFn-t6sY7lj+1lNdtcX0Q+ZQ2i)B5HB`2vG=e!}dv+x#G6~H=!2nrOu-|qWTN~puW zAC_&EQ${VK0w8gkW+3&vc3M&z*LKA-Lw=O>UQ~%&|ANz-k#-IP%FJK)0*q{F^FTD3_oUgS&Rt$B$+MF&| z#|BNiUd3r3Hr9nuw^dbZ7PdBoK+J}@C^+K~h1r)f+}v!PHAI-FWP?v}+#Pn_#AdlH*vOlgYKV2sz24Evl% zQ83Izphb-_&-Pz(Mq=wK&|FF(Hi&@4E>tBKlmdi?4YFZDwxj}ptVO(Y#ste`tV5*G zw9a|eqKH~@91kfaQkt7#DcRQxASA@88vr!tOgz8B2tcj1WQfo>9{?zh!!Yib>r*lu zyPmC;l4o$1N|8KGDS79xNN6iVETU6PAflpL5;El&$ysY`DJrGVOjaaKDWRZ<$ZQ`j zrQ~dkOC=kgXX=`Y#FDIH5fv%caw#(QLn;}FN-lsnCw&Dp#Zhu8IZ8@noEStw95Ill zF)C=^#}p?*s)A2Rrg56XI;x~Oho-WIRF&CUW0}o3_C=KD(;`z&1Ef@>R6h7R#1vzH zAZA}xxs<8z3?Umo)1A=F>OHd7s!Gi2EF)kMu-?y{r5s}^35Z83}Fm~S8p{b;lJPza3vvG%Ms;l6n}Wa@1Oi{Kl1)>_?D`!|K?x%FTeG>{(T}e#u{skwZEgBb>7#D z)#K0p;_bW7AD^DCk2Xg~N9*5HtMyuppVE~2(K*}23CP^KeecnOH&sg&>RTrpYm71G z>iS9)j!$kIZzN^Za&mg=+SPDZPa_7m_MarFwaZ1@(#{lCrF>{pcjb-PiVJjek(bX$! zEE{ArOz3MbWKm=si!se+a|)zQz0L}*@g*h%V>~hPm`65_P|4boQYzVd=PZko5=2!3 zU9<~uAThGy*vGMqo?VQ6vse~U0%XJOYMsYe2obTw`1Hxsq5!~6TQ`+Qp?cAvioa$i*=OXf7fow@x-H_#0n*{p|SY$@$g?j8ix4u46iM z{jLh3+eK@rfDmCx;zNLv_xsTpXDW_E2{l_|5ye{i{fe#SX^i;~@=3WLI$MP_MO0-I ztf#sSfjKmO8scGlbC{wEmXs3Y%2**W zyx4E8@kOHd=IQm-l%h4Rl)?rLv9Z<~9)`iX${SY03SdBwHz%3!^z>wNygAw&ePtb= zoIH8@bh&I7i?(f=w*B4Zoo{M?v)kXlefQ+#c)4iStL4#ZwQQTZ3EqdQ3P-C&sGPT! zn1l7!`y9u*s(l^uIE7HrGb zMb)rHrpxP_#d77UuxMB3=TDGmvpzxs5}0E0-V++**;-Tj>HhOCUSHqzhkkv0Y^_Iv zmVqV^rnE zYW3RdZ^l%nEGpt$)lU-vZMWC`FpV+4_r33_>$?8EzuJFc@dv;0+nx(5IJQI-8QFToB5#Y5F+UJ}_b&CWYdIU$jfV zSPorxeQ|MgeAKSj`@^6`$l%q*^}QG0fgJL zg(;;pjJaqj2?@%)N2N07RYlZT6URvfs@fr7$psOb#k!;sq!8m`b;LxXVx0v5K!a#P z2q-#D2T}_L5WxrUj1R%GvCf*D24hTB`64Q%l$^cyb7Ly1b6P>NGLa2IOOcX&T@jJ0 z5ECJ)>NNDT6yO=NObZ|i6cr`|Iz>SQGDIXLF+&k33dl%EIY$w(OgU%gY%WP+LPC%- zO$8OMAHKQ1eMiCMVTj|+{a4=G?e@+Y+f<}td^Jn45U~^?WJE+QDLxZtl`^YSFim4A znVAt8iD;g6O18eX-mA<40)e7MigS*Pdq$tCf@NFgtU4kPm6TvM;Q^?Kh#(qJh*M;O z`F~s0SZ}3dYdm{PO5M%n(Rwu{T`ZdSy>R*u{_3BzUjKu?^^+zazW&4C5LHUd@Fi3F zjOC6~n$n19t@X#7^_X*sW$Jo1zHJwW-A)SZce~4n5AU4$-SrOK3aLb~!;tp7?$+69 zeSEfBEI)9k`RR}UVqLe!c^f>kMMM=LBp_0N@(h-wLk z^Br-T+R7PLHjb=KMP$xNBU|HvF;qUMTvdM8^>Lb3%Z8a%b6r)|V48{`IBO8J>kd;t zh$LXUTm}^x#s~l)SrD!+t_7v>o{c5MX^L!SJE9Q4G-ekZ0s^RJVPi{)qQ#&|F;%sn z?@UDSX5ZzMo7$(C1ZMV9QAJ{V_l4(v>oT>)M$>fK=k;N_wv#D566cDRmowHS4k5gO(7mKVGtJS*g zhEWk0ZL{4EC!6Jiw=aCK%Vm|a0H}&=cf&X)Pz8_>{4m8uTZQ1N;7TrsA$rGS%$0R@ zZ5}*0M-heC)=f8#*4jlC6cq_qi)y>=oHwZ?QIP@{SBLd7+-wK$?Z=&6J&mbp-Sze1{=JQ)oO3EEQJIeKJ?B|g$0x_nz5I{<#$W!> zcYXIS|HO~}ev`78g$pT2W?RxjGcdX-`((3B#Pv4$0AAQP+V{D>0KoF+DA z-sXCSs!NeTowL3U^lVfQ)*3{ZhG?ysrs%y*DKoPVPUM-(u^*!MMnO=qk2wT43^4@T z_Y)gx+R8h37-L&iDNm9G4QUZFW?oZP;IW^UtN)L)H;c7x&F;HK_kG{&)>?b*y-$0a zs(b5J<8s+mW!weaByOv)5S+vk5;DR# zIM|M3$4y*zRk^x*Z{2%Ov(MSxYG(H}WAHFfm76pUnHul=oW0kY^P6M*$M4r@QDhnC z(zan9=VB;K;~2NwH6hkj-E_VVO}lFAP@z=f@PGL){-ck5$M-&c`-^|{KlyJT{lmZY z>UaLYn?Lox-T&~{Hg{ijr+0SGo~hA;hj%@hrkG1MwYIH;PgZR$&bcboZR2ll#=|(GS_sYy57Wc| zxBJ0+xxVRFl@p?AN*AB~#m$|Urfj#5zm%{l$c~7C4#%;nJQ5)4#q(PuigWVLl~V3* zyXTkBoz910ZrYXz+NL`_KbcdRW2$}A4{==wK&;ye8K=3-G1qm~b#;sxgzKi7=R6Hl zO1ZzizP-BioP~zPb!Y z0OBa6lCye`-cVIR!HVw3{^shoB&#Y9sz8K<^PIcY3Jp^(B-qr!Ik~zyal_@awNT>)zlye3%K+FIJgr)#6s|s<}Ohin;$O_;{meZ+k>X-nu%+usU?VM+%oRSm% z{O3Nsz4J1Gth;cyd}`?8Jcq7&{OHm7y7}bCKK$PE<8Zinda)};DaNz&bM{rtd7LI7 zvIPxYigTi+l&nR~IbLs06wM0F^T5t~UvuU15WQz#)y})!Ztt82EnobFf528Mq3%Q9 z`^j(oC=--Cq#=bMOunr`D#?3h#2AxjVxl?C?4|Ox0_0SPux&d9&3R^$)#_9&8=yGH z$Rxs!MMxFL;mF>Z>C*OMWB^<|UU8ZXk&ug8$)+j$rXnPSqNa*MjFt-!u}Cbl5V%l- zp<=1Tk)Q%heZSm-W6I7kT46833`kX7PvcNEVWD>bK#3DN&%%Pd0Bv&4#H_iLlGH3t z698(CW>#`$bamUJL7v892Bn}A)l9T_?2)}&PK$`hOn_ik=6PUtL^#L9?6g3MvE)d^ z#Lg@OFtbBuG!*ehkW0c`Km-jW_~pNefZnmM+cM55gw7$66+=J@BpgakrdgZ=BsEo4 z=fe`+UUEg2%MvFV4|{P=yf;-K(vp|3QA{% z4~FDKN>KwSIhB&jG^HH7%_*_uTyja83$ysT0WB$I5!W=UMT=_yDHR|>WGE0zK_bVT z(~O8QPBBhkKuic0W17b~h)3rTjKz6zz!JP;g5U!&E+>2B95JbdC#e6NpmjQ%)AfIiL1S1G6T&S$<$0sK}17jB+Dh2tYA!@L|CZlHm0O% zBGPmn0{Reu*afdSv-jRtiZPq|NJ-p#>Lb39zVN$^yKNg zk01Z8dgsxjci(&T(krjd!&nF>Efu?GmzU!-GfUkxF{Tje?b*rA^J^fkn(EpDkrpScry4Gxp2B6-Dq*?&}b;}Bv0w_`?j9#v8j{TSpQ{)$ND>HjRvqHpFmUayw zVkt#LetXit^3|OF1t1{CtS^Xj%fP@_)%;=)0GORxW|EZh810K+e*4Wgzx4JyPi}Yn z*WUMv7g5!Dn2+P63cjh);82XQj%~@q4FZk&INBpo3^{Scmzg$ z%$D+cea>i#1B=&^h{aTch=j1;-8jZEPXU4p%Vsbw+gFag8f2ZbBB-TOa>@jRJaO)vDW^bk2J#x|rwYaqOBVrZNu0YSZOu-khwD z!&Jbw>&}I4>aUN(o-p{}`eR?!?OR`d_w;mA`HG37=3{@Tf{(EnlsM-m)K|B+zNwFg zW1Nrk41^_TxZWRk{qf~HXG^1R1^_Jt;3=G)bZyr?y|_L->t1?rZ=UTq998wsotKIH zoO=UWceOBSOrfn6n5dLeDj&?U7RYL#06<{)dlX=bap^n#9+#PlyMn3(oBh2LL)dJ$diRGeJPIaIRNU3YEg9p#bzn;=8VaZU&*EXOI5kPDUfJ}U_OW)+|$RVH+x(K(mLyuW_DI=vGpk*hc7 zcLaHu`lQ7WeUK$BSXDwqn!!w`DKaA>+&+H-K+XpjJP`N&F?ergRkgrm3NA_KlEpdi z0|4Y06%@gyV?PZ?FP<1B zElbjhVu~!mg@8nWRt(J`&V?NjX7S#I+5iOIltwBj-l3sE0Te<31Sf(_s8CgsV_Gas zPLPS!bRH*h!E!wI2elmMgry)+$_YTNKyY3SO@Rpji3m#0&Q&5XMTm1BGptu#-%lcb znxhX63;0l_m~z&f3d^#9lLEV35*TPn^E@AJcIOWs0Ad;sb=Qdtzy32nsbKqKuhUew zm8L|_6OoxMpC47rIgi5u0h|{#EM+P&A9mMZ5bE01o{6oL7d>oo23m3gGc9Ub2vGq- zT|ogNcH)4^iQsakSBO(j&J``pZXO3xi+N;Oj?0mq6JDfS;6iZh<226ml#S6zR|R0V z3hpO!iX{vTv8RRt(976L=iahegZXhsA^z-3WhPytxDDjfk_`fd4BAp0f#CaudYi@_wJqExqr89HZQ+)|IK%wUB34vUj-JAE|7RyJT0ch z$}+M5G)7#&&9;0o4Z%Q7;l=Wa5wQX=k|E%7W9Ef-XDs5JXCg)_U|RA*uti`4Lo7%l z%;-Eb10ufYl9+g>MFEURkd_ZUEkg)3D7i3WsDdFfiQf8fJbY`v}@J-x0&h>2FKI%Q*0)jSWAff3O(!|jt1(kn1HiVebBeFI zb}U5;s43`TQz>Ryl@PqAoS~}R?d|yR?s|W-6R;E$p+3Jl#8R42|Lwo>=XYQD{CEF_ zzuaFw*0}%2f9t<9O*Ly6pS}G&fAb&vGo`$nlUu z#mD`0vT2FwaCPOX*45QGYu7qeI2?{`9oi;L;~c8mdv|qxIPMQjxLvnO((n7Iusz$< zAvh;7+ccNTi=w^#sbBoUXFvbR@BiV=W>t0dPyE+^;p2b!hu-_r7rOOIllscVl(#3H zDp)S#Ftkl*YQMWZ<~W~h+G8KE@FowK!}0%PT?^RvzEeh7|ZO6RAWtXfxriBc)07=Ycqa}t8T zx;dm&R&9-dYC6wJ%~oCA_tANtrfGjWvVfI59(zEoLz7FcDhCL=-EcUJp5f*&)!waE zO&$2^YQI`FC+qfhH-6#|{@`JlcDwQXw7a}MRDlo2bnpHN8Xk_r_Ox^4hnV`~F!Td6 zm!h{f`+kVXkf*Wlr|e^Uy#3;UV6AzO5#Pgg@ynKv_H;WTOW_Z zX4C9akJCII zuE*P}dms2<+pV?_UY&+%jG2W~$=A32x~uzPe0FiQs5syE%H1jHVVu1nlAGz zx@iEAU!bc&I8<$@0~Nr-Fx1{Lk@vDWSx;k3rZMXFq#K7~W>w|P^yb+`imC0o^~tvF znt9Z$wmDhN(O8I0ji~NA1VBR&D_P?deI@f44~K&jN>dUhU5uTGH@An=?dq@}4GWR9 z>jp^KkcET8tj5eaW+n<%7>2oBwah5Y<2X-KT6Ilb`*9e@aX#!0!kDH()sPqgmf%HQ zRjBc>+rRzR7Aqp~pG7B)5Qc|3o z(2#dnkSHOT8Kj&+l|4HVMj<9FCSLG`phAh*)fK3ESEp%EGY(-{++-&RJ zVbC~?2?>~pi2*F9Q6$7^oR7VM#d$JAS$_Po{OSY|2~dl=;8|RbGdo8>YOruVTveBx zk;qCm112eE;sP_3QkEOCS|M2YMkU1@=Lr$bGAy$v#AzIhDuN#ZW=l!YEGA?|L`G&I@g5f)0uu;9 zQ6x(9z}{n4@-Fqm6z4^6SW;T{#3WQi%Sa3W6j%t+g$fXnIi^T}NWc<^f!LK)z^tl* zp#lIgD`=TxPKkugfC)>@TSX#jphZR4K=U}7S*TlrG7f_h=N#vLpHgyF?VKZV$HUH9i7^`zk`;xv zYgmMkip4Z##8NERfWQ3qvv2t1$3F7X-2(Y)*AqZY^E8g#`m}1=s_A}PwN=wrb?4hv zz1sZA|L{NmvA^~|_Wd->`8dqKtNLLcruga4eD?b0^40tIh}=BKW1a~S6>s-fNN{@R z{${l~jD0F`J{%&kBXr(bXa%(29m*U_$z`#RD7?Ui7!vX2^%dc=`KG_UQl6L{0%}XXXm0U_*H6DyYRSBA9`~N8b{vAbtj93Z($``-%?DFc) z_KbcDL$F*7pkIyjFS3W_K9O_&-7|oH5eNt&E5KLC?gmDHp{f=Z(AD$j+w)T*8OP(r z#YI0J2=Kwf2XDObdRtdb+Z~R3W#^guz7N7pw+W%0=NU|MvDIcXjDxU?MZ2bra~}d1 zEgyaT{pAHW9I}BRrmW0Vd6`otq<7zYTz9Lix@x*%90<6m89){MIOe8Z5fZV1VFqie z=GpTnpoYvo_*AB@YY1((zp;pb7B!u0x6^SyO=+0=;6pB%m8(^AxZSmF3xtTGmKj{3 z?72oFS65XP&~dWD%;>lhZHWH{SJM=I<<0Q=_Vxqsf3>L_=iG7X=W#%G#O~PNFjUIw zD}UG>y1H4PbY!k=gZI)kYZs79e)-{pnDe4GF#tvyQe<(W)~?piudi-*hnHWvbLdAe zn>dZrG~*IlAgJmNz=ok;_=chNxmZj|n5>i(lV&Z8b@yLVMFI6+J1g3xm0FX$NqTq4@ zth&1Ihae7-2q6TYrZ|_yCF#5bLLicuOODYue(dM2Y3DTEzx%KscV;L)kRe$?#=2_L zJb^gXc=7b<_H@H6!W5$=)wZd}aUPHRPzMAUhn|Up7xw<<`u5JLTtXNz(+px*-!uGdbO&mz#+sbzw`DNvzd~L<2*zN)I-VcMRa7FADhe!h+=wM})oJGO1* zS>}1lxtweoLt^3rSXW->88Pp#kIuWg_Jo3@gm5_Qa-8qpyL)>W8EhJ-;3XF=(-h-e z6ukK1aFa^`5;Z^~D3O`H_r7kKWg3P!_gl8;|UhX)| zyu4gZV@y+IK_YZc7~KnSDp9CI@D6ZU+CxP0BE~FC24qVP3kVq(87~n}!>C$Vyn&`% zTnJ7A0059UU($@k2u9xLG(CCi3v(R3_u~`~*H;VAQnfI-@whKqx>aQg&asFSu_Z;$ zfGo7IgvvA%vw1G#=rGFhc|!z^>6z_ z>o>mX;tRii?|rXo(aUESOo)inJTA>F%a$z@IRJ?z0ihGmg41yUh|{`_|_kKYDUN>@A?C15SyWJhh)T}hM zKO6?{;Q7_z!M!aiIPY>UzxtCue*fWpJiI6Mdbitu?0bIr-Jkv6+w*(h{2%|-+b_R$ z@#xV5=JX*UwX0uc||T+_bG*pT73`YhG}iqBwr( zo4*IZ+I5>_sv5W7k4;-Ob(3@6AA0ZoG)J&9Pm?gFY+3bq7^Z3J+D;8X=grA#e>>bB z#!$JYuGi~km{TgEgiRgZeR4xgCz~cmJq$g7><&W{u&dqac6)hqV1Qh7o>MMrYKP-A zP4i~cA>hTul@BhZeDA^Cx(U-bpRKE>kDkoK4oSR|lXWoUo0~)JyfR)rzanNPj=3=6 z>9)Js9Suy7ySD0wS+xW&`{Q))&ISRe6o-Chrd*T>tI9KxKxx__p0BU2PPg6un3}Fb zgv+brG#5Y+gw3{9BS6~kr>+ZeO3W(anb8S7f4+ZkcO7F{cVQg!$vOz}?fzJKUsa(W zV@~DX`DVRtb2238+Dgr~T^;8#&qoH!(|r2UD_{Hjf8bNU@Q=R!+rP_IbsUfDdk;w* z0;HIkfcb^xa)G%OvlJtMIbX$CnzmZFWKirl&rYQ6n&ss%=fVWL+oP}CG>!mPa#?^u zh$2p!CLH$%Lh!+-l2ciHac&sq;AP5@fDsi`54YFj(ASMW+#WaE?Q(RfnhMQWq(4L^ z7{)25grLk!WQ5$b&Gmj-wY7J6dwD$`dvf8FJWbOu&Q05>f#y7p@$0|m zhra7i{5!W-`^_c<$0_CGFvXa=uC8lGfNfJhxwyKw?NTXC@Kxggg#ms!1I*uo;24t z`)M3m`*9r2l4C)_i>H^Xww4gkfB=ZVF+1;uF(EP&kq`k@0ZTz*YuX9`=Q;NKomAD? z{g*=Bi8%4qf`bQu;OKCOEF_LiVH(CJw~#LUR(o#j~6pg`6H%YGjb znk}!mWK_Pg*QlTdP&B=m4-hg@&RI1RiWU_CU2Klxu*Bhb@S!R>DHs431V%xyDbIie zip7dJCO`x%pjIpu6DBkPA9+8 z`%qt8eEIdS`?llm^5*Kw408cQ6f|T$IXx97p_ahPew$+ly!vUSsVyae!&~z;! z%`vy#hOHcSwc0{6@mVrMpndxFnc=0D;6yGfRE+)r>W+0Uy z@Ur-)xmeCd+*Hn%+((Y8TGw?r38gzQUB&a)XHN{aL4<9Ej4AmU8({^pjE zR1pw_Xc~{D6lQiJip0cmedQj0I4As11M+Q_O0bb6hY}h+2xd;J}PTz`($YDIh>8=sf_MDw-); zjxmp;S;;9AGZ+$+nZd#07ycNX^v#(n-&3!shR;& z)r8<3fekTg&S+3l8m19TCc+GsbFq?_KmeGN z#1}Ib5n?2CB%p>?iXvJN@rOoAe; z#YDbhSO-9M#Js>Ak|{B2$#IS`&8SJ7NAh4X6&;42K*c)%0~8Xm7dlQ+DD@&KD5 zq6^i}{r$gr=icebX1!Up>s9kRYTayB?al3eiup@lel!eY0V^q^Le}U*Wd`@|J*r#GwL6no6jfJLmVI*zL_TU@ThH^mlM}2u1j(C|h<&!p?hH9;aa(Nd&aa^YGx_!~S^a_Xk&nd7hn<;OplXPtMNH z;xv_&6D-kh|n^+{V#X+b!vA{jzOVy02qP*KZd@aVmF$~=7L^KZTO{`c*7`*zhi zk=PGL;E+>}DaJaqgdpUQAXLpfjcHC^e46q&&u8a%LR}+q*LDO%hJ~%F+uP^QLsJoQ zRdxOGHq@0W5aTo+bJ8)*{b9#MaT?4(3h10u%AUjFcoTf(eTBpZ3Pc1J=Q)?MY{ZpV zSey%}IU8U}bJwjm>l3M};GAaL@Af|U;6O9p?)Kv}t6E)Ehr@B4C)3onUFC(4`+g`n zO|v4zoRNuB9Gj+5Kr=uxG`v0RPgko%fF>!~ez>Tp{m{b)U-QXNUSB@93?RsbR5K73 zP%l8t+g1I}yBAHjN^>Cu_Cg4NC8dHuT2fVol#)1c66SG^Iax7Rc_-p{k!Q>AQR2iq z_pemGBrTSgzDpYBDmY@`pSo1d-dImXGHkoN%POtFx`&FUAJy7uXkssC#4iX zEULr=K;kPfARr?0Uf78NYtC&|_2cB6Sjo%cocBETb5#cdGa_W}_m?J~kghJTNnBmk zKv=nuVq_;^8cS;1)p$IF5Qx}S)i4Zb%1CNxmMalraUvW%lM^Cl2dK<0NVvSdNvXec z_kOop-@kW%wOZA_A%tNZ2q_Mu=2EX}GeWXy&cQP=01=ZM`*FQlDM0XCVoqt!fWdiC zIP}M1n!LznyCo~_dUJbudv$x|yuZG@{^-|#?e1njk7Kvm4)YLP2tJ&io%V;Fh=1*k z*T-Rg^X)gUuCB$a)A8s(hLRK%lUL4N+^@x{AupPb%VuUAvbN?f#{>M+Hr-)o+UL)~nW zmfT;5rp+lc69|S%2$w^Oi$fCc4U`#&VRG&TJB69WS23lMaxsX*Kxn>c36NbNCh^Yu z8WzZTTDF!!7Ui+86hsZ@c?y;HRc)mdl%{Kn+0uEb~zwqA83KKi$V9B|>VDTdY<~*}F zQ=5h%rP)hh$EGEx=&H)s&ElLSCql^LtELTAy<{Yjoq>{}04ZcMOY?+=ECi+{&xS!pKYr&e!ueFf%&`W?G7P55*RD zE)kYk9Kx(IxQd111F(A@P2mh9ELdQxHi|?$`eEn1A83Px?>)^e6wo z57evh*?;m2uYK*;kt0-e-W9WX%((zD9s9wHEVprntkZmX@uUsTN}6V^yc;0c+4OtbTj zL_(<9J2NBz6fiU&JSZxnI2IBhAYvr4CI7XY%Y6W_n2UGLz(O5NVeEIzEX+s@R*D&7 zLcn>BM7-)YzN&$|qL}!k^2#e8eBXyYLhQfrn_pljDIOnv_E&!Or+(}=eB`TzQf z@BK4>u32?&eBzr-`x7+np)PPHZ z<2ZJe7_cx_Uf8*@??YXW!%)|C-8R!O#jI6RhlFo~-;FOP_Ntc5>2s zu~c-5xvqmLs3|!wBwgcu@Q&SKcj&ry7}Ckw+~)zJeRD%5@QC?JjbT?s>M4gMaOXjFhUu}2u`}D8T-R- zH!0KgZn%HG5$A6AQ(c9J4^J;HZq}_J*!lVT?RT$MUEOwVQT5)ZoD683k{3GJtbG-> z>u!mqoNl|-s@d%Z!|a`Z^7v}b+Eu=(UEhyw8}@xffH;>J$F^yvq$iu&O!FL__nXbC zuDuhknlMeVsjI_rSg&eCSamfZ%rURK=H})o!d387%w1ar?+%Bls@ycizVFpQQxcJq zq8ZE)r&u=Yx~T)I`YHf|0LENO)~5Dd7v^ZwG_SiF4Yr%6ALn5h9dlE=DW&6KKG}9f z_3^Xo2lq}+&(_zw;c)EF&boPwC2Q8aYO5)yll6+2kk~Y%*~9m}-+7l~PIIiAwv>WI zW?9%3P%uCsQ!P1y6-08uFAq2;oMSFYNx%iy)QxH;=4nbH_?+kcaTxo_ISzGYEW!?m zK!Kf%<1BuGV<-aTV)GDv@ZNKOoWW0X6H~Xpy!XnOxDzI=V*~|#xc$|t^(|Tr{ z=fq52==tRp6FhnP{PbjdvI);FZ#JtAkc{}wos-*r-?V-l(m(ylzyEDN^e4akYd`nz z|J5J=zyJIH>iK7WZoK&H)z$6S|B)a0KmOv6-2cSyfBjp(^Hcx$Xa3Az`qAUnjR68` zDjgv$p0T_Zx(CYo}G7%?%&KgSF_h{&N;Wg)wr(9NpLxhZDf;%G?qd@fM_I; zP@WJ%A|UY)A*AF9fq2RT5(-E}N*+kSi2_Ij#Uu!u3MPu7r9GW+|yQjR#fL`uy%_ zN@_I*pVE9f&xKsKZjIb4k1u0rrc{Jo?83v{akKU}k8XU7W73qgC^{!sm)mncTy6X? z)hXrUlpoz(8sOnH1y6G-X&yuHh`hbnK7V%T8VNBRhdlHnX*td1*M9!ze&{Q|=k8pe zJi2&txq7($gyZV|Fm+AXAI`grt|SE1Qgpj+@^BKUU?#%%x3}Xsg&@HE`0*1KxVw8e z_hayqtF@~J5QQ1Rrt_gF&b30tT8+>c@q9WnQ`0o!1zAFLK7@W4`}5Q`KBe4t5rF_; znv)=%`tj=W;&kkbsW2zA;Kj5OGZEB^>s2#MWxZ|zK}&H#suDo`?4u8^uCAwPHpFhV zCU!>7sv=R_1Y!g=0~K+#Q~(g~mbYMbE?0=&0U#4P5v#=jW7oy?`v3Z?|C5va=&dho zuU_#X0?~Lpig#HH0xrB4L=f?aPh=4~C{Smn_W00Dwh-0QI|Og{9H}SZeB1e=0y-*9GU< zkrOuzLu4e(LMToUT^I1Mf3~}NB;u#3e)7S$Hck8XkN%!R-*=6F{%o(r70EHS-FoOp z1|#PX8CblN^TR%PcRrnv07=BN^PxYT+x5EJtQ>JI*~d7X2VyXy5WBYN+N+zt|F?gM z^L;TLKKthGoj>s9w;!d7r6xwIwdOJd5NJUbSga6MR8_Sam}jZDU^o+~m8>ixj%w9f zlc}0j048#ayQ2VrYOTt|NR-kjC?t}Sf>t6zMn+PkT9apSPRx)@ecLcWp64|8AvWTi zYOOhkb`?TPOj_#lFF?exYrAg6!nkxEz3lwaYL!T)p$7y5t5Yg@LL?w&aZ5mefV5T; zE;$1rlOR#MTKgEh48G9rmM zADZRCy>w{TX+pfm@$bHArt^($571$UuzXFRZTdI z{RsgN`xkkdh?qsJmI~^86WVBKnsupRXq!g7n}%sT^@vo{$c(k5Tmbbz3cqHp$RZ5D zo@)hmo=^dK8b-BROC=EmL}V8nJBKVYA#@v&{Z`AgIdJ9-~te-spT9(6Pp;?$VARXW;8(6OvFM02#Zadke7aF0x>9R zl?jm@f})~$r#X{zR&_j|7#NAfdt$6PPv>*D zLMdfh@<5vNTzz!879XPX-Z@83s#P=r30r5rlb0ADxJxsA=0Y z6gLltr%-CC)zBCgEdGjM%#&%sXq(jkaNQ@mApS5E8>2? zH)at(r1^M0H*E;fb-pc{L|ogoQ!WM-5xsY{)KbdLZl^C*O#%W^MU=`YLhK~4d+*!t zjne?YZ@m86Fb=Ernwax6v2zGE4*kueM?S`n-~aY$JZ;zO)9KuH8%1r_>(rkwE^lg? z?_N9yFi-TguYdFU(bdqOS8Z2wA@Oa~k)e-n90%{3S}cZ`$~cw0+wNlM$cadp=PBpx zg80@G11fc^wf7-GMq983*0t*pVx4;*n-?$k>s1Q|Mv5RMrIJ$!VLTtlAsx@>CdL#!gfZA>v0Jy%oV&b-m<2Z%jLE**y{^DYt($K^v#Mb-P1t#X`BY=%#L4=%Z zF?i+ibw7-N8vHsq`<*}X<-j8BUmWgdLyrs2n#{leoe+_`+^#?T?6b>FGo^W$Qq_vU zhPJ!7JUkp+aO0^b$J0E5sgE*GwdRs*axnq|EX5T6m|?8B{9v5sA3avnRDyG*mTI-@ zRzg&*UO&3FqT~4-+RZo&WB|axWJR0CD*`H3u$KbBV#27lT6N!puK<8T>6$fZ8mBQA z>WBS$yL)_j`QFE$U>Yy0Hh$xq-$64_)x~u3{Zpz7e!IOw=DWLx&ARm>rdq0kp$py-g%C1-4 zT1uJII86qSa`w@Yu!1?nVI0BKNd#i=+;RUPE|O`}##&O-1VKVa%k`=AEaI8nJoW3% z_B2dg6Q+4IQy-hQZG&^j&`%?=6xC(*1cXjpY&&N1-aUJMyIpsy%}NAosSgi_G*7F| zX1lxm`27zy+l>Ty8C9<~r&NoIIMj+HPJ;K&Or3A;p1%O(i;FD~gcuRYi@V$3I`76| zz@ocH*AMsm%gf6bcXy}bsq31H>#HUL@j?(Sj#$%h|b-dtW?U4HV( zr>J#%wYz$B^Ugb8280hk_@r68&wuetDW?zK`{3bj4_2-pJ$d}mX4QEw!Ao%B zy{Ovvlpp@WkNoH~4!`Bh-~Z##U+#9BO-JGm`y(+P9{Lz!0_(i=Lt>(7E>6g*BH7T- zrB)=X{Yko&0-pPmmrzQHp$XBS`&0jLciQiBnh*ESor@CM4?sv}3g$v|WgNkNx;P7JLRM_`LtsqH$erCoJ^#O%CtW)+tjH^4m23N_7j7{|~y z4&6MT&M$65+fC<(t0!;1c=}oYuCzSnvpnhPDEZhNdZe$(3;cad{`>!g`E*Q$IFWaiwCsh=|D;@gjx$g)oNCY zA%@l?G68C?bI#t0gn&e9*0k+wH=C{rQ-8w4hhP0mfA0PCx&{VB2!b~1+}rLz=nk4{1S!&L=rFT(9EoY8WFG)Q)MD81x17< z*9-u}NbJBMm&(j)I`*e=8qqZ6S;P@L)w(#Wv=TsFGOOb>5KxFQr^GDda7wulyKb{y zZFkM)qK&agx4U_a6z60f`)MvlA`)tyZf-71Qq#0rb?1H- z$4tC%j@uZ;iyC?%b^?S`s^gTVesCfc5eTM!%DE6~@Qg%EP;wFcz9Wei+|+=5B(eI zxc`-({j=!&)M zQ3J5xWxqd#;9?BJI0Nv*u@BB8;{CqgY`Yj@%C(LD;o;nmBbkl!Ok`$Ng!*Bg=VWHb zK1UHGd-nWv^Jp`idl%yUix-cc?9P2oDKpB=o3B54>vJX75M3_niKd(tY1KvqI_~!= zr;^L6YgpWR+YwW2q5*`$96zIwBM`te`Jm+zoV-NtG z=iGH+$(=3>M634V?!l^d>vnsw9s6M#(`MD3#%aB7PRGf4@s6*r)_p%2^3COXoC}~$ zb9N&0oJuvsI*i$igf@KpgXaKrbG7aJp^g4<94~hpFqr1FyIc)pDOI%^0639(F3Zvr z%t}$v3TX6Q-~+QD0xbt5P*5{MtCfjZTuMa*OR=1j3vPdZ1~nf&l1x)BT0`(!HF{aj z^^EMCqwlU6mM5y#%Ho1^V9>Pz(U_4%rYQv{F3`}AEX?F22*N_Kc-i9E4-qs@ueYITrj)(s;QjG5TwiX7DfQ=Zp3=?rt{?N&tFOKI);E9c7k=UI{*}M* z`fvN~fACNImw)H4{A_Uc#*hC@``W92?XUii;nQ#Y`rrNK@BH#F{qukHUq2pC2mowD zpNC;E&?xY5JZ;udb6v0e@uC0V{f_|na<@L8hdGy8wN_hg8m(os3G+CKP}enwVVb9O zy+k$^*EJWr$Los=asF`kT!amo zUVeW~RlSd9=A2)a7G@O@mZmL{ATa_F5d#7+5;6JfRObAO$se&7W-R>-wBO(d{6RYWcGIXdcx@%GsV zFFyM4*(V={=*Pq1I6RE~>CLy^WN}ZQ9h$at0*N}sU;uBwajjtIzTd3ZENif8w zTkRi?-V2Fqx^C63frSaZ4~`|*c^bziw%$q60;Xloispr%e)v(a^X2aHs%xiE>LIni!-T|R7G9u8@yx`#FL6?_?X7Sz$r+H4PXsyg5j>S14alwi6#8j)LoN}(E zWDz03hub?JoS7oBSw%Bka%#?LE=UZfM52~sTme)x#w9PKh5*wrFV^Q;7A}w@rkYZn z=UP*mCwAV476Ec8H6<4VlPK`gX3Sn*lDZKLFwH&WN+RMM6B-z?Cr`-2#D-LBPVO& zAuP27r{QE)(Q>VI?1%3`M9+N>2JE8u&d1iVI7cL*Y9+97=+OX>axoUNTD2&Wc^`=^ z#&#i(*Lil{FKgitS|H3hqv<$IrDii=Csr$zgv3RWnV6{Qf>w3TrCdb>nZOjuh2Vvl z9kYn{o`~mpA^<>j?0^_d(>(g%iKV21{Icf3u$q$dvDTWWexAm0nh-RGh{OxjRU9ER zqLy4#%amu+8e(HrU2sr=nawPNI`PB~&3x14oS1=`YBhqTdcjE$MsXtOoTl{MdIr0= zx*=TrObTe^oDqBP(Xp9X)tB@wk@NAvu?MnR=Iv(pOW%BU`*5y4fH)$8nvIyn0|FB- zlJjr=AQG`_x^I5iTkZqiU4SRP7(C;Z@vEH>XN)HklSgV4iASs&5xfvZbEy1 zKGrfmjj>C4`rPNg@X-e! zozKT*BS8d=(t5Yv?e@2~xhgR-U`k~v;u0SqDa&FAwxC*Qb|i+B9l{(iS^)0`o+F`w19 zQ-8dBIQPS7hVwjmb_!5)+3j|KsHzp}oaeTQPNZ$yDb3DF)mmzOa&@5#ya7Q~Jxj9L zv;>f>>O8yH_WdxI!bGdh<^78n-+u4ItLv+jXD9ysk3MU>G)?D%fBfiGMQCC>j^|qR zaR1_!*I)nUH@T(yHN0wnc=c>_3GS#Bzsn02?!Zh69-Jd0RC>Ff; zUdC}`q++Gk5@SKqpFLoRoz@%YR)-j7rfR?02iB`S}ipn54WrK zlF)J~sxuR(QXI?u{XRO{U0w|55g9@2Yp=d?zu)&|s$&)cMI-}{HkFD*1PEH&;3c%5 zK6`=W9H|eE(bZZ3REtex0;%oxL)2Vd2&Lwl zQz>=3*#H*DwCTE3Y5_bQ4+=C*=bUoWG(}752Z??dXIV-D7IdOPHEV;{x}?Pns!la` ztKFQYbAKGhsXyn-^=7kOzxUyHhVj(K7L{Y``{5iVI*}>cm)?H!(Dy(6V?TCvaWT#5 z`Tc!KQ_kr(O(_{nKYg)pqW4ag@Z0wfi{zYzA%^C3I;E;NH`l{3HPJiga;hwZ%>6hC zkk(=f3g%E;keX^5r|1I`rId5dPMm8RBq%vEAquk#STuCqJWeJcAm{TrglJYk++ly~ zeLGE~Y5_LqLK9Z=ls^6FgGaBu`q?KRcdP9}6P?GYmP{^;Qy zyQb}a{cB%m(zaWF;R`?X=_j9_5BK|r+tudc^;cgVhq0=@^5pUH{yvo&gFl>3wPxr1 za6HD&3CXFSUVZY0nchCTFLjR1Dl`qCcHQdXe$SrgVQ#xNO@ng|08%Od@KWkfQ?u2o zbIy71Ug}QE+W!Z0S^Q%^{YO~BKXJr`r_Y}CLwWq@D#YfqPd~nUep`_rU#~=5*EWod zOy03D=c0=e5Q4OuO-YKv>&@o=?v4=WDTPL`n2{_ACU!gz2WFNKV~h`n!^7=u&E@ju zhLG8zm6E3OJk4l`1cqiW`%Ycct%CPCLHJ2HIP(YZ{JUI~{D7hf&a%&PoaSVpFl+doc^QELxO3n!leehk^ zEtvpjN-2R^nG+F-FyK<&YKXM7fmyANX zh((ZzhzPOFlXy?^vh4_nOU?|YR;?;~FXES^1PPa#k%f?qtmc}>{`n{Gvp9BMwE|+T zl~7je4U>$052h(i%(UHX5ulcWj#sgJbh&%3?l1i5KQY$B8esRuul&eA_dELgyRO}+ z7Ogr@Q-~piIL|o`=V6|j;7B|nrD<%sl_{i@&gTIEzW!?;pZd`uk`+cf57W){hJaY) z=H>={dz{io?|mzuJ{t-+zan<*oT&k`X{DFNnO1WJAp)$m)>;V}9itTkBg91oUD5yu z1`3PSt7^eofCvncnVnx0F(eWs62Zko;vBLdB8w-4B~pNhMnq=BSZa07*PPioA|etm zY~qAjRhb>VOeI)OQ-3~tVe#Iv2;}{tZ@Q+|TJl5^f|snu3}{@`2*Hb&*jmx$Rk{v=(RUx z^+!1a6TeX*M;XV_D$Qijh~Yi!_7LD zc?RUBiA{{o^E6Dn6j~dN7YTKlsv*|K9z6 z|BHYAzxCU#+pNFwbN~C3ANzf;f90nG>*1?^@yU<=!S{duuYddR{`K_1w_o}3pV5-0 zdDyPvcHN%NW6Jq-8m_N4566C(YX}jM*PYMBoagh9nx^U6fJR6RV5i$>!(3i@^UdQ~ zA6+%`nENS%LD%@>Ff~m)e)gTqC$D44jJ5TyTg8%#BT=){c@z<59;b4#ZrNiOn>p#K zjX5P2-d?QF{kU0m$8*2ku83?L=C+L?#_LDd|L_0&=ezA{y;~3c?438YG^bf>f9!n> zT^FDzp{6_sj}QA}jQ;7<7Zs#kt^4Et_Ws0Rb1vTdHn_IF6g`YMOFr0ucvC{c#kJTJ=1P%;H0s=bE#HAfa2&bKY*(!!*~T3ZPY;NZ(Iw z8}9B;rnXu&-n&}W447#-n5|ZwnVnDP?K(QfyTg3B+o&m#&x@k;BD;R9oEfO8i zW822_d1@Lz&xMGlc>)9{970${7lPd1ol~_}uGfddczL;6o|RKdXt20M+ZdZD!3#Tq zT8Yd6Q>j7(rsJG_2#mO#ot9qTs<0r86;yNeF_3suCBk8vV-PdCzdu}TS4B&I8e;HZ z>V>B{Gof0oRf!0f2cj)c#kxEmoOjFwfVq@vdOVE=7=xSU`R;Zumy+ODD2lFc_R7reMwpH4&DxZvG>{~)M$ zpFR7^&-|;W>HH`E;?Mo;pZZU~`Aa|lQ~&ON@a|WC@r!@xU-|0K{`bH4-}?8z_SIhi zfZzEq|C_#BKfc*|N2U}4vy*wsfE=7dqUU#ec7D5#S}in_;8-KYXN|#pFRZ_O^tx(tV#9qhkx?=$&=@w zeIl``=hJ$(IUI(Ibv&MilrxaL^5{yTibxDXB6&_$=hJC;>x=Ka`Nc1-E-sEkswu@F zsya+5G+{w@AJ5Y;PSHCg*gbkxoLe&dL`;mskc1G7#4!t(TmecgI?rX*g_5-@Omm4r zOcl{YTuOB*qKr|{XdDN2?7ZN@20?t-AH0K_ZLZZZGjV@TN|cHrpm$Q#oOet(&!uVn zVc)N|ZEV`%oM<@|F(E-t1$DvxAOH~2>3Hf-54C8BVJ5yW3s7@wwlI z-pA0e6IES^5oXpjt(ldQOlz$b5z)wpj))D^z#Ow80)m)nt$;+r!VZNAq?F9gGoj|P zl=+mDm=Q^8$7*0%Ab4T9Er7;?TkcgS`3;(P^3L!4eeJq^_nRLR92fUvXqjvWMI}@$~a}Uap+wP-71Qsl+97YP*Z8EisluSqo$IGhb>!R8t*?9+0(GGw`87vs`DWifCYH3#C|VE!D9A5ttg7)umMn z5V7W5w4f1aaUrlRG91*U52@{{fpcO2NMxp3HP4fa5m6M77<4K9CS(us0Ox`zc zPNiyPa=Fa&IEnLVnh>;U8f00t?+^l!1G8F-AG(<%)y>MH~ZA&Pl|5cia4%Dd5B$+V!veAAgB_ zSX%B%$-jAWZhT;dJm+71@1x)%5vE)K(0P94@sr(Vr_Fb(rCa<@7cEIA(@4vNNzt_cgQ z-4Q<=P6)t2A%>ExbAeGDAuo=)s+ZecEvnT_0T~6LEPEG%=!Ho7VG3QVDV@%T)oOKj z_xwxmyhG&1(*aN(-&{@odA+;1zkAWdw#+%rV~EiS0}C-VvAe&!%W1s7?_YoY4bX~6 zr@kkY7&?GTNDqhSpz3_XEd6-gtZxuxPIKGEd7hfsi5CIh>^7$8m|P6|{k@l_vbpHB z6lNEiu-!ch(SPlizwSM}{^r}?{N}scO*}k2-|ilN^vP%aFl{fI%Zp9hL?$AM4-fa# zl(w6d3mBY_P3YS7-TjNzdi||;zahR2(HR0EJ$-S1y;}nYh62FoD3^5F-}!FE7%#SM zN~M%S1WglJsPBi*eeSJCmz%@={jndsIChA+R>rDINXs+JF;}Y>KV?>g%pRy^3;23f>1|~xm`ltFJ!4Fny|04$$^qd+ZLamCyc_HV!X5FnyNoky> zJb@yThS+MZM7UaS&CDUR-hb~qBf?HtLNHoXT{Hp)>NZAWSVE1r-D$_{$YvE0Ey+jk3U63g+&$p z!Kr0AVbxk<(>{CpVzX`?iwjY!mYQP>3sc=SE~n*n)sV?KLUF^CTxfz5P-uK823jU3 za_mp3Osn-~=+BBK%vM#L6GI{@rc1*mngMAWV$-!)*ar_s_f83A_)%IU*j<{W$hWF!xhvyok@^yxCk_?k+$3^piOc(=c9MKYI5!zP;ORwbW0a ze)8(8udC`jp6+h%!OT=|pFjKbvrkW_)0n1JxB2`Rf9P;}c=7!9`ti-%Z-3!ezV?mt z;dmGx-g^D*Z@v4jF@oX6?s6K>Y0h2S9{bbf#WjH5-Vf_d2u=V&*fB%Xu8yZ30a>6w zr`^@X{{9%FTac?LCPFOK#OS>9-q|8H**{L!;vfJ0f8-xlg#O`i!t0Cc*wo=P9FOD8 z)tY>qP7nL1&kJB1oojs4xHdMYe)8VuqKe=|&c~^ggjy@Ou50)A4@6c9Rz>G|9pu!H zO}8>?dADb_wri(hnA5Podv4~6!f-l;7#NudNZ5eDDzSJU3_)wYzk9L0xOPoj zQwkyGH0No~r8p=;eklxl*` z2k%5e49JTqtco~dn#X~_(lnD5)5;>cOUm&hK` zQWXH8iilbiK&{rCl4@;Ya7{xjS_`5fVqI|X2I5Eorv7N(ZD8z&IYw8DmXypYu=wC| z$_w~E25%@aI4}mN-=+2^GC15n2*EInA_743dG831x1She|8RWm3tv(LVPG?IJogXJ zKKT?;B}5W2MPSTzW^#ytXeH^Q-m5793Om&z64=YaxIwj|*{Z6U51z##02tIV_opMX zLuBVXB9@xbU>tfM8zQQuTAFiCV}C>taRCWMh*1zQuDWR)$&sLp5WT-`oI3J5HmTUR-R1%P`~^TuCYTIHb$~DVOtk za>5SjcpjTBdM~GQ54GmGXQuT<_w2K~E}#Mo{p=Xq#+xdF40B?U<7t?u(lpKts$q=2 zX`1NWX`W;7wNxQIPZQ({XsPcdco(Ah(6k*gBXX&Q2-_x_fmIcD=P_xmRx7gPTrV#> z&B@GE%XYO|U91-8+U{ltM$ex;{ab(Tzxj<{{eNzM<^Oy1+kW)L-~ai|8(;ck|M{Px zuzuyuH-GUj{||>g-G2M)xeiah{1adK*Z%l7{>EQ+H=hd*&*wP=4>ixJUT)X>!)eaS z%msiDyx`$DAmTWdoKu>Mb8tQnZ9vWA#nt1YxLJqe;YdgV;3EsMRSRuv;lc?X4yVIu zaL&&;#~{_z$It|apru-^+Rypnp&#dY8s}l0)11;c&kCz`2Z&nA!=X2YCWiBQ*xw(D z>EY9l#k+^w<8b={ODM=bI6#as><{O0$YYwPlvAz2Io~w7;`O7e^?KujFDaE$aO_0+%{g-LiF=A4dZ;dTc@1NAWa2KkNsTL9!}HE_3EN)fIvK_G#~fJ z)vC+6Zq{Lm+n1EAssWhlJm;aGLv$&tb5tufO-S>+>=4tO#R)9Qm*stec*z+7KuVdJ zP1XCr2uLI%P4we9dna>BBFyx?V7Q66dCty#w~WLpfK5|&P7q-lXBHXy^yqpUyeoMI zO~d&l;@Y-hC#kA;A>}%ZQ)t@8ag4G*43`&eQV^n?%c^bm4~N}ueYIVs3iFgMFSmeJ za$0rq_P*~LU*{2p%iRC3|J9%D-hBJl{>ESa`rrJy_WBXGaXg*=oj>(w{)K<8eVX&`Vr5WQ zT`R=TZ;ujObaH!lIu2>KU9Z{zW~wE4x9;NMG)=?2T?fP?(YB`n5-G+cjpljEV zCl}*eUwS9a+K=p_ZaR zNC>8gG|qEy6v9g|Bcht=|4-SQ#oD%J_g$m;x;f`+c5|A0&%Jf)mdoXiO6(ZhiEI*# z(}+fvA_PQ{Xx>nQgo1>43F3`MNL~<1oIE5FZv>D{9EU`JF;Ob99XsWwY?sT`-1gja zcDI_@e9ahxhk0(LTsDrqG#>WD(bnGkEUo!{V~qdr2WH+eAcp7|0nH55#MaRlf*~0g zsMT1)3xKOsoSjQZz47zzYgM&D0)W# z%xjCCnZ5UGXOo!FP)$Kq%}j)dL=;HPfMG?qGm@nx`WY zFp>fUCN)DuC6X#@P6YshM@Hn}or`%nFS)3;6g)x|BJbR8_c-UtOqmf)$@{!4F@*i~ z^?P6Xt*gfu!TCI$vg*U_;prQ%)tViW0WdQ;9~_r?nNEjpdok?x(=v5^kAw^gD$a+* z?1GOerEUNuQ}Hfvm$sYBf%DJ}(h_kGX(i;rIa>>vHqn@)hNo#0I9AnoZqKSekkZU!24u(d+L{!T}fXiF}lnfM14XxD` z4Md0thU`q6chS2tO}}!4w@6Au^$%sYp}N z>U<<3Bv+@&r(|GxS=40pMUkqgcEc74&D5tz&Vd3Vit0MtTDR2z5dfsrc|5Z7&U^0z zGnHCUw5f#H5pfgMx|CW<9*G?Q_nY3k5WQEk*bQJnjsaG5Lt_rmnzU-F0DKHZth}8LbKqTjQRgSeLj2!w71i&L18KHB|3_^@CY|wLCN~yDFhs26nOECd8 zYfV&?Kt!xH;ShXqK*Y|+u4Cl6%#!nJ><+P8 ziJ6dDS~D~D-mw$WrmH)t~*9cY{xMeE#&UXGZR~e)*qWJ$j;Q+5~Vlr|9q61tcQh z^}q5nKk0`(x@hE#_;)G5(^BRpAAa=mv!8zZYwx~mNY(_*mb_eEKTdtOAWwOzEi(`~ z+U~FO`M#AF(gsw7IOq8r9j0p&`u6U@IsR>690V|Mj)!3YwZ2P0zAm#FI^zB1zU%tq z;bC4XuI3FDA|5te8?VCf%_ z)i5Y(W|q9Ksz8M3re#7AMGPT!u}{PB{<~lE4!g~!%#({l2!1K0>$|)xO)Z94O4cf& zOXr8f{lg6+JbCi^o1b_FVB`5%)X?Da@}kxm$@;DrLGO|yj@{7peO{)f%{$KkYG5j; zDxfVZ6A0+>;Yj2-1#Qx5Lu64|N>;Jd4~N_5o6U~A@4A#1>C$Fdmi=z?=yKnR5V^M0 zxwY*kO!GJ|^^Iq*g_KIJ0I=jGgt&_CcNZHp7SkB~-Tje5XQ*Z#OlqFb=h|(8RSm(< zbv9{ga5|4y7Z*}%llCV*`-jHU=`f9xfk!P>0jU8F#G@G)BqL=+;>ZwOcyV`sx!+Cm z(u(F*q(bnqXFoHKyhM1LPI5oNE2s|xt{DnvsdG4syN^I}LbvLB*W zxY}<`Wtp1_vZub^Ov~bfN1)xN3(k@E(Y+Gzu4g<#WFjy{Gc*8IBiF~Yn9gM}X}L9P z?a3Q&eellLs!iq8rDl@3yyhcYREr z>GI<7i<^&3=#AH(jN`FsV@I72wY6t&ye_5Hw(hK(nFSxe;q&(QZvF!R@Mr(%AD7<+ z3iZvUCWq6~55vp%-|Z6>^C3hZ{3IL*N`psFo-F63w8hAkD%hH6?T2mA>X=3G@^V*= zF0U@k1UWXTM4;q-^4;cocXiR41&_z`;$v#XsbxxH!_{k_C}j#RnJPKwJUbUq02%U}MJs|Dvex2L0zhQ;-XQ=Ix3ZX_ zsUfYp+cma9h=69~gOuhRlK0MYt8Gm&c<+gM9;aF>IrikMl$bhl&Hxe7Ils0KR5jTs-=gXP2M(j_*88XK7Udm+`Q=&Q!rU zYE@b-h8DapMF=FuEvKL@$3(yUn=c)-D$@14FMs8|>wQR$hRxobfBNL=(WA>P&9}!B zwvxIoTks)$EHY9iQ^i-SSE?)G6o}Rl>6*DmU_um9fb}m*qUx9sR#g?_tBrm}LPTKl zKq#&8D(3@OdB+YJkpM(m1q1~%5F*Du1fN7@<@my?16DOtM3N?e2C7JijM5Yt9Q)R4 zUC!e)NAE8lUAJX!%M^kOUA%qy(Rn-_@9&`IC6`tgP$^BA$kYH3P(cw4$orT&0IN%j zUEE$=4t?JgymK+ex4-SPzxs3k===Z7kD4}O+-x>O3c1YI>af`@)5P8f&)z$q;`zL6 zhhQewB$v9|4hGiDy42;|uCFgk&P&cIrg1ERYRTDvx7*F>JgHiqiwkIAWhu#XZQ6H% z(9^p8<9%t;cis7LEV=nU4V%q0=M=b0&g~5W%aL6|Lb4>3xECZ{lmZV z-|pXd>)EG1wcGFi{$Kkm*Uz54@x4Ft(J%k>i!XjLU0uEXeLoUBNoh!Wu^*6pRdd1h z(JjSH^?Em?NFRN4AfhF=6tNY#yokx;Je6fyhW(ZAHl9&bOOeZq!PJUEDVYds)oGfx zeSCbqtxW(ZuxEms`;(em8ZtmBWw+lpQIo2r-NfwZL{8Klt#5 z*@iykoIm~De*`y|+s$x1PvkK58+IN6=cO|9lgAfe065*wF*6!&H?dSfVgR^5jGLhwPxJNl z@ZJY^j;Zhc-OYo51$NUkhv3Y>d#c6yO#;Swp8GBy4&$Ro7vz(3F2qo3-E6kR6jBf+ zMkFS3PPHMBssdmLjy_JFmL{8_b8FHBv6NTq7|yv60uqa~TIDb<7u$Y3PLBCF=3E5< zh9Mq~V{l$Urm2c(*ZEDCO0AuDDh47xhRcf$Anu10Qe@(#RWuooXH%_J#DD?TC!mTP zPGgMTRMo7s0%kt=E`_y&4*;qSM3Ly@EdwB;ZwSgGB2LrNb&&{LtKP5QO{4c_(DlI# zopU*tXVNnb|5E?>$?4&U2E!1~=aIpN-EcgNeIIXb4%=-aa8bPPv)k{_62pe*XXb_Rs#|7xxd|@w3Of z={%+A=B0%c=EaJ@%iD*mi+vTk*vHeDw|zIxvx*_u&GYA*?QlBJmd{n_a_ety55o{! zY5m1h@51qLdh+x#CI8WjyMT0>Dv=(J=iSh|K==1&beNnwP8qtr3&Su(b`+z_O^>Iu zBTX@FcRK`Vs*I>AW~@!q5RiBrmk>OHskT-sqJ`8ub}Kfu-*$-TohL$7Eu}>759iT2 z7lM;!r?EQ6S_=|6qA8bou6>_Q=cP8;Y`WUip_XL=&|D-Y|1o8&?JqVCNv(ynS#3qy zw6v09TuKH&k$QV`mr^)9oL5~iJ0x_iwYub*CsT7oODV{%-*h1kAN!lAInc5oFTj7Vyyq-wcPYNJIMPdS7_qWhQ zMQX`~omW(52f&WW)+2)n7;+~g+){G)Hy_2|wMo}+D1_-SuGWE^m(ca&>G;X-_@1Sd^6=5k%iAvXZMvs!*bLj) z?_7vP>b+}CZ$5f2pN^vHQ(DePtF`9y)zw7|-NVb5Ce6nvt+bT~!nSVynFx9Q&ENX! zmp}ixn-?GaD}VCe?}n?lKlya3l|P;s)jZGVV~lC31&LKEG7`Q5~#nsqGM}nqS^`qL4Ac) z=hUMr61tE~kqo3&0h!0qIYuxa6C>HWie-jG0LJ_(wAxyhlC>%0x=}u<0T~(*G)Qi(fsR1*#G((8{eUmi~Pw+~m3uHSj@`Q>hS{m~=8>FbhN<#;}gdAYi{>Vq?I z<|w9ATGc9!+;7Kq_~`x3{XIKJ^i94-GJ@0TVLY8(dDB@j~{>V z!Fx-t#K4XjDE5B4*`Q(c5eZ}L``}{?f1pY+q!_vshd$jNPwr!9^h)o^A6tCy4!=_d z@VkJ3)|LOImQ9G&^y}Yh+YfVI*4>zzODSbD41{RF&IMDDlJl}KxGr|YyyTktaC37A zDXqxzwDwuUs-S6;-eycAklW5YW_~UTnr%)|>E# z*V8+wnPW~wjP&B>_Ao9!c3`$XzhX+krzK}Z1<_iIBkx0}q>en0kCD#PwBPMjV86dq zZ5NjpFJIo&EYA7k@wOW_j$K*ube?^1+Qhrq^{KTI*o8H}<~L909_QksgkWMV#1&*(^TGl|Hakird5f- zg%p=M*QLZ5+0oGVtu=#{YXFFA^W+;F-TxxWV+P;&b&7#-U0nMAEl2E_=kbh)qS(r8 zfQ}giLkO1_TTnHF(>Q`dQN<>rdU>%kG*u%YWp-+4@bwZv5mN(EYodMXDWnMHa5^9F zPtNecw;xXh6ZUj}Cxh z3RR5|$e@($qAN{NjJ>3n>+y}4D_H)Naui#c{kz})_t&lW=kyhL;-QBHw z9)l*!)p3pN6C!2OZ~WuiQwN=$9ouM;9+ z4*fd-z!)>gRZ615B=KjxIhl@zn4gGUJv~bH)+GFstP{KJ1q9a)8w2whxT3N$jF#NQ zYAv^~_E)wKjifEJpI2sX`6??*DEO~o2Lmd^URB&lGIsf$aWFy6f344MusxY7AO*~ib&sMS0 z%DvD4dQ~)aq&(d`evtM&oafK#S$^pDhl}^(U8l95ajc9ry&t}Dtnyx=Jt zGPycq97?1i@esnZJQvqFEl24mcTuft&iPiMfr6S%Eb~+GM}3`5vW0r5@l0UA#q@4_ z7jbJzC<=2{;CxoTD$=#XKqRy#_OeG(NuVB#((2Sovb|0wZ)|%5q8d&xO^~Rs1cAUp zkV=O7XAeeS!xNR*0Sa|b`V;E>CEt`z7FT?R@v4U7+`QtPTuxlD{UBIlVy->6k)cGE zfUdl}WG4KRiH1e?Pt_SKz2AxI!=pcpBNqmajmUR1e3Vc6x(=|*ztc8yIrD%}u_H!% z2^li%bQ*0wy>g{+YorZzQwBig%5v$E#iI;E)v+Pp2t}m@PJ{)q?cOM|LWU@nKhP}J zug}#fA5ram^&z|bE$2D~_@7gtm!HX(77#J5f%ktI*uI2@hb0t3lQ2FEQC+Ekrup0b zB9+)2dvDY`;hGz^di_F$)bg^lw(!{lO&ww~f96U+z_-xYI8W#3hs#d8#{J&-i}>$B zl+@b9wNce(-PZnr{)oMpj9;^)InGh!@WoNJ!FMqK@fytoO@qIj43g7WT&*NnB}jm7dz+I7v9W< z2=;5We&^d)vm<-4 zA+A2tM_YBtSSQxBNd<~8dy{zXGQ8~i4>eCa(LuW0PJ6z#1^P<3$-%)yg0bdQby9fq zJafI+En+4D6rGgsvt(Pg5MC1L#&3vwf5y!QII+8vVMf?2a%8 z9xg8%5ET05C$zOl048YD!$JU$|MGqyMS9Rs83{_s| zM_h%QzgsgLF+%*nV4xcDo8CfDMWc5q1Ph%V;yvsk?s&ZqKXMD<>L*qqg_~+`(UY(&SI1xryqhCISc1a$;pN zYA7#3S_yZ@Kx2LiA3W~I$$yQtzSyQ*mABjvCL=2iPZ(N#ndfWio6`Gc_AiXN{Y7P? zK-huZuFIW?M&q!{&2P7YZ(=TVy^*>Igk~e#L1;|3c95C1EEX{Nsz_<-WZC}OqyqKW&uIbz@A3f=ur<#Mm?=Z)aadc@IL z(Z$;#v($WaNpMJjj`Dab`9wls;h$sNK%Y>#*t*hCIF`L^7}&IQ8=LW{HRA!}6r@5Q zMFQ{$j!-1v5_lp<4T~%eFuP}??L!_NooqjxMMi90CA0m*&=ZC91TFkd1+v&dLjGOG%*-<-u=i1Kv3o#vH?AWl?|55w7hD!|v z{L34;E9x=xYytOn!JuTXu!c&p4u%m42kD}||t zGoxP}OsNhm-u$TT{{B+>W| za()}SDa_$sS^U+I9Ktfv0 z*kL2#Bf8Sb0RRISXwxlH`fn;hQLRtNjop%CH?^vO9n>)+3KBvlYMX?^Uv{K?FE^MX zDO6Q=hXIME$5F*Xp`m#)})sh5fg-?iJ-Exd-(57M>RysT=#H45--%mD-r+mt)+Q=vl^(_C}F= z0|LHCna&7B-BtOfFaN}zx%Dd8oi4|p5~~^uxMNqOvU1qo@#s^8Hc1u)aun!dXt5c( z3DVK9N*BD{k@`dUql*mR9hnN;nT@cCG&##fK|mCVW>S-BRg{dIrbYoxG7pfPVpu^u z=($iso4)+~YGC&q4~h&j-kf`~xwP((frc6rt%F^nD}%0eA3 zbS7=EkfSN~)NW6rj_$cq?^G`AL!D2FK^AAQ5e= z=4uPtF%4Lyfi_rxST7=uz?0dxbxb&@o$KMU$DZ0b`%{U(m0KgH&4eK4I+iExPQa}yEG(BA+)!{`7Z^6z&;4PA#d z`g?DY(kxCKodq6!SuX`oD*jc4K|%FD&jp~VjccXT(Q~TzBnPM1@}%ob;i3@Sr|Rdc ze*X;ImPUaQq zWLDfXd-We09_X$9tc7LyI(tailMA${dpXTjx#3hM_R;GA3*Btus9`mOcVO7{ub(vhq6xeKfyH_MrNL=^jX7o$IX#=$nB zfNaFn*?YHR220;3ms@yO$uwK!8K1G>GzNB;f7cmKcO~kPI>o+;9QD<~`{zAnwm*nD zLfT$eK zE`VeBBYY#4;7)^2XY^&&gAc!Bq%q@X&I(D5IX}X?JFE}Luk#lTFDg)_tmXVt(WlqT{{Xr_>PX0bO~S|B{0Zl_7vpB(KL@~y zg2JPcB(@k$h9;z_guf-VGBa^NsP&t_lGJ}P9>SQG*HBXYSX8qI?go+6&*jMcQK%G# za^@#jHKw3^><9MNHP*POc}2=XDn;58s(g&RIv&8yEMELR->&3Vl*s>+G4vtena0nz znKkOZr_HAnP4m`D3rokALt~;We+pGC-}TnMYK8EOX4unSgt3=9Vm;Dwqk4TSXaKCs zzJ-$)LgHo!1f6ASA?TeDm9Uz3<{d$48Jm*nym)kjO>ccbvQD|eQ+f?!EtBY^Jv0$a z(=5X>c?*zk>FH3nZ!kCWuo%$f5;`L;iyRNJdO%JI0^tuVBk8^~o%czrWz7co30+j} zIAxS9(IGoTO7Gse9hPB%d?9q^sr>M7!V1Up28vpXuXX~J%7GdoxL+hmeJQ!LbxnpY zx6@IF<%_|q%gg)wO5Y?OeD69KX=VND-+lJGkEJzRuBgjj5q~vk*7YY*zr(TY^*_Jv zof#Si&i10Kfr*KuQ01c3a;zL~Ij|BEaQalpQ@Mzsq|(-r_s3T$87p7B;m9@QRneNS zKcryhkYBE;F|n}~sH}3cIY6Akl`sJT@$^MYz7?ZEg^1+1$X`Y+Z7mK>PiGJ;2t-i6 z+`MfAn{3#UA1A5jZ)N!*W;<`4#a1OpRlXq|Y1(^|y2$H)o(D#oYRn(tqfX7@G6D5w z&dNmP&`wZZ%?V4X7}S4NK81+FaoY&0mPv|y(TB5qx|1g=k@F6m5uoR-4k5dDZuLDw z`&Zrkn=&lXiL4}U3G@it#=<1tuZA}t$o2U*2xh&iRoO9QZ`#7h6@zcTF(2Qod^Rnqchnf$!vh5HH_M2gT!>#csr*qNHM}X! z@(Gg{^-yjP{j;{c{|S{$Yfv>H#@rjJx~9;-0Ovz)EF2e*kX6SSa@fu8UK|~&ItlrW zN(Ws10&?l`N_eQfPVjqa_pz}(IqI8|wyS>8Bc}~@pq~)E_@ZsvR_J!qJv&n=Ax`Ng|vov{}8cWgYiuD499KM3cgpYATSX%$1pH2P5v02(OUaZ>GjDvp7DYt%`Sz4|?Byv$(0!rza!@~PWt(t@$G3*gBUysRiZ@u96n5M8JiYwZCuakbeG$Zc0bjc;*Zeg)=NE z&-NKP8mKACR^velNg<}2!VLd{1D|tFFhNi86bUXb%dk|#Z#PX)&-m>f;Mna_2Y)&M zD-}Q&-QFhqvX-k!YWb3o1oQ;U5fLlE=n++k?g{sms7+ z;x}^}D*pzG@P3z_H@y)I;)UUR2$j?IqHC%J%dmr@>jsrmqli}>XOnHHin+khKZzd1 zocQYU^`>#k5JRN;hAV^G?nCQ$jb)LF?~RO*2uW`Db37NoYHLF0an>;eUF%U9%ha*#MTo*GX z5j1z(wtcU3#8;X37Y_GP_q>=!2yKyI!|J~qn13Ys>N(XonG5Q6@435)Z#HZ6D@D$I z*n{|4jgmf)#mKQdZhRHrm&hr4nb7QEFX0`vuRsa-VgJ|5flV+O|d}h&!4W zBK3E?VisG@g4UvTuo>IsAmaf&mioI`pDG4oVgTO|9Hk zjl7R>r+=Pc^`H%x)!TvBf6#cO9m624W^10)P^1zqOAgjT7`tn2A8`|09 zf>#iy=e!Wt_jngyi}ETuhDTEMWJXd36_EEoyWf@aezqMMP^dveiBEYcMCGtnmQsod zd{i=J)M>r~{<}*g3Dqr`M*<3hSRBNjcohOb1;mPGYCLPFePQ`qC6DHqJTcS{8GYjlq5*zRz#Li_piC!<%fO0*CSc9q3MrYRGoxHDIaq#U1wQewh{vn zG^@2&SaaH<^C<4K%bUYh;NHryM{C6O_2E9@=B&Q^oWOm4Js)wcA8}L=(0yTjWnXj= ze{<2`ah43QvOItbUEpnODhGEXCBz-`*3spNFz)7gU0}^P@h>Inx3riU%X~ccO=P)G z_}+K_S?lE1ph4zGpt#K(`>bH))PSKamnC{jpoZK~Xls&XvT|F;)b!f9i=6J!7YE2- zaP??LQ@a>kVevd1SR4`B+1af^hg`Np5cpNP777|Tx#`poCI*V{N<7&}-B>^T@9NAm z_;MG$=TyWIASCayy5KF84x7xjIM~-8BT@tg@B1lm>5ob_ml7;6%3vrN zg$_DtmCpROsK9NA_*C)QRhOeUG8dl90wBF3xqG3pW@^9JmefXZv*GMC0oi;cV^ZO! zs64juopR~8Gu2WoD+lvN>P`3+BHUJ48L%BZaG6_l{!ry#`SqK*H<(W{Bmn=eY{>#W zp)+{p6zS`f7;CqB9<=F%l?Lr?HqMX}F5f#n!P2}NjU#z%Ae7U${^`ok&oKNf6YiRJ z>|HA>IVDkGUJ@qWymh5!cnnPfj5dL&0{Hyesb^PvWH+H_e8b0xUrpdi*_|m=C8Vct zU}0O0efS+K(!X}pkc8Ldk+l$A;A??0*d(k!&3oKUf%~Aa`$Giik#u4o3GArCqOW;EaTDc`>L!StJC|604)F?d4C z1?A|hO;LskZ`RS?UZ{M)&kUtadEq$g0mvtlAQT^{oNum=ieHf$p8mcpc)D~FhA=~5 zbl_N%rOTV=Cj!tW$Dcuq+x|Y|dytjRK=Gx~vbpNGQaeE{Y0;OFLQ!e=zBbxCjo-XMDit!ta=$jpEFl9FHWeS-je@yPY#| zuKeL@;q2G%SZESd0pAx|hz*ld_|46gZm#-nFyPf)a7AgFCoFLapxLRnx;9r)Gou`h=;^sB zP)}aFiQe_t@MAM7!@oCvWPkY`t!JYU30c!@Xt7&Q=6aKru33On7GanyM138Cj)Bh4=A90;Ha@ZE9 zhf53H(V(h02qB03anA37`aPhM)Wrra_#{WolK2*qygB?YQ}Ur=s}QN;eo>ezv=Pq# zWQKZM4-nAmMa6+wZOlPqY8lheutsl0H!FoR7VHk!&`v%r=%bq#k$O+U=CJN-}yFO-R&ot6h&5zp& zYu&*L(M-KT`ME#_OmZ$K$1h4%)tfI8kt*cmRxe}Up{NlPThFOZ0erC3(0t`5hHor_a0OZ>q!p2+^;9(qn%`vcC` zXnO9xw+RgQs@I0v9H%iRru|kdcO0e!h-i$hiNQ3OW9`PvZGB%K8C1$r@&X;JH+#TS zaE0~zd3I{QmVJTsNeZncG^~LH`4sF`)lMr$XSpT9nSjm%uI;Pc#%!MIifIy{PehTuAwunS>Mnl)GpVe{|McWd3*=@|^<;9tb*1NJOms}^ajK=9; z_&Ub?pabE3e>Jm>{Qj@Pwq$~y@KL|jEVcFQ-v5}o&7 z{-76odD5tiZN7`T$B>a!HOb4B^ON=Vo#W2sK(W#{a>$_>7J4o#uE9Y%>ct+#MPE!eOijZO830?M0ZcoHb=ey`;UgnQ z<*lS=H8s-Kp#=q;JLj95kh!_+tEyfuCVLm5Tm9jSg<6T3xL@ z^yo&Fw(j^hn8&`f((2xJKgI50!0VT#Du?S!H!Ms4rUb2Gf-0TbS~|N9mfeBB_pvMr z8=(I}|EB(HdBK+mqjgliMYV6#{gZLhLOT=iYsYUU06#F`&t*RIHply2bV3zou4=J6 zpqCET0uQKF3QqeE2DDsa@%FXM2ZLwFfm~#J%pGc-R(= zeql#q-w?hX#^_SV)%T;+Z8WtrAD{jS|t^EV63O)L*RFQ)^# zd_o$!TiQZ*9v&Qr2|~Lr_S*@c(7O{GtB2&n=q>K5e-l^cDn&k*yj43!z|fGK-oGm= zD<|?r^m0_?N4BAR$7b~E?Jc|Tdggi)O$P>x^VO(=oT!)P?O`X9YZh92ZJ>lI+_6hv zzrCC61Tofnky^8_B9S(Ws@Y$vs`N9IKn|`3HzZv>8E$m8LQ(ztd9frT^$}z@2E`n; zHclT~eyakJ%dgdtQ930GmDk9jK_#DFl#wK&Wz`?}JdU5LO^_&EK%Hl!a^~cI)M?wBuUx;Py-5`K44b! z^`N68o)?o-xxM(ZsYY@JC%$at>7p|QzRlXBc6{i{x9zH;`!@?og*A%b9~_Ip z#W>F%Sa;NwrR?u3PON?2w*fIRX<@gw?|UB>l@z0b1~Nj~k{n6$KhGdpNRp zPG`5t(>KJv7`2FFNJPnaQVJAlyS`UT7J69MKY8r>4F83<8ZCL@5@zcHiBj;b3daRF zb*${kLzPdSKacwP-YRb?A9Q$ocBhu+!!~r-D}r+mN;$ zr+PW;#h@V3(AFv&@YGJtA61tx8VO_@CZRg`x` z-(QjFO#s~(ExD@57+B&+ZTTsmgF|+vX%BhAWAdKwsu(~Nf3@tqq3~C4cDOgyWaAyT zebs(&e`U@7ssXT5$4IY$m&R!G+_9)_yCknP)8x+UVlxIvR3&Jzhwf9QUm?-TJL2Px znwC7U3R23aN15Q_A|au3+#YnR>+a~ezfp&O{|J<}yOJcFcg?_4hwOEtSk<&3(7I+> zx2Abn+;&gTj;{Fg6Y*56=eH~B$mt!6JL(??Ry{sK1v~{+-Q3(UCiYrT&48*>96YvS z{tXp$t;-svfAL>)D|=&EzfKK}AYKP!fNqr3P9riPIL1GhjyZDB@T}*zS(P0D-C2m1 z!LUDc38BCDY7yAcgUi9%YvK>>vgo4fCfDq8e5aK_GhNs;7|KrfNbt-@ofS%IH!`T9w3zccUsXqc!6@?(6i;vr?o|KBdB5{7~UeR z{T<>|%zfh6d!Cr1ydqw%1-4pZuxUn$ssA-M_4rTEn=I;W*ffc4{LTn%$c3P7kI|i!?H#jL-b)gvX%&3N=bnWA|+N z)cia>pU88J`^_?WY5g=tZ%H7Sd0Xhpm$zNo;cohU8nB83P#PJNjn;R(#;43StJ;(J zRd-~24KJx>i9EpQuB&iIb%iRQ>LvjA(fxItj#F6;IeD^Lbb?-sO;RYE7!qt?wBD1@ z!N=P6K;-Aa{&{EC0_bkY^cUX04+FS(A@5f++eIFim9*oZ^p?aj$FwWRGcp>QZ<;*z zM{4vC8h<(%jauet>w5+!A73(A1=6eqJdTpR6;%p zqiXdn`*(e&R#IKiyVf1~LqVOEOF?Z6ASkeT8g4{6svs8m(aS~df|qw)1TxG=7h6+m z3`l~C+UvOr=nxI+hpi7FqT;$jM~A+~@kvQE)FR|_I(8PQHp5Qy<1$vGC(A4o9?ezz zC!TE`3nx`626z2*r2e}v)E{0zHtL*%H-5plPSgfO&WekhrTihr({KK$5Lw*i?AY?| zODXQq(|h_|M49i|XoOq9&EbVd*m1!1%*{2y$zv+~Qv7Pj`rk-V+fAbWQp6?v!JK2z z$!;9T*c@1)O=~lBMFJ2PGbLOjyZ>lMTzC-U$lI@O+)Cn{`tLKl)AbEBA;&4@=H2Dw zhU!x#b&Y_BO4B(jhe|}0d^8KvU48;9ub9yf>yJGD7Sx&6`${=ML8E9qq5I zd|!=^zbZDy<0Itr$6Zv(Yn56=26DVA_g>hb_uIwX&okRF``dP=i*No&YzN~5!q`(b zcrO1CJQWMOf0s^BMjuIxmF`bh)zE|$nV`lo3x?F_aNjbIRZLQOr17ZE7$X@NoV4?Y z&kCd_dj>U0x9-c+o5lZ=<=m^@f^vigU#BqICvz4zngSI{Q+RV@aMRmw zoP-1!AGh!1=HvpI60;L?P+LE$o97I^a?UOk@RQpyzuf)|4$0@viaIKqz*3%BMfoQu!ZH!>fk&OmGQfGXHYAR@@;gAa93miH@);l@RG zbl@-*XFHAp(|#NmMF_I^1OO8bx-QnvZEU#TrYAi;_HD;m^vIhzmj|X}%(ve-``t?M!VOJf`fOr#Bt()x03=vHdNul-6?t;sq0 zS5=b!P7}j`9z#JMTE=qhp)VIX6$w9(Cr`E^PK0BYou@vRGF?%h4nv|2+`w)+3NKch z_{zp9V!$xeZ77i-g-E{-DdrVr6CkwB)^=t|>T-N$tE`ZSY0YKKfZacO?WEm-i20zH zkbAE5p0N9Cj-Bysk4Eo2Eyvi~Np(AK7nA1+xoyYP(71kgiWJ5KkRuw*w+xH@RZ~_o zkO$W8UUWw7JLz&xjdj4WF75<&`!UO<4UKfa=fSyJI$$7ZeZdE)O76s$b56&Zpx_A< zT73$2itMlufNP8XXXXLtJBeZ)b`C`{OCAm(20g^ZMIQU{s38sW$ zyD~;e@vgU$sUIG-Enas<{C$sC?DFrtZ8@X$XxBr&pOsfECPRh1aBQq~>GH_>Z0U!K zHV24mnets^?x!*A{6YA?x8mW%qj7Jhre>cee*S87C&a9E2aaq5dHD;P>|(SkNpe=Azv!#q!CrfA`s_Ei&v182 z>YlF*#M4!xM1$zZlB(a9V~w95#P(6Bh;U!4(|{OM0^ z{}5Wi+#82y*p0B}^97c!e{c08NX`R^;)9^T!$0elJ1*E9#^{JWq{pMKuBUWidWt4m zw!%hOxQk`2*>(*8^2LFuh>61PKj-$w z_Qi*xWofz3k%Ku@;sjPQaqU_Y&W+%kKjB3y z7J`Y8WF2A?s1HLqb84+p)Rs<6J)!vJ{@+I-goLkK=i0kP~lbEiw3|^5SdD&o`z!S?vAHTuPzR`Kd=Q z)YkGd9zwKpE3;)WQn#G_QlPrn1Pz5_tUO7&jHBK0+oE{%n59MiM^_}l&`-ct+D?Ep zXV6eroso}fEaPhika|s_ET>O?j80U`1y#5qnZldKK^Gt7LcAX4k9E%9XdUx;ufVNe zUK@V(@Zt&@u;s}fzZ@!`KjgKzw8%BlC$EQY^vWCWJCo1fs1U2?>XXNy!~U)H;rF+H zVp)jSD7a+)g|1NNGKCYNc!an+xTnqfQN+n#rrL-7>^dMb5Yp*)t9!}LcD2epHzcXM~pg*cS7<0}MAg#hg4=atMW!yHlom+wigYFnn^eqgS%rMx|zBYOG85j3a zNQ=*wVWo_j|5(#nnmyyuLwL~f^rd^+>vy3`}Oj@q9+cdjLXt!GU8r4}44&(ZD&Z<2(Kg$QE|#&mqgni5(!c^5 zC~rfRGYaaj@di~Pb5~YIY6C<{$>7}pl9KXnX=mcii0!!#OQKvB%QjPMF^b@oNaAgT zvutxm@-|$2ebkVuhfPRHv1uD)6Xc^6DqSG^@y`oYvR?AA275(vV4 z71p9yk>!U2>m?}`p2mP06tp4t3$W!S3T@&^9u2<(V)>@PGdSg?LzHN)2B}sF11U}a zlR%1bM3}fjNZ5RIDsMke3spYQe$ehmDws%;?z8V&g`#~!VZ;1_7{x_b_DSNwW|n%p z=$`}YDWG^PkHTU^U=c`nPbvS!S6tsym6HY)l~n9K>+8d#qgS;NXM)%0?!PnNB;Lp# zN~xTbN8E7V!~mZVx^KE~QX>c|mphK^poJcY4@_Y_S#^7GHm$kn2fGJ%}Hkz$N&k)PtUv(7HGT$v&fyuL<-=mIt`5Jr|RG+6DajrA~{A$U<3;r{HFDm@m_eQqgj!SFn8e=N4tbUkMoXv(eh{lzm_G-kM+Hvk!8YzbO z9-6Q&Y5u>;LoVaKh<2La>9WMPQ#QmEWlR?v$U@cjD>00U;3UB3@Feo#3Z!_8)Y{fJ zfYeO$DMY%?@$T;aHnnO;wIv@1S<>ZiI$ zi-f%<41dl{0_Atg@GDYd4w%SA7^j*Z|M6B=+Z3zkU17yuuOBV@CJP5OPt0py)kfX%>*Aa-^vef(kb}&0!=lb=_?tzrwl3SY!y2XHJYd81*ldCV-9fj zT{Ykwvnp~gV`;66FGbs~SeJl`<6 zf;sH6f(S(xzs%zKgtPm|YM9{FsfD!wz!CQQ?Iz;@9wFaWDI$^x<;=Xqz44=Zw0LL5 zr5W!&Q>6@Dak;bM%s%9dbz~rq>3N*_-u zs#rsv7EiV)zSyZ_z$ZA%)Z(8d0~Ac{tHx}eB*QI+5=V{uP#BD(|8`V10~L=?W~^=c zo}3wt5KWvHdoBk9OCBXO7ugDhHsnOF*k#{$0XPwy_BqIj%PLkjpc<{?$UDiRDxZWE zlVQ#vFy=K%^;e4OtV`8g9y?Qsa7o<^b>nEhw?OO_rePFs^8L?synapX!40_+*Q|xbU=O5tM{e8(t5leR+x>pe zqby(TT@_~9_Boe5+;2?jy;0R2sstF{CzE(c6>fWP=`4Oe9IU&G8f=?OjR z+b{!paC}b+qn!?HxTjG=<1-UedX7*V1C*M#MRwpV<+E6g{U%oBG4>>h5@35f96MJn zqY9#Hwf+z*J5i2A@Y%We6{_hZE9XCDe8NW=Q>H2cg`7+85bvwOdBiLoB?BYaw*Uuw zs}4+$F_w9f&Dwhvsst&P@u*>p24xv8SSHBxGgGKCKIxG)Bk&|LCnu+~P&6|=et^?q z`L2%?21=&4CIW}nFqros{(+nsq0%(TdQjxcr1}PaQ|OaykWpGDpI@wjb{2?XYxP7- zajI3~xvTwdNQsRu;zAi3?FIa9JSq=)kvm?>oRXflfOB&`{nE5j)-Rv@O77nHQ$DCG z)YBD(F)AqQ*j9s$y@?cBKl1dY?B{_twGuh@6tSBCV*DHS%L-ZX7^)ewofi$$nkxet zC5H_^0_0S-6Y_l!96bHfv>%!Xk?j~bc~#8ATVL~e8HrWx$uEDQ{In~m0S+{KWU;!1 z2OF~jkBGl!9h}5AH?X2okN2GfBPb>$H{PjGP1*#K0n!p0V>WshR%A#StLdl2#n0~~ zK;~D4qPlfgfLe$WLLot&ONF1p&lZ3Pc2Ek4aYK%jxUa~mAvKNEFKOCV>#U$;A>ND_ zUTq*15I}|hW-%okxe?A}2ufM?9N!`4{mk$E<-FRG1KH1r{tW(m z#n7%YDXQVLHQl~+sS*xd=K?KEh1V_Iv4}WzT?+oU`Mqy+Z}jT=>a<92o#QRC!j;KM zx;?ScidNdA+XclvfVr#c}wTN5Jx(!d}UUqkE^ah!T=R3YUjK{FKmA> zDEMr51lKv*=S4nw<)s6aCK};EK5R)L^LtGhc0zNFDAV~83A%}PoUCW__KLIcrbKfY z9DaO^yH$AtWjypOEbM9tTJODTUJR#+lAU+UjsF3kIW5&$tscU9alBG}aU7NcUT=JP z+^TJfFup@#1oIPX-N_-2^e>p<^LtP3i*z*(+q(3*AHDl2FFj^I3 zSg3pfG5AuWiEN&x)$w~Svyq8&dG{Qxi~f{JyrkPT-4pL?v~KN`3uU6=|UgloaR%)4v3ZHCKpXjNz{y9(_Q{8b8vTF3e%mblze+Y*IC_0h7F zOmvMeIuu|a8KWu<4j4g^A`vMx4Dh;i&cXcaP8=S0PlH*T3D3Mc+?e$}#P1gZII2+ZVraZ}fU7cTHiF zQny>Vigpfjxr!np(0vWTffO6`#9-Xg&H2Igx%f@d%k7Y*u!x-bfj<55S>5IdQXj1| z`DA2Gw?e)V9V6_;La5knkUz`3v%GA8C^6gc$WM;U)h%CZ=16`VYtb}+e5SbOl-6vId<$hYQ|qlS1>$hV$m*9`aYNBpQ|QI=U0Vt8!l208bmXZBRnxs5&%P3A0(?qdf`Awt$O(lon7$>CF8THn= zzKAq_lTQ1gIO(>v=+AtmfAv!6i=mc-x4Ewt#{eme(nb3y=rUp@k$+{fjD9V9#iz zUHY!V$GeuauEc}2L0E!JL7Nfcb-Emyk@mxGmEY49Xg3Y8VI8*tc{9?DZWZuHvV(UR zzsn$kIMl`;dt22ey<9VxTgfg`qZ_(%<~Tu`L@3k7&m)#DztvuSwLYU47@aXg?$vNt z>TfWm0cjX!BxOxb<6uNCBW`8~7nE;bWQZ`Y_lP)}uQHKE9dw-briNX=uh@=1cofya z^@{Vs_22GmsU7?Ss=YozZa$&r__OO{vRf29s_G7&o^F%uV!G-YH}aHBp5<%0@{&t&N=>Iz>#;K6@T7r=t0+TABl)f|2g zT#JrAFN{r_#4S`$W&7Brl%a?aIYLb(91X5-7e910J3R=nY+gFJ)#ySNK$VzgsCQ)S zZl%2EQ(a1YWRaxw^!20TP*s)0Tk7SYK?!XZst>)I2r$|wG4tI|zg+W$z!7m@* z_0pCMe}Uj!!Vvs}to;B(hX6V#qfJH9y&pb^$w-BKdb!m@*+GjcMzOQ)$ybm0+)OMP z?thwOj+7_7?n&Ts{2pwZcAsNgNjSQaAstjPU85bD-G&($5KCA<4=JmaiJ3aSWGpo3 zDzd&gj7jVH-aD3=;H)s)vaD9_C76*KPQag5HIs!8#HB)-IuMK`y7 znt}Yncbvvw(>k4#S$j!QzHlhtAALrKx709Zp{)}C9zX-*Ootmm;0`&Cy~tcGAh#bv zxy>t+-5cSvgqmrT&XMQI$i41~I}A<(FM zUN3@e(K_&Z4Iri@Phh0OT-va&bIkdl644LeOA~b(d5|RO%e;f~P%=eu? ztRs@PC~QY#CH}GbgVnSB)|LiOok#UB+E`F*GvahE{@{AE=;ri#f9V_yCwh8X>@AEx5CTl@x;5LM!J%C1X=EQa%p_b zriNM4>WU`7Y#vVtHEz47{ZV5EQ*-jC&Cite5J$?UWZf3=atJfVfc z5G4;~W5NsOql=#|^9&)8^BelI^C5s9?ZD1e;?mUT=F+*!&nJlU;trINngMLtlT?Axr@?l#l#$34^4*+FLnu~YCZDNi@g zfLZf=L=U)065%Xy1Y)FoX`tfdPYLGvG7T4+gYUPoLgZ%|X@GR@Sm}W@Hav;l%&o*B zY*Zp$vz&fW*Z%+^LEgUj=2w1sm?v{9^LRX*{_M~F!gxMvtIOnG>pY)N4j?40)sQo@ zL`fnNQgR2iwirg2=$+-#141{wLxDM}RUiO!FmpmC)K-B=kjw$RYEfcrwV(m<;+SVg zpb%5PB4#3Ta}JRSwW+GQRs;tUM_@t%ugw9OTn&IZ2$6r(3qv9xYPFd*awNtDOW!a` zj#wrjsLkBa!0E2dip;d65g;*=Ps14zl6cqe+B{ueZl6DYN<>k*i|y+D_ulJbD6Jii z2W=CmKKa(~t*$=hOz*$*r0csUFHfI({gFt%ytvw|`(^2r7*e+ag!Scve!TqDm5F>Cv zTH<2^pqm<^tE<(_5!DQ;@YPuk{NW@KB zt&2xPLI5Unuj47?RY-{ewHd`2Vy}i zwK6lO5l#u0ggG|}vAK#wCbn7tgQE30g|6@VH82w} z2ASu{Q2;SXAOw5MqpBnnysGrphd(P68f-u<$$#?pRwX^TfnVjz~y> zSf;5}b%|nT>rEe1Z$N$5Ynwxi%rqY7>e{CqqPSy-kz+yvbZx2AxWJl z6h>kZYPBpzpO8}svDVURaj)*A+8hiKz@e5V9Q)N}Nbz_)Ovh81M^n#zCxOgdRbM`P zf=J+o49o#Y02;V0F?FrBqE(P$*M*o6fEaVXK}0YmB6D}u({bPTtMPawMqo_2j}nQ| z%mC4}s1}aBNJMndTIK?TA*5RB)&1>O=o|0f{;AJhmwso4;sqswdk8_~u0QYx9?TqK z+Fo4#;{Wh>hH2OjzMr)S^EA)FeY3kb?DuURPE)zu?JnTo3zwUSeGNlyJP#DQcgdgtimT8)&(`GYjwRW2Y077=N zsv1*>BI9^*e}8v(*fU}uqE}P^T_$&|c?QHjb^W-K6q#{arq#HS#I+PAL-%T}6mKL{|3Os9pTY}S`AU%ieYm}wBK zZp-p&H9STw`}vr-ANpjbd6~)C$@8+*Tvy`=j2El*i`TDE;p+NQs}hl#&hvbG^SbMX z%{V@N`uOF|?Jx|R^~T5$fdV7(>2R_FF@{`DA#j&2PRHZ!u&f8C)-#ov4czCqEiiBBfa2Fy%Z}wU@b2CAZTGT*T=4m2H zhljl|_2W=$0Y?$%5K1kUvqK%$>uy{H8B1P5kY?rr_-Tq>^ZHTvS-xTrj)(mnvXs2M zy4$VB^!^vV2x_Z-I4#Rk=A~%tI?KfgL*R~C9r~CUt-}cIR)vg6;M9$tjk?=Rio%k39pqR{}BfS__G!7_2s( z7>L-aA|pAvLkwwNP8~-Kf} z0o{>X&?nZCSL+oaqdA8dMSy^W(1H1U=rq;MdcEI2kh>vD;MKTsvvIS{d5IyMJ$K+l z2<=WTjDW3b;>lZ&PKN`M#1K+Ux3BNlo0Yo_tMTFGUB8N2_31nB519gm0O@o+q}eu#(tez)7*?{@bO5BKeV?(bi} ze)V#F`80N6v)+E;qYolUm#o*r)1iF$rLXdMiS>|OF0M8yu&GLrIb&8c^?ryqKlrR) z^;YHj`dS@_)#!>6i32^{AInk|rMoiCS{bOH&mE+BnBt)g8|@@uuLQR<+jobgZ?e7>U^tIWQ8l#Qm$AVZC)b zPw)YeL`*ewU2D%kA^<`JiJ?JPSV9N^iQNDZNSIok9P@dKWbWt)1O)C7h*fJ@mWNlb z$}+cXw!}z8NT7-mSR^us5ae_`MG;Af2(>O8LX5-V?p0Z)`(PR_k%S znfJ$czw%dZzWw`;-}?{%%RD0*qJX)-u?QfF)fLqLG(Uh()akQq7AYPN&H&laNqk4ggLFC0m(i)q-S< zL0!G5069U3>qjg3_~zj||MZ{yo&WG}|C8VU)CtQ#ZpTzaNHfH zymb8rgoy}HK+vkS$UjP>kb6TU0RRCJVR0uQ1Uy5fO!3VqjsSod5P%5*h}-6n&V7Ic zp`A}aYpsO%23N&|VD6ElpPMj@S>QaxV{a@5Zo(-F2j)mfAw>WK#F}%SPbDv43J#~! ziG|vS?f_Spm$|BzDv;Gwt161h2w;`}!`1u-**A5Z$2b z;yllQV6I7o8HF3o%|oBS84F z{Pld=z5B(loOZiXrf>iD|MiQ1?O${E>v!J$!MFc-v%QiuEX!hE$uS0M%}4Y8etq$1 zS!RcJHhBJc>V10vuD7) z76r|@RAFrI29h8t5$8pP5roaP)mqfzs?ANqj##S>eKf#Qi9ow#`tqtQ$0%V~uT$3}VCVy=IpD?i zBK2KfW-XOkw>Ch#yS71_`{y$*IP+}~kqE$Adpr?0oK`dc|L9Q%0NsrmHmGs3%@LqM z^Bc&mJq(x`5L+dqBbXL9Gd~+`&1<{Z;Ai;4Gj7%Y%=f!D==}LAZ~t|-Hx4ocXv0Ia zs%qe_ZFEi{GQd4F#ELIhQZp2F)4)5&eWgl7PS^LBSZ&xH;M7p?lqQt@$P%?fBjz`hOwRw zPu~4-ck}&U`8)qfpZZ7df1x^j^wn?Fk{kNh)DT=^i2eBR^3(O@;}DXNI3ocP0utwC zZf0skcJwGAS2eA9nE^Sa1mLDvYc5MxZ#|dBF^W*0vv7l`gPu8rmMbu`*2?6e>-%xt z4IOcEvs^QgFmqn!S_?}+5d&y#Cf>aI$G!N5%OvbbwZ9k873oa)S^RfQO%h@?35F-Aa~4u`<}@cQN3Z$I1Xu)Fzq zTy0Z7AlXM>`xOQ^H$b$qEb|h(jzR+F&~>Rxjq}rPL8|&j#Xl3U+}uHHDXj?V+~eeD zvEKoNMOEF^&8wSLb4P6Ld2K|2M1POCe0_bnT5n?NA07_--9bzK#b5q)09&tPE&kCL-~ISIH;0kGt0;voIlr+zHuSfD@eh4M5xViN+r(fmpVH5mua^T*%$^#101 z@BYFsKg=fzSC6k(xf+9j8AV~l>MERKOw5GDL~OOF6$Hqo0-l=`=6PvGLsfIDPS`x= z)A4|yu^ZHkkR%B>iln=jKN!~+?%?JK2Eg0}Fi%5os(@`vN9_Y;Zhh1uLC^sV9i2Ed z`Y2Fna|CNo%s0tVW>zhADGztIWm(Wwn-bOFX^hMwsY?>)S~O39)P)EnW)LOBnC7zN zxrP+MQN0GF*pCKgXK4W_aGQ*yJFx&LFc1nbp~F(9z^GOcm_tKXS)NZM5h{p;S{9b* zX2QWui3lXbMpriw4o2qYL_$C$+~Wr8iMU0s$@VK+Lt4K#4;@ zL=NcS!?5Z%moao0f~gXtnwz@U+Gy;l>sxZVlv0-kf`o3UWdTsFW2$1WDT*+gD+{`LjHyAPw3OI| zTAhg7k5(6rNtoHHdaXzyc8NJ?t*y#9Pp4cKsHU~F#$c<4B236JiD1=wfBO;;@;rBa zimB%i9dJ25+~3?f>Uw(-(?EpawKcaBG6(5~Q2;pwKoAOqKqR3{ZKBFVrg}U+)MBPu z^9&?0^&*VK&4;G!~ z=-I{fqg)EbU}wV7pM$+emVVs)AOFMOTd%qpqcFE}0OEEsaC2LY>&uHx2(Uk%j?)x` znA$G^#w4^|tuC(~?@lK$V4_^>u-ZE4lFMow$IWF-@#Y85i)90|mOFB7mVk$Sj%kpP zSbk)2GBB%o7}lvvUDw^;z2YEW`sn8l`#U6`PK(5p^AtjF4k7}Apf;=rVKViWDi`?~ zm&7P3#^bV(FxU@w#s6Xu(BW|G`Vcty4`;FjZcPd}ole{BHZKbz#?&vmq?Cv$#6eY= zxa4K*M?)jm?dH+?@m0xnNd42dztE4vX53zl!~M(emgC{DyGue-wqu>4i{e%M?;v8qd1L=$;06;bv<*KmW3QS)rY%NDdpK)?>roj%v`lP%6@mt z%**_5{Q9qb`spVhe)z@je*DRc`BItMDc2WU5Po@czujzCeFRiNM8T`g_V)GN?r<`|s)p!YjQi=d-EP7g)8vn=z${}w z2KmW9iV|W7iCI)lYe}&?O@|QU*!R;s5mBvfs4>RlaT{b`wn5gq4cnM+>gdCp~?Cj>4f=Tfv*AVNkfg@^#r;anP(=hFA7=0Zf{xew8hvVVy{^9y!qh?u4 zim@sNMr0aS+mh$iX8ic$Z;A9VVRm}={kM;YLzl?B-tSLILNiRM`8k>Oms$Me(Y30n znpQ2Pe)#3Dt}m`u+skpi9oHA*YCEj9{c0_-`#1mXf9LA@$z1I5lefO`#g9Jt;G_NV z^hdw{&zJb*>aEA5OTXG44$JX0ALbfU66V#|Bf#l26X;YhO4;vsvETH4#{tY3-IrWV zbKmtq?Wksl!zt&PL`s2_=x|twNvk!R7$C*SRw@gf@tfvq&dedis^`=*AxmO6FLiDc z(0=R@*fr;65f%hjtySHu;eEgXm>3C7)!W3~y``?z8vw#v(e8OapxTO75m2?5Tl*uc zRb9PSKql~{fPYL( z5|OakyBr&z9g)xhz^&Abhz=f745mS#DM64fEH61x+pQWw}Ln_qnREb zUO#&OBQKfzQ7GP&iMJT9)z zA(*M8RF_HBkvMfd7_iW=+DuDHU6+_14!P#Cy%_)B-~K~K@QTG`?9w}rH}|vN+-2tQ z;TN8TKE`f*{=H8=`ICP}XzSJHsBVry0th#isU3^Z9fXmLfZf`mpB0RenfVQ0gps*f z*pSIpkpK|T%o*FD$q^Y50M#pVXmN0q_O`|*0uT!TvWS{D4v++KhY*-K5P>;RV>!7t zNJ-171rcItgUflItc^HJ283bgOEp6r`o6`;@{;$*qg5ToQPLnGA;CBd!}hWpS46@L zfl*!ED>Ii`6%@4%SBWJM5FsHTbjiITVZq#&(-cE=cO=?gT_7Mj1479&G1pSN5D6*u zfthyu6KMe`he?@8$N_wRICe1tfSOLnL+nQfXJJA*9S;D+A&A5_AZ89k#39yN9B@7! z9$w!L>urn?8LL^Jy2h_;em7$7hfd9_TFDb2gwUnFLqH^MK$2xXNr=pi-QcEPm)U9s zA`(IfrIvoZIo#jB`u?9@zxUB;I$@nprwr)t{=zrzZf_I9{mmy1*l)IA(9X_?xPSTS zJeNChC9s9oP`mRrAs%BtnXZjhMn&!+*DTUMS4uuIp^L#q&LzFbGYbh}WQ*Zxr z)|<=J_aY2n1o-O3Cl9Y)j#t-&3;?w(fJ8*9{-Y?RAoUPO1(GOq1Unm3o#J9Pl2>rR=hCd=& z5D{{lv$K|&V+8XC5RY9SQcr;$oDi6#Jxo5gXr0#^P*MYhG$%Epiv(ugJsgPW{7Mkf z?2Y*F`LPh)6wKaiR~p^N_$*!mm>~;t!`eCGdEkg(#1cZ#Qb4s|UxbwKJQ~C1XJBIW ziU0^^wU{cj$-WkMYr+OedxkS{E5-n3W|ESZH!TKdq2-HT`{w`pU;JkeuU=V5?|t~C z-Q8__)#K%(-~LDc;ORRbTt9v9lW+gQ_1o`g)#esw;yllv{^_5*{|jG#xVsrvYajyk z)9L8$OzdqB;|@qM2(choaRtW^g+r_gr7Wge)S?7rYP1BD5JCuDh$*={F;ufxr?n7sRdshEQP)~>3=OyhXO|BEqH}vf0T7XJ zP_5{y>TRcFX69<(XyE7}M0YT^bE*Xii5(2w&yXMqvFlRon*G9^%u4Kr)DPRM$Jgui zKFeSE^}qGc{_+3R+#bL5*M4KSyFZ>zF?6LYgbK)U{@DGLbJAWX)uj; z7dN*o5)(R7btj}yEUPMD1;lb|WCwTxuyXb!ixbu)4e3ay&YsmfH10NI`35a3oT20$d55 zj(4ZKo4eQd@`|4MRu_s;Btu_pkL6EadsJXNO7&tIdE$Z$~lLJ#TWEOO55*?}` z8iLRB#7M|dh}|u8eTX74)iQVeMs-0VM-oCXYkUs`$H0=3NFX4I4Fn3zL{5$-F}BkX zNdP1;YZboOK3`@xLvS@khhm<(jsg>js;1D1bcl#3NaAklhzKGvgcL$(;8Oz^W|8=? z+i59?)^($Fy@P=RlmhNmjRRXLplaYTMFWa4AsB!+W{aws1EEQmL=pjTNWcILS`C3H zQi#c{<$y$(P=drxy;@lah(#O?8%Rn7-D=H5ghB{SKv&a@%!I)KPz23SyN8hCay*r3 zX{KZ1K!hRz5t#!MvP2Zl)7%Y1Q^di65Rrgcw5oY!3~}h(orwGON?3r|y@f2a;rPIS ziHlZ5BrpzL95(2pT95$1%3P`|wk);?0dPt&bck%OHP1B{tQ84rsVFh$;#E_ZSXg3| zlv+60z=_1_Vn*&xh;CFp1CoGq>Jfkif^>(&5!|(6J}spzYTA!uKXkQb5k|l^YiJvk z5ZKiKO=1cuf*CU|x#Vf8wT5Bn`rge$N|Is_vXY%(KJ1AZ0m^(L;(i#+j48&xYd!8z zD>Fo^nl9CbP;YfMj4b zD-)+K5Qh*M5JeKGy1RO1j_MUz5W%V<@q9X!Wgb_nT=Ft6+cACbv%7D9a_?%796<5zy9`HPu_d> zG=}){^~pJTI|IM??73+vC6~OM*Rte13scvP6s63WglaC&o<95DcfRxJ$=l>`n&nBfBKhFF8=IU}tR(89NMS|ZP z4`p{;YJm`!qE$j1+}`N*Q#CDjpJCC@=b!z; z&wqKYIxq8TT#a47T8}MRJ57g>!o$OKzq^0-WOJGqmL8F7odd;w7>)KYg)CUP@Jq6sBojmfZJ=IH38HtE*h9xr?Oz-5rH!ZmacpT594LBNr`^q6BFg zBq5>0hwp!3J+3#a^>)2ouQmi$rN8QMI^N$soDQeSfL49KATyH8s@{{s7H3=<4doBqT_fVyC4vCN_G@EBi8^t{*>n@%%=McSFa>yZ!$9(PKB= zA9kolF&vK%TJ-7Tw_^&s!@gP>QZG#V-Ndn-n`+nfA@;e}d77Dg&c%Q~`snAf&Orha zBg=H0-+AYq&H8F7^H;z2^%pNbp~~a-Vt4m|%-tYg_~_?e-rQVXY-5Z>zT3}TCwV^g zU2lke49-5p?&*`aZ=S!1BE{W6$JN;UZLJV3=gC~n>d(IT-FKe-NXiXg-`?E4eEI6; z`M>&W|N7PC_0{F|<;B%@vmN^37r*h%i_5Fa>&Mq`J^lGFeffhgerb3A@ch&7!TR0J z<@M^~ayrd1MG0WlLyQVg^Qn~Frx-%2WfJ%0v|C?YYtd>fgn3$qforuOe1G$UhgUD> z@c9(R z)eOAJdS~CiRZ|7C&*d#|;5t)t_o~1gLr2U(0*4^NNJJz^m}}8eIS4TYPVK}iA!;r2 z>4YTftH;a|`c=1DrJ+Z+`)-m#fAIBx>)(6t z>E+v3!+vrDWZ~HLMQfcWBr$Ub6Jp>nZnmexahWCr3Jk~7zGThQgBg7JOK)49KK<`-8Q`4s_QpbkB03d z2XLz*!GQo#FgSq_R?W*)j;B+@J-45SIV^dR7(dVBNY@bnGYPW-5TXH%t8rYf%`m3G zAxPk5E<@j?7=UP*^PEdy5+ZjmC3pQeO?g`8)sT=lgt$y66pr1B2m;e@|NZ~|(T88^ z$5lU!2xzVV(43fNMtD{Pr^AC5Jsx*4bs=^k2uf&gBy*UjdEP%T$2?CDFF!l&9#ZOw zsp|)KYaZ?vaFY;;sTM7H7LM)}L`TSeIzk79i`RpC7%19z9U0kuq{dd3p=z|Z<-PE-#jZZ=xSO|#CN}U!V zFv4mUgo8lpdjg!N6GHRsCyc!sc2V;29@45?ZDY4;KK*5xPOo2a2oj;qiJ;@v#O_Q=9E(Ck*JoOr(=Ws3X_AEC2Q4Y$8Oc?Wm&9NHAj}z z4b5c_W=Nd+v32S;>7~7CEDR{7dOFP_9Ab(wrhXtK12WEfLsfAgP zP|c`8j(&XXe)f+;Yh6LpcEz1N@@L~c0ZW87{cksLcOv8v(A->+L;^R@^3OQ^|0$Bd zkBbv#KTS?(eg`0L6dEzla1&0G~x_V>5lumYlUEMmzGxn;GeHdL3lp%n-7&Bq;wXtfeyRg*v>f!s+hxg|@XYGgn7YW+8NNEv4Zu z=2{hzV@d$ERwD;uVB)eY%nV?z=B_0dBrmx%->3u$eaA@0{T&jkYpoVz7{(4r0HG7A zb+YQn+z(w~R#nZl4an7%nfukc8^`1Be%kNcYB9UMeuO05xB`cUngMeFUv0KlTI_&H z1OOy50@kwRQn7i79f%11+;*?k+9gqzyp%jb*h;W!scOo^z^#ZFNYBOTj;eDed4u5s z?SzLUSxGHx(IhnO_UrBC@BZ%ZU0rV1!|?Xo?_msinwh!pw)_3V2VeQC_qTVi9}b88 z{^5B1g%96391h!UPZDom-U^gbYd>tvYKnp!PNzLJ@SW>2mE-R9d^%RGHBa5RDsxt| z@Z$z*Xzyy_glaHPyg@#6Uv?U&%W`i|4Lx?TDCO3+|LNmj1i?2Ml?c3F*jjS zGZ8^_V)oXJqBVA*sSWps*(+}p#>h-%Kr*aq}0 z;jD=weV(Z@1h47<9Fm049!w2b1!^tV)}At-*U>jEFvNsF!jk%);M^bIjtGDln29KK zy%U5GV&8i$rD!fw$IzN5b3UOvb6Dm%*V<&(5F-#T%YsA_`xLtnf`lXz)VykTYZn>D z(5V#zE4ef|P)OXW8JH`f1B(EtT8QkWYAyyw%r#d;Ec2{pT8fzwfb@Nk?xdz4@SXd3nT|y)|gIMcQO3mz~P`#L<_v0#r zLDj$wnOZc4iAu?mB7k&#GP6>3o|n}1R!i|}wVG1ZLd0fR@)SadF`&5<17ew%6gc!L zbfW^)YzEHMu${t!!eKh>MR=Yj0v(y#Ij?Zsy zUf$lmdj0zDboA=S(}}Q6@h!xzx^6d{%ZrQDB?BzeBtnP7X|*10&K%{*_1nvGIvyX& zQfkdD3VF^zw^NVEupWnT=!gEi#=aZ+t{<)1GA}U&caJF^rqj3@F1Fh;&&PS{yZ+^i zn-G&B5(A_3U23^8hc@%jzj%QH7@`Z~?lke|VbGtV0sJ{2AjI`*%ykip=a6VEF%4~Q zBb4U(irk>rZSzuYRN;iy~^%m&+cX#vQAS~l{+&xUIbq@$`0^kN# zW)J;%vFYZefI;ljlSgkY^HNmDt_R`^dc4@}_VY4_0AqhyYEjKC)+`*WEyL;}5F_N&^?6#R zCBOCf(do3aO6zrZILs0QGHTIfDKSunB0=`2e7#z&h6LutK~;CtVZC03E@~-SG%%E+ z6qu?XO3f7pq)aXdq3dp5-gS|?emoxb4vt7mK2>v_=bVp@R2G#;u7b!vz6g=A5t!es z>Q&9`Cks7(e3@Hb3NWf!*Qczdi+vOZfa{CRw9JNt%oM_Do=i)v5CZq9mk>;g0df>? z*;@p2OIJ@aU_r`A3u5d>aA$^Mp-zY5`ugUk?*m|3mZ{FiX}>Qu_kBNXFE6hjee2^t z-S3XMl)j6_^~u%cul!5j{PuUh+jl8-F{K}_F2%k}&g6gwWPpEWIUu>0Qdy)qpi0dl zC3IUfGf^$o4Om!2s;auRKI1?H2-R%Ki)j&IiO~ScGE0gr6K`fjKqP9GbB-~%dCrPx z=Vm)SCt%&Yl*~laG@n`S=<_mneV21?VObF&76*t)N>OweSF8KofeE@krhZ^LPX?yb zA$FbS()ID>tNRp)B}Ed7EF4no%d(W5wU(>L*VD2zU@sG$=0l%GaLA>+_2ikk?e_Qg z_d9U!yUq<&t(p>X0Ky-t9XPa610y;?Ez9w67orr^?RNd*`6uphd;2K>JbC=q z>3EvUG|#iS55qu_UVP`1i|fbJwCwi}h`buQ5PL!?bq42UIs!(sdYq3j_NU_{5r=L) z&yy3Nt5)q|V&uT`mskAMH$fAR-^^2fh_as6nwzrTI;@~dC_ zdI(~r9*&2h>#r|2zw^8Q{2%{s|M2}^`sJtZf3V$*cb|P$FI zsr3Eu`t>cD&BuwPE4l z`*BrEb$~L>5~G<@@!c1Q1z-&a|SR^3?`0%#A*cNX+C_t5zaL;3iH4VN=zjNRZMH zW5PB-5drs7YDyilSj`T`B;M)`+C-0d*iEj_dVhqfT&;cB-s-c5X)xMnK`s&lNsuc6fdd#Z62yWc*|IH(B3mT8*?s2o4tuDowVojt zYo8WLO$cD*MO~am1Ksc0*t>SE=lTDCKN7C3W+}d^JGichoW`VqW{&73(P>$7E*DwM zf@Gvp{+IvupM3py{)-Pj{>E-hr@Pak*M-9wB)l!BV{01bL=X`?WKb`8k}PlD-3`;& zYRwt`^xuBUX}Ejw#iDd`y*(U{wZb<(yngxe?W3!rEdR-OKKbW=^n>H=s~>#&<*)t9 zFD&!w4uIhR=s^fQ*8|X7IS}aYAwS^YBm@EAmL&m@$BNi(hYkVQxm9K!PAJ$B+dvSG zlA#CsdQArVpg)92MEVdc05H6@+BXUWi07q2c-Ywx7;0t#z$A!pI-Q`?6{ur5wW+VI z5@BeyICE0Q%`}eVysT=L%V65vE$956bCno*S=PgG4)B~)hah*D12Yk`l=9VL5_A6Q z;j-4|rca(ey1PHL2F-j(a+>G1SYl|k0^xC8r_Ht$-tSicKc1E{jOKW;EAHX7wq+is zt(4M_%6+5oXNghJRcu)t>TX?wZOCrYJ@@**6G!oyVO(=p}JCqA4~$_0tS!mM@EED>$5u9xN1mSwJU1WcQ& z`@6T#zxS`6ee)Nmi<{5>&A%+$%?IE44MrghN;$#_nVGLX`lJt)dZ=(1(>hlc42Ljf z5&)>Rd9Ajtc-D?_KzKk?4{)>C?l#&~Bzu_T%`lD;;I7(NBP`>%8+N-h923-P3wIQ9 zHPyB*b6s1w3D=0O6pSy`1kko z6?gTo`wDsAfkkW0yx-!SQ+eN1Am|7-Ven9`$P(eIN+N{h{UOL20deo*y#L=36P%YF zXd2An;b5RzBdk}I`bQl)HqV_zSkkn;z&_hvm!HB5fxEk^X(c280;cngEY7tFa0>`T zkR;w5!X4kspWc&*5WMfU0VzC)387Ek)LgBL1P~azydeMr1E%e+u5+Ci)hft0U;F6$ z|K<;u)8RM&;eS=OTL%BX{@4HU@rU2I`QRh(O)GZ-xOw(r%1NYbu5KWL2v`aeyS3x} zo$AWW-Q&5gtC|r>&I1sqA=O&lfSD0F!kCezn7JeezyN5qf{VMgw$ynkxiFti65}}b zfpw2UGP9W?NzS>y;%XYTMJT5X26bIu|Kx}F?_O`V7t!}^?kOiz0|Zk;ktEr?npvO8 zM0i`*E{z9706N^iTbC0$kYr?;F0MpUAOcdTt?P`4G7RBR*F|#5skl3nn7O&TYS$kT zk%dQ(1`%<}d6?XET^9!GqF?Hpzs`!5d?wg1;kl0Eb)Ex)C55}>%>4}<*s(aoEGZ$O zsUyO)yGps3HgD?g0PgBYluH35H^*@B2qHva7H|tB=wv*IR#(*qz<>Vf%e(!0cYpei z|IvT5zkA-+Ra;9bL!h|=a>^xy1tLfQh>4iM&gY&^+7n3`3Ej`HNrVBCNa}GVaMQYW zwmuN_CTF;BZ;9O}}v&VZOx0U}#&TmZP)yE&*?CZKe9D`Ey2O%>=mMo!ba}!GLibPBlNFKJHj$t7rO;CM*b4>(Y~r>Wx5LD-Qz!xLe6Z!b+rPkq%PV z+M*c>r81ZrFbxl2xTg%fn zz`a#U(tpL%>A)DZ*3=1j>QaXD_MO0*YXpUdHqNQF*0nfp222c4tFlm-iU=}ik+!Z( zA|)-yBVfuogPVh6a6|(L?Q0^}>e_%Ql`@n8iCb;0HPCQ^&=v?HLIA0hlm|`;2u*7M zh55QxZ3^U)O3KBp^>CGgrZSQgjPTap-98*{Z~y*xz78xG;@|u1c6W1S4rWFGGL*kY zdyAZ8y14w`{^@@=O@)|0`Q(#}i;IiPOGgSMU`7#2SxWx?_x^0$3_T$q5GChzT`#v= z5!!Bd+s(ytyuUvk(Q(=gAAR)kyTkpHXJ0#>_S)**yE_MK+GQ&Al>>l?pTBsawXVy$ zF3bCCUgxExygwZ;uP%G*be&I}OJW*_jbyI#{MnB`fBfuOM3~wz6sXQZoTTrQ83lmw zZ@UPIDP_rj`sokREDgh7#83WGKIX3m0RcQ5j@!+qSxuZelaobQa;*!qsH?k|G+bO< zi%?>r#DC}8-^ryU3%~ox2R9$Cgdab-Sqx9d{lEVHzZ)g5%j)QX60VU*kOpBeHwZ#z z%8~_`ADaH&zy2dh@;kr$i_b1DuCF!&AtTn)emxvqm#b;|=68SDB!B+BKRet%9Pb~F zZRznlKvs)Pcxo##Gb4N4Rz2K51mU`@5g`(7p%!(1c$>!p9)vzk!*Q+*vDs~OsYnE7 zl-bn?0)@wMb2?P7-l8^bWHF|)=*mu#`7|HOR5GOq1ty5t-@Y8jn|YZT?cx3{fLE>e zcW`2^b{NX#s#VS13<5A{ySuW8r5LBst~7 z{%9IzZu-|=YEDS~xhMceDN>k-ipZnuty;{-rPijkW=?Cfsx^YmPGc74TEoLxKXpBO^60~7Pv5+KD?~kI`Ij$D?5gf2 zNvdjH*N9*dK}wRB)_^eOR8mqi66T=oZZZo)u-X`ra)IEw&JZCvw`J)0m1@cv)!)CA|;n3j~_iwr3`tvxxPwC+*=};rY#E(!}#dt zsp@jIn=t6|^6GfFABPcB8VVrdT;b=0wlthmm@>EytybtX|-<0VcL$5A3eUjzWMSepSwnL z-EOA3uJf`Ivp4$kix)`v_SKtjeDm+T{PKk(WG*S^{qZ2gi8GNM_j8@=?)svxEf-8_ z+FtIOw$pwuDRUaM&C~W`e|OJW=J`lSWf~GPF~1+0AxbpU<+QZc{z?V(Uw84>Kl5y-o%8%Ze*#hU_A4}aIUQZ_o zu-42K0EiNV*SgqRIVToj5>CRLFo3e8G9hu#2xCB;XGdr7LJv5cF#-@j4Q4j$xMv11 zA_59Rasa@v1q9h@ta5D#@U`gj8ED;l%wYt{*{oBoUH*I(Bo=e_b zJ-&bSqD)&NcT;A5c=x6*tv{-U2e?y`7tepV*<6}d6d@)vEoV#$XshACNZzVxqm!%LZ=uJ5g}6|0mRm7n0DSvgaKm8#RI|>fWRDuI2A#zb>WhGCJK>F)!NE{>wMyr zCCPTPeewF$TJ_@M^7sGvi$DDR|NX!GumACz7cakfdpv+Vd9>v~1R;(DTy(Mh$1Z|F<{c6AR-+CN_Qh2Ly?%HCkPS(4p0~|KoC%*#liRi8zH51 zBmM0E?6ddxi|x9v^E{8^{2n<=xyhM`POY0%rW`HJ;(Jk)%7!^66w)ou z&fb3ZZCB7RO~;F-$ba(-Mf_6*7Lrl_;?=|U|LhbWe_JY(s$FB6xlc%if{evu0cq=O zq;I8cjq;Yq!YH&zNSdr6felQ8F8v~|R@Jy;9mNEnmGmpGE$CPzn?>yZ zaj(RdE`oKXyqH4e#?L)-ri=MP37DOY)(EPRZrVAIpnD_%6ZS4cr7}mDGeYOLcgo-H zObk=z2kRIu2VQ+a9jPtZE7?6tqI&E{TaDZ~6tUtU0EecYuQ)Fp84EIT0WyoZkvs(e zj5ewyR0i(q%|!X}yK$ym)GWRL^dnuSnAU>3%uP}{J&^FTuR2CvZO!33@zFwP9xV%Wt${7Si;V#^)Bi{@YW2Z9|c(`lKr9fCLjh9Gy zLo;SI^vHVJ(AtS@n=l_MBBJ+W_bQM2S>$rBqL9N(G_wq1ANnvE`_;ntyvPy&;FR_Q zB~=EGv7BFpM4Loj9Q#+~Q^kST<#Ot?_Z^ zJ9G+9OGxP;dAp5iwI=W)PlSQW;6`?%xckA`>&byI0J&ca)%Aj3)Xc2Lcagap=u zcFw0Ka!k|!z%`ZIb$;~=a&<5T6EQ858oUlbn(jJ>HVxsH;rRjg=Cz0n!iOZW`L9Y3`^A_!DUE)6VDXE!Fw+l<9|H-loQ>DLz45x zn$1J*P5cCQ85)gt4+Tj4OcnsNAI8UOz{p8)=VR%vGaogh`S-ry5vd;zV8C2cNs-)p zPwtnbmG3tqLL2xx7vz$3tl5Dvuo^z(>B6AlW@jD;rEs5U6;L_PY6__kO;_;Q;?CaD zu_x8=DR4W14LczoZ!5@G69m{9WNDbZs;vZ)7&~FC2`aVqQhvh;i_5OMP_!?U>l^E$K2Klh6+zbn|OeSG!F@~Zya%3$+7KYiEXu>(qyz*K%!{52_fOl7i; z#J4I9E^3<`t?1GGstBzD8Pt2}=e{zlT?3?0fn>D{nK#w>-4{khd#U1M(T`jZX=%iO=Zv8xGthU@+Mj*gq&2bonl@-f2;IN z;|5n?<{*|&COPkVHs=1aM3pA%x+w#wZ_1qgbw)){sa zAy->pBTC?+@8Lm;T?NZ~^k6EmmRf*J=PCDU@4J2_Fz?OsG8Xq6Vp)z*SD)KZ9fxR` zoCi{h#af{(irqgzq55@hULvEA_w1&S_w=vAne{75uNQvzh=3v20VRjRo%Z+>#s*Ic z872B;E5u^jrvIW&o&T`6dp=YdW86#FQ7keZh_qTJ%*)w(*Q~fqddg!y=aq?{F2w43 z*GNc8NX)i{Syl_bukxyJ<7pDttOkYZa1 z%{Q?qs7~%CH;{2IRGFCnh@oeT+AumtkBilzHMjf|yN&s}j;KhjB*F4|YG1Awmqr$# z7^(BW?9sU*(r<_}FO&wHJE@~?Y3^CX#tgH2S`;uddpxF0Lm(R9dORCREa4F`UX6JhwB z;1DM+9$-sy=apcqp!=HPq(-u}i-e<%ZkGpI<@nu1rn0RbGz=5h1KZeH%s~l+HV&qg zt;UIp?t)^QcOWnwRF^Tt>cJ}AtrnYKRv9s;#43d>Occ#nehAZboiv!=w*4c~0 z4L_wxQ;+&>;@L#hQfu$|yrY^_ydo*z=7v9$zeAtqhYVAcLamUuPe)t$K8qBj^c&wx zpl|+~RZe&JdEKNG9~`i+YrSuMBIO;v-(q6i;qEd~COtaq$^0kt<~zZ;rmEM86^^j^ zA;mnLtI>GO^HHLv7c01(N3z$EdY>#8#K-ap#LU6qf|K9|FsrDvfHkEh1Bb`zgeqGEya_6jBoDeLNjP5s0PnBa^iX1Sj_jZ+Cn;#jm zQwaeC`M9b_xS8K>0X@Vj*9K7Yg}ezP&2FvXvrV(ZjKmWEn&RYNBOU)Ek!M=3NskOL zT0(u*hAV=0d_5>Tln4G*B7Jgfl`z`oX3|@t{FQyAhA&TW)t=6X+Mvsi!B#R%ytSYj z9Ja9XtjO-e1cOY>S4(_K1tH7RY7s zXS)2Lb(k{k=g!F~7;0Q}F23)aPmd7Xql8I(S4msA2>mx4(h+gGI#hdk=)>0iZ`=2% zPocvL8%3FEn01|>i`CiMstqrMDi_+k=2;2D22ny<(97pvzosPWWxH7B@Pb#TvdhZR z1#3Hjx-zAhH;b?`mN)kodM;;ce4@@+SMy4X@VR-G_^m{}nYO6D%E;54sIX|o#>Z<@ zNvQ0g<8JkT=ONh0bM7ytLqE!*8bjN# zW}IZi&{4r&q2~?9d*EC^2$$?yw#635&Gi_`PvP`6!RwIbJa-+X>-BYj;4WF3INS{v zDcqmG&$!AJ1qlpf4h}&gwQ)L=VO>)z#`HVRL7RWCBKhs2Y89Z7VSg`uAh> z`XhtR#~#+kSJE&6!`QpDnhCF}b?hTgROL=Dw$6*vzZ`o()!HJ$4)#;zMWMsIk194q zps^T%;1t;as0Kol>jr(P%UdJWE(3`{r7n_+RmRWLN7V8PgsPweAW+InDT{FN2TT8( zw_adsY8A{=OiXedbU|pdK^CV7{Q&CH0sdI@aXh==<#*Ba8nxqApTg+F9R`yxN3IuB zL+0R?j%WZ?h%Ngbc};Td*DC&x)f?YiN}cS<<_D;T)Z}I;ZvSs*QOSE z?vZ|Z#-M)ouR!SS@>1yY^di;M4f}uFhYpfl`=IE^+$yGYP+g(hgLJj`~&h90W-RM^!? zQ?{55rOz|xD*mh5w*8j@e3Y3A`GPtg{_82C_f5@dF-zB2z|NF-#TCH?IXVa4B#9xK z1pG%`70DM082~r0+jNS|G@@c*{P3?d4K;$qsVX9o2plALjT=3DS)F8+dk059D)oah zpQ!Y%z$8Diz`mj;bUS{TVP(^tD`yg%9s+m|SS34Bkd-|$X)bERVyyGTwO#V!SLD=~ z?R6EXm2IGHD^)I%rfZO7Xl=b>7L(&BYdkH%$reN)M)dw?DTOF_HPGE1uVdiGqtN~!TI?%(v9rt9+YH!3nz1&Z1QPQ}qF63r-!EIou>o7H_YD12D zg7{^@8q?9a$4S@uH`G~8%N80pV|IM`BJpBG3tEqaZ0-av)G{%sPc!}zZBVOG@quP! z{+PD1cG07nCoU88ru$I{j(wbR+~T_T3-`&VbunPJ%^BgRwp2o3;0N4&_H^Ov!WA{| zM0=!U;Rqc##OY6j`@UMSNZ&bk&48yXO7?fe2RhS{Tk$QH1S?8jq&5PYavzq}na1sZ zWA&B*QZRV`Ak=0>X^91nYQ8I*9CXmbQe3fs32?6#rVCAQOJEeGen61ALkQ+ivYMEh zlJnYCY(L%|*!X4+0ag(Cs6A_H?iKL?zOquQULn1^oz5%$uCn!Bs2rWgRNhmtoslKJ zJTszp;5wzhtg@DzTb4nilHCkZmDWfo5Ck0*$S{AK$n#JOYsGiMkR8C)*M%nHi7w=I zi3&%Kw4u$CTIRH)tuEnQGcHX?+VfFs=lKl(VpwvBkKM&$@4$}pR3kU{^neE{(C-B& zvgeAsxIoZrHox#@p>naM;x{;OAO^w2R4N$VgP7)+rC1b_Gtf$(_I@QTOF zmKa3D`S%-2Ns87XkwKP3t3+gg+Q*Im)=NJ{ANccs??LItAd%&cC8Xk3(i`Q$yf?7S zuxMS&2d0-_0q2e#9@qhf-f*OPnHW^)-23d4GcB~I>W&M&11*d11id%-dxGlxa&YFBT;`9Y9x!I&ODEH8{)LBUF)k{ zsdUF)EVkQ0M?IQtH3c2!NkX{^tR;qtru4Lqn~%O@^o`4iSpjTK50-kY;(3zXuA@3T zNngjP#%|Fk6g0Vd?Ety7VfDndcm(O1#WUJ4NwEa~+2Sf{r~wCu!rFx)Y~AQO{3m6Z z5a$}RfANoc4w29mn-2k+-mKXt_#nKOL>&FY3?+m03{RwT26G2e*CwnyOu@C zFjYLYN6$Y54xxMMMCE8^I}KG55&N+?)O|(n0Z$@_h;vV86dTHhMD{G3i-GUU7<;om zu)0?qfz8Szy9?5nI!J143TBPi85SE$A@m;t{-23T3g&^YGG2K^HYp?>d{WfQK1Fc*I3c3X_jQEqSh6*=4U zyyJ55+g{TigT?!l{V%w@yjJ(u_1rtpYJ6$B95GQx(HBB+ZgVW9zQ)yfSbJEHJh;FU z@il~oNt<;Fl+a&Ug+#7h`#imA_#!_^c;)Y|lagSAJnu^gOMw8`-4>RUJUszGwtNiI zRyo3je+4tnw&8<pka#wdgZox_n5bt4|@_=l6u)7SBd+@$tzvlQuv2GOth2MH>Dn zV-de&m~-{X=TaA2YCjNL-(VYWi2BJ+dbUei%vR*7HCF6hZ7j=Zx->C+A(A?TSqI1l ziz$0s@Kxid)xsC%XIHefSd8(F7PWRf|K#itkAf7eyA8xz8V@cu4+s@PC>@~MdU_rw z^{1bkCwapWfX1Ig<%3@BBs)$ez#Cm0UpWr|sq_p%T_0xKNYE}Ix+0muBfZIJ9hw$= zo63-Z)0h;uB+ND^|XGpJHN;Id`aNwXV5#QfH!4%jQpOQf(F77Er`5i;*Lbk}O#XXhHihklboN^GDN2B-B z1D&7K;x*7{y(hU%F55`Ut58rFHb7WhudzVDv=mJf6N`;TomO_O?<^Ex%A9$VWYU(T zCc4ShwdzsfI{s}h-om5-P}T6=_4<)$(y9teUYBIK5yzJ{(%a?x?=AOS+C>Kwe#dTk z3(d@I3aR5`>N7xq5}op>{mB(of@_s}z+JO(n7_*KoFJD9vdZc;rWfse>04XgmD}rR zd;3YxFy(ZXdaM%*HMrnez%_aP;V#f$#ACeu5n zR9&kXdsYP+!0+BoTCv+th+&r50F|MNAnfUauq-s8F*xEVxPJ1*$@?M_$;MVa9Ochp zeALuL+oKn?J6WV2afnM!wq9;f;a6yVZ3TG1MOy;=y*I(YF|cAEd9kDL<>pB$vJ*j- zUJ@?vGRWgDNB$-Y->uEeQX#`2ETz)d>^f^|5s$L-qH2t8zVxX1pN0Qo^YCC`<#JyA zOlNw7?JLzJmP+w{1)+E0AZuSmwMz ze-$@mg>>H097$0%rYhV636l8`KLC!KL6)}Hm}yL7TJqhVmdbc7pU>DD;o?boEk()G z_;3V)e)Ltb@Ky_aM=kCO8Sd=vJ}<0^s2q{`s)ftLNtuXT_pfGdrje!pAjYvIEbI5| zn2v)gf1G0MYLpPAWoHK|Z3rc_Sfom8n&LwbsnQ7tg!DrnJL>s5a+V5joG!FS#?$7wZ}K`d^WK*g)# z)H+SId*&O`+;NvRQ*J{->f}>>%Qd(n?e&p0RK~!gn_zsHqMsUR!)LbbJg4K-B>JG~ z^5WUnYVFx?PPZVQPv-VHlSY;|bt%rQ)M*uOh-b7-@trlltxj$W?lu3j`mOVSfw{cJ zjdMNjps$)ZF}9Q%L0j#a$dkzdui~bn7x?xsZU5Pt;{db`sBh$ns%O=%2nO%w#FoQ{ z5pW1pgMA`SM|3n|79sqmRaBE@J+^Zjj_w?$3tsFIhi&a;r=oge{#;wfPsw@5DHbV| zG4d++!vHrKF|4$Lf_#o%i9oMAkESDSvN^R$8|ew1l=sw&!^KfY%kORl3Fa2qp+SA# z2xYaLMYthPOuX|R7aNSS%$5D8qa#m&t`ucDJA1UG`nv3rMpLoxV2L6ICl{kJj<&=q zP=-Wp`RO!+S>m>PW^RFdpG`sG^3{j(iDLXp`R>Lp0YRC`uXTehn&@9ZIYx=ASZd$A zBpE|Qi51Q**#Yt}Ax@`Xgq4${u~A!=oj}Ye!>&nr8}Cu>-I!8r)nnUAj0hdD3@NqKkn1HD`K+4=W8#8~01)TipE67{;%DwzuCuom*hcI8(voPj|IS$}>$hP>)Qx+;L@onlRdD&;VE$ z{&9fW-lIk>JuVG#@kbU~NHk2E+Ce`~m0fTq#C)cAK#aX?QQXS92t{$_mZ1ll#l(W9 zz*0IUJ5OXM(4R|5jyGcd8!$f)`<{QAC*44eFuUHfxiKil$&mv8=dS_}g@jBDxK8;R z>;76@cl8$Zj>#--wxp$}d)iwOT6Fbkj5hQ3W*tt7KEdt-^%fCtJofMw^~nUys1ok0Ww*6P+galH80= zjdHWREsF;MJ26!6YwmX89_#U@D19oWfcxJ1u!}7P-MwL7U82+bTliILY+g%iwQjcK z`wFePn62e_=l=PZL8HnVI2hYvH6X48E;x0=lYmsvHDi3 z_ZdJ=X5sgFPvQDv%;~LnLTiQb`5{$rLiEccVx$=%pBFLywE5MRXvb8zS&#xQJ5T7v zc7w#8%m_Dk4#9i6ir$pga3MxKXgo*>Oa+!V_l-V1d(|ZQ1^(NuwKe?2lSh7#5t%E( zP9yARJg*DX4ZJ)I;#H{0PwK*i-zvI~=o!r5jeW=Y*j)AJ#tTT3!gb|*CQnPQZKN+` zv!}xM^@Ap02rUXK_;5nWk2>`WqknoQ#MN0C5b}(L);Y5#2BiYo*LvuIy&pQ<*VUy; zn);k;$tz08_E#1VoKd}$N!J>t1Dp1LO#pewGW(VuZ`_90Z9_I&n^aimN~=J_ZVvOl z_e;>SoK$`ZmgcaRF&!Vm!f2C#*Yzqe&-wsQ*7zu1BCgj;R57JvoI_ainEz~Tq(z;7 zxq{NhEOI-4Og&1F4rjU}U0-?d+lp)Rf|)%~fr|>LU@n_5Qy%E!N(5Zk_s=X%G~Vgh zI%)sT6EJ-6Uu}Rf*}|M0KAGmX4$_I$g=hTIeJ(uJ@aq*KUOgr{PE7z74!=&@2L&-E zq|&~ALVK@V(=*41Top0mQB;3qm#(zJ)4}lilkudB1@EW3fmSP?Z`&uV0@9AJ&2FvG z2sTR?U_D$dvqi2tIs=({0EVS4@0)U|cp1Tod*5&lQ^;uUN?-xCIjlY-M?J$O+>7rX4CVD^O3$8pbbDKNxw-&%M2<+sa|f1z?SXOxJ8 z^V;as$(*BJ++%BQbM7ytg92Zx)kq!rCKZl6pwW_~r`8t5zVVM>aS6HpalR~%a4=wO zjAPJ7c@c~eFz)e$rbH!ek3c2-Xia1`_NKVtsFm#a;|ZzjdUL|4@MZOUnqqr4Ia_Sv zabnqbmbY0e#aQhpfct&<^7jWbG?PWyjIo+yc!5vji!M(p?)Z$J&NkK|9&=}5U zDz@$zw$;}##`*}|;V%;Nkd{(R@&>LpD}ndZn-ejETh|c{&o$#Pp0@6)IdU!ciiJ#) zQFNAo2S)czxu1T(Nd<-U{SIPlYJBugS1gkz1+(1kuQ)iM#HuBzO^pD1ywpt{9jkB) zG!NSFl%rc=XG%cRif07GOh(oiY$&z*-VNfw`1f_o*={II-$wX24*Zo9N<%;@pXa!N zJ!~yeEy-d1B4dvk*ct2}a)3XyS{aFXy4ld*cv;tz@}#Y?{4T&CyEqlue{-(Tl4Ued zV1Vb!qQlSo->Oz#0>wm~Zo~w=oxo8er&jOkD!wX%5s3i7a*gZ!jQrG|Q$EwCLsNhM zW&ro3o=85Z0P@!NOt@I&zF%wlG}%$W(|C>tB=I!Dn;#m5l-!VFhj+NZsm3jS8}USREy|AboAJV=iP zUZL``J<;m5w*e=p7`I+-bez`K`uHRd)v!FhxL>{aiJ1MFUr=akQ%zs%mQqJVXmd+@ z_jWaT`Q%t<%dW#~CJ_5P7R5so51!xo%LuA)b1L=YNtW5aOK~$9Q_^dB{cq{*7THgd zEBv0iq87J9-#N4U2vS0|dFY)V)()-z^*!5|y(p;t5{1J&yCMPe#-{fDi{t;7IQPEj zj+3F@#W(h79+1}XTZ4BVS@W9DM0$!Y{`Fc|Ohjkv9EX8^-c+eR6qt*uFY64;^QrZw zDPD|J5$YYfaXo7HZ^%nfb576R-?sdT?K%KG@CL-|hL}dKFrefvT|&(;53;@#5T2h7 zY~X#FS^!N27i?@EoSzq*hEQ#{k94?jv3&)zr6Ij4lMtizB4hb2@s_l9>~a)rBe z8*1pK0rr$qe#yfA&OpkOv5!E3bkMOK zqe7JU*}D}X8Sd{<@V9xxD@)5K!`-}E9IfW819Uuz|JByk5`z+B%B=RnLzSs?^p?)M z7aGW(y?P+AGPJX0RsNUu=;+IfjqdKR)Q=|o_|hxFWOs))%=a1xtM3ja*2r_#>*gz; z%OpshsaVugyt4tyZwrle=A{QWYm#%VjXo)-)2b}v@&Px>?EFy<@nqeSDHSs^2e~h}Z#Kc4@4OC*IsBAz{%&{wte{_l>yL5Xi0t6o<>t$F#U+#;lgs4Uumf6(yb#ebeNQ^)Y@FL(O|7kc#>=PBmUC3af?C$Fii;nZbR$(TB3XEeO~++T7VqpdMp} zu4%3Db^4g(`x10>zf*6(>(kEYfTC!%%nG<32WT{v*4kqrlFbA287W1uvap@l+i@#g zacea&&4{aG(C#Bg407?3<=CHA8?CvQqf8;qRgEHm7M*o+tGRgA=bC}zPzb$3mP{QG zDp({qoX-A(G=0+I?Cgh(QozmpM63sh!~pBzJp=Z@5El;DnkvITa|3_H^@dmWj{kmb zow@T7_mT>okZ}jYV~s_Ki&;{_?NA&LCWGPb@Ng$>fHpWrs@{>mVq-iq+^OU^lmaI1 zJyIA^zkg%+h4y#ULw~kcE^7M5y0p6U^p4nZ6tgsqLqmRV=FKCa;u`EYpI{JnCG26k z8wM~J8R_)bN|(D2*XT%64E^7@POtQFkUcT1ZxAo>XXcT@sZlP+ZfkM`*2{KU?uPdC z`}42qUqZvrR}ZacFBPH}?!|8(9M}oiIPeE=CaFO3Ju={ZybS{ECTtnWp9|9`nnp%U zOcov$3YySb$w%DaC>mJ_s9qb|d*;HgaAo!jFYiJK1x~;MD2l$g6Ex%5I6!Fx3fxqR zatvYxV^U}y76>Xw3PFa#m_p6b5bQO_@(mkIy*NX-fU!MqGCXQzNm zq#?c#>7>aAOw29azdq)W@FByRLs#BE`d z1M%fiC}s{Ib%bH77F?-2P3ZxvyxnRu^z4RE-63~tYlQBwI0r!U!T5JK1M$HwsESdJ ztikWcUb(w_DX)=13=Umi!cJ(S3Sumj?f?pLB55(X+R-_$rC&3I^Sol~ae z*&u=82w+NW#28%#f|35qu(>&+RW(8;)vVvr=qru-KRzgQWd`=ASDCA(rcrza$@Bfw zbO9AmPv5xwYKkcr_AUhWDNmY_2_I&YaT|&3R^0F|5-C286bw0~L?tSkt_+3-s+m|1 z3!dZN30g{-vp<<2vZvsW#=)O~qVzrJHxAT|k6tQEL4@^CzRB?4Y(K5Rpv?Az*FTpm zQVb1KK`2y}h@Mzh@s$uS+-F~>b;D;~@FssnkQe;P z_d(cvu(AsO=4{nuQ}p&)w=3ac!e)m5@WO-Ln4SW%S{EQDV@mlIg~xY8)9LG<-+UA= zH>#z@(wckEp+pY->KPFqbK>;s&mB+j-zOD7ACDjgcmvSU2|TW>F2H{!10l1*Kkq<4 z4+;kRMnLMT^Q#wsbwpzgtcm!KC^{Lm+C4?jV1*!C9M1T& zd%%6)IES9S(+DSxF4LFt8_#=t#vTpDCaQ;8PLd7pN|8F>dz9q@@BR4Dt3w*>ju6f& z6Fuh+F)4#_y@NZ+hM3VhYb=i?I|)(|#igi0;>w+TPrW>%3v6D-BB>sZLqT+%%4_^m z?^|*RE$uf5@B%#csXl@^=&S(RujC7krLs`8 z*Rz9&jns48l=bh^>S>p#k2qH@SDyhlTVfb?_T+U(5U!|XJixZbyM`@!Vca|a`$s{m z+svEZTl}1{pIE{$0O@qjeGb}8g&~47D^(kdS-(?EI(z!SRNIio+3&;E%ZtA5>e);C z!={N9$%_MfO0MOFPgK;Aj=eg+Ae;MLRxNd2%56&dk9C_Rye_bnm?S5dhQx$5RX|#A zORvb}^J#@vV-Nz<_?iJ~jlt*TR7vzkcPc!wg(D{Ad;l>QXW>!;q5F9I=hd&!z)9|w zH$W(!FPJCwDS-(z*PaCaaYfLvze~IiEBuhqC?U&Hv*#8SzM6lPRt^W??CW7Pq!~3- z5~Y7^pW~tz274*4i4hXo6j?%UV&BE^^p8EfgDAn_w*6%FZp9fU7*lviih4VZjfBC$ zuLw4-8hoQwKw*rH(e-zwnkWz;5BOY7Rl4NqJ1Eqz9}uO+Z#FFMxlF~98ivX3xlRh? zS4i+x6Ij{Hyh(H+5>3UrpR|qJB!w3y3$INH3T~R`?ESss?#45ywQ@Bv+07lhWa`h` zhLiCg8q;Ka18gPY#p5y%EWZ2-;v7>AO3c*$)pt6p$MNF2=#=ahC&eRjFf-U@;%Y`) zjnOqu$cdj?7KZ7KuBH@LV{SF;eiyj!4k+`^t&#+J*T=Sbh;GI@qRUOXy6#Ew91QP$ z5csaAY?|28QiF=Bs^8WT0}-btIHDAw&q&pbtQj9N=&tp}rH1lIwamTgQ0LDK96%0;WkfyydR>W8A(!7W#uolroWFYx)Ara18y?LM`_ zn^M%1+&H<&+{Q2ri1EW#<~tTn4oC{paQa2IXL)kPQD=`>Vwm+xje>#OkCw4U!2Rcs zu)G^STK69SdMr+`=M(HW(F_2(36 zINIzcXmq0lbaGtg8vY{U=wgTbDqRh`c05#|aC$y2=Oq=`G>O_)@ZKye6l}Y7_?(W1 zy&(MVBBg;s7Qr0WEkyzXRSYB^B^#{Vk723Ihn#_ z+ZlJg+}y#^C1CB(7Z3c@W=Q1yhvkqZ3`FjsFr50tyx z0|3-)ZAP6eaZ@@v^=SwEJ#aM0WCy0wL=Q6KT?v{rx^{!MzP96H^<*_zmUX^ycFUjF zZl*(X5f+bo45aB&VR5kkk3@7ohYGoOW|+N1eqdrr-ectLb=2+tw zZNF1l9c!#GQQ$abYcz4>6Fu01+!nf2SO46|(xOQJCUrp$ZRCMnEFGFCCrAwiCB;w( zg+r9R==Oikc8?JjgrSB{jr6Hc^?JLdbEV+GmLI3drwj9}kSt+^1^gH~K+rPC(qhOh zA~HOu5)$jI^rfiQ+gm8T_wnl(;2Woy_{9dys-oe_LGJG3pQmn3c?l>3TL* z!l$aYCM!8Ub{#KH0i*i;vuEpXRz`d(q-{5R3}z^Pzasf*sj1EKJ-l>_k^Ms#+G|~%Nh>?!%weWey1>7z;dP^UOh20uEdMdYCZ~Zm-iGE z4L?{NmoxIP1z?cLJK<^qH8q9U10WcrHgR_;ZaYV?KWdblPWshZv~$^{A>*f4y@PkM zFsAhB1=U6zYJXI2@l=06N5)n6QVml7-F}nJpL&RM03>3AdZwCid+oCri}@)vZIp$vk7z)uU!8 zBydYG?f<`&Hl;VcaF*wHa1+^6fe?JM=TT4gY%Eyl2Ag&qLBW){M|rrKARrFaFa_|H zwGqDgtg_l}L&3u~^X6cZ4E>Yg_y;m9fPC(6+Z%OMX}FpRg^@u4f$u{xh#*UXl#D4# z1&vN#H=mv9nDIW6L7SR-AxBkWq-||yF*$o-YI#;4puZ@Woki=$_~z#F$=`Xu`sr$l zNdZ97GoI)=!JPrdVx+aO$^#Ze#R3?Rr1BUWqR^D01nT(rMskMoa|Lteg6h{OOof8; zgTH@4U8m&3?S?uB)T4>R(OyZrwtwFXntT}lU0iH@7VpwvDHm2!Z|e|Zm=~|8aJiRe z(wjVCPdO$P_N+?WeN7`p6U0G@ehkJxVM!%_I7Nvy6`0)pnY`h>xjEC`BB@3FlCU6_ z^><-JZN_+7q1NstddT&3d3@lp2d}IYHXuu!_B<9Yk+Izo=N#06v*n6DwJyqWJTQy~+!w&kH7M0hH|S-au&MfuF@9CTg$diaS7*Okd)#N|1H zB6KgjP?Z{lRZ(sr-0J3u)e}RU;kDE!%bW(Ql0LbG={f{rvhdrkMvMtw0**1A zM+;29Jm@?}F z6G^++V=-cO- ztG#MBVT8Yb0|V+szxz$iY&3OTR-{+9pHd{j=>6Slq00eDNWUH0a?RKJp(xiKYA|z_@qAd$KWJ|7aEJ3eYfvFk0 zuf&Xvkr5ow@g>8#wJH5uKU7%5YKEwi{hW4jHGmpQgqYd$seUQ{e&Ef@z(GIk>xk)u zn>oJ*u{DB2KK3Mu%4t)aD)=tM1%@+O71VV#+$B^;5kU842hLw<%kD z^=QANe;015BYP^fy`nw9eyR-AVsYJe^Q3{;+#G0At%z;Gl}7hJ^EXKHkN+GU+BIR& zHGH%67Gdk0FKqu( zMm8~?ldZtE`ZnG`5VrGKUiK;Uoii13sB1iE?2LWx9}fgt_w!YfH=PXCqNP&lSgFkWN{8k%0~h-rVcSyN^Kf z2upQpb$541*rzFpz>LG(_da&`KRL`EFJ*S{hG zlJL9yyoh^6Fm9NySNYIjCLBT0*XOxvG^ywQb9CZCAiDOtISn*Rk%~p>Jm_R$Kg}C* z8+KV2jc4_{N+qqroeU!_*QFu(x8ctTfF>*Q>3=!~d4pF#V395@oPr4AW$D=T{V1^% z>ZiFnC30!4M1d)8x7;ID$udj^4QmROUIu^LHTprCn~FRiI>J&EtvsG{6?aQL`Kf3~ zZXEM*1Ry)h*Qx{|n?pl!BGf!!ph>b0ufMi_nMzxhyy0)K6z>)xW$*|Ictd=U_AZ=w#?zMX1nrL)t~`erYNpWB2(yW%;7s zzy;~+Md2kv(kT_nO2u*~wfDvT#re+8gQQXF!_&0}G6{ILb-5n0X{R#aqT(IB-7XY) zc=-3x8Y(4IcQ^Nq92Qt;P*~$_HjG%W;Q<%-uox!r&)eRMic&`RtiGH#S0#a{`B`ET zuy@DHjg-n%(!A`tvp`Bqo0{z7dxZEZV~dH@#hUJh_c1O?_Iv=^ay%vtOSJp8%Cr_# zh&89xbuz^fF3O0=HU>@SJRsxM13yx zV}fu{m&&1qO~i621P%fhl%I8QSFtgS!iZrZoptlSMEajAu9QQN`-B8m2MG%j<2CAVjmDUW(%ta9GwRdUteXB=~Yk{ajuB^52O? zq0hzs(DfB?CSXC5l_r7^pIeqnVaJ+WOq0hIHxI-3e`Q?$zI9*!6VcT8$Y++CQZb9r z$}*IyELLx@!GEf&iw2qi-*MEMYnjBW-RDn+>XkSWK-t2cUrpP$>B z74~OP^K^9zx2Z)OmP}G+?KyX;l?=>hJM&TW>`-r!oYE zc8dy17WbuCPuC-|r+0B`sn!NkUFU+0moP*>gElRBDmpRJ+Y$u-FMSk4Oq5guf_ zgq?0;bzOH|f(X~&z_JN{n>)S;^f!MzxF%`mS$l{bd1Y);uyGZxBN3aNC5(FNcW6RKypgRNmS#zCJx~t_ilY-;$SXcxx0NGcNp$FWE3mSzQ%$gZZ9Xd&^YxmDoYO z=@c`!`IQAFKm5#W$`x-9>vG3?lGTf)27Ac!V1_y#WYxye8+nG#AlyRa%`mtp z7?e%I{D|6a_i;M_Mg?8gk!PlqO$g0Tm|3Z+hW@)QORY)c>kF@0)4PV5P-bnFLoeC% zR`Rp|A4O;4$n^im@nJD%8!Aa`GgrAsj^rGTToE!iS+U$#?xSH!!dLF1ax?cF8#zm1 zRE%jo*HM!{_sPf8MXx>-l;-=*-%G@o$BXCv%PUYIXwP-(r)#82q{z*P{nt zlUShap@|Hab^_ci$9^DJ+j{4X=R&R&lP7TmzJE9 z5=2krM@B&ZkKMwPNN&<_`^=i5OK^y*TOJZ7H8L_|CnF zzRI)I_VwSo7~=!|?x>Z#H)haZUCz{Wy!oru($#s!oNw#2U)_$_9RIKM1Nu(P$!6Vr z)bDk=%K@ot?>FrNBswY*fJ2g*iA-tZ?0xNnKTYLoJGRw) z+C@3%=Krqwt82ZXOx7!+A2v@31vEVeEPSt4oA&yK0<)yeeOLX(ZRgm0?o<0SF<}4` zGW~C5J12H4j9FTn^mZLg$8yXRy-4$Z$73LGceH*w=EUWV{XLQW(HHX=BrLVCb&|5g zpiule?p1AL8Y?1zzE_qO7oT{~%sJye(n4!!J-jjk0kNnr<`Ow@<_-q-c7bH}oZRVT z`r-#iPH?VLVNiC~EUS#wdCopL`O&p0I6(0h6ItG8meD9kew&p!;Tq)p~*ItXOXivOjY#b;9@z)g9kir@v+(kObmd4M+swS9G2Eo`8}nV`2Fom*GCSZ^*TSo?1++er?3@*t78 zq4NnMGd7##62~|Y_>-P$Tnu}>Ysu}LGc)AI^3ez$sIgHmx7N!_f}+$uy3e(2x%Q>O z*XkE}dPaPIulJK6`lJ(e-lJR4#iR2S|+Kil3W7#HI@v+@dUflWk!@C0MR`M$&sf!S- z+jiAW<*3|x<#+-p2%v_e9|#JY`m2w4N~iUQ&-@5I`B%gkY4VHKQA~Tf(*y?RwGeX4 zUXE<8tk|3An|{grUDeNjG5jGOT*b?l@_zW}C-T|iZ#TCU=7)sIIS76r(n_&nZ(>&X zTUr!K0dHS(S0{xWi6uU|vk`vtRb0j9DHzEh1ioZp!Z8V4>qLZPdys1PTp^o&MEmL35i z;m!izzAf5+oXNt1#NoEI!uU*ebMp0DI{4gFrk1s{Qv%>;a3e z&c}noK_>WRei#x z$+g>a>(@a2DH;+!PtYPFBKgd)s`vI!g0KC#47cHM=>i|!Kb9RBaS)2VxAt@j2!5#B zy6zus*XL+u@=6Y@Yu12lj+^D_>EneY{%4KXV8=-B)jVjs;uG?0`|Jc$j~hSfN!+Zd zS{>Neu+V);yH<#w^7fr_yfN78{&FFH*z|xwY296S`nvs*n8yWy$ZtkH*f+u_dkwdP zg1&C2Jcy07dsmrdiV)49LuH9H#b<@!`jHzx)s=~qWFlQAr-8H^6_p=qcg^$br>h{> zvv|mg?~4JJb+%P-VfqR^HEv@OAhSx{HbG&C*!)I+{>A%d889t0+G@SKFYe8*&1trN zP;xzi&wky3f|fDtCXWmxhhcDGx8j%()j9xt^%FHBJR#RgbS7fnimISu(*^Xp9T>y- ze$E@Ssrlq}2@|i8-x6;gXUu**%nl%Ev?0Y(_Fh-ok$;b;6$3zTkS+H79kOH2q-!Y# z;JKwndSyI-&IF|t6zFDWQIfC(_*LKdhZ)JKDGTZ>y1K}fH+w@+thXBq(khsVE%dwh^FHVJ=UFn_f8 zbnf_PSgV?X_R*iW{`B*w3lO&_Lxdg~;wh*2qoI6ciaanZMYTf)chR^DDLVkiK;)USXLCv)dD&C91Z3zAYX$+N(4N*-@(7)ZhA1Eb0 z9>B|zDBq!gwD$Aa1#n+4{vPEW@`-elpWj60?g)B~FiQdG0Y_v=4`yzb`Y zE{}9ijzJH3&r3#bQ{z^FH&*FU=@o|w5|O^%P#Z)X9IjrExtga6Kd!F~H5y42hu=7x zQ1--LUE+f{B)KyAp?e$-Cv&5k{NiaMH~9I;T{k8<@s(o|*%nYd3|Y@}^OTO&H!+e7dtODBiFLXpd`=qO5b^c7_J zoIs~mp)-4u7^*{k+i$3i@$_WurEZs;2Ird?BhwQo!u6mO4Q82O5Dw0O;c@sJg z6W$KlZ(F8iaeeZ(491FFS;tl(3 z94CYZ_Um3!ZyX2T`SgnG(K6AzegC+MG$H#=$ZI$nosmWOfebk9A0NrLH#>i6MP%nl zYh&f_11$nNHZI%tH9A?n#qn<^PaOE^z|uj~)K1;eEnOO_Vzd-zZ~P@)l)2IJcg&(k zuB01eAcXq45fK{_qNX5qy{43pax*6}U8vn){Wfc{$95~#n3YOWYKA?j-L6epPOh7O zb5&$sdnVRDa&nr+YX$)=_T3#lS+h7cv%bI@^{*#LvQet`vLf;&&aX=t)Bry9jRr}H zM~l!z5<9+H4f=A)m?jS-*AQ1u84^C+#G|b)ZFbZk0g=|o&f%N@;aL@bWjnxx6&RS} z+bT#)|Ey3(7Fv%bhaY>}z=7y_NO~7QeB*%+Zvxb?=(Z znyGQa1a3BP0&_dREp6;e{)&X!By4+woHjkn{0b*TRFggoJ2a>lpGRfP(ymL)m%Cvm zvTv9vgINSF+&g9PjhUdE+xERpK*-*(rO$@;=_lYTU}?;*L)EaGuymplP*Y?s?(51S zrr=p)%;p6#7=8UusJ;BtrwVm`E;IMTHlsLYjNxam43wVbxPBdYJ*hNblSwC+;C3`$ z4S1w_6;ef=YR=-mS-9GMUeL$$`3;%Un)c<)pdA~^esYh+lIcW^wLr{=-{m)kOe6oi zDg*Z_-d8Kw(hVY(o+*Liz0bOv_Nlnu{@r*XIiS!AI$0|o>K{g{w$KjYKMgVX10HFA zKrMRnSCK+;9L*V9*RmK3&Hwha>+g)WFB8Hy>zsDl!*nSZJ#AMv-!DYFP!Z;-(rb|% zI&M(B!+mQ62HAPSXQNaN!Rg zeA%kSIPhF6^(kzr-J+e-c@rMhpl4b?#$XSy+@mluiMfck9|h<#BdZ?!v-K0ZTM9=J^h4UFLd?H|*xyBr zv8gH$Bt>yKzGo-5Y8&)} zQxN6moQ;fQgDMwC;;4{hFW_~XAiMPkX;4{U5~75;Nx~;%nC%)@@y-~iUKeEj{9Ovf z=9%SfR^8J~50UCadFyYmz2GNo#SgtFfBa#zJB%Gq&0-jPe*f6+SR&b_!zKBRZ>l%1 zpzaXcWQt4G_X30S`Be-bTdZ$A>gFD{C*nJxuuJGC5D2h7~(*M2eNd(JuP@2^#t zH^=2Ce|K7KbwqlL-e^M}Bk%c8!Og;L{dz$Gz@IJhyKOZk=K2GMr<0d_O`q=9=|sg4 z50r|S9SPYmg%@4NzZD*q1cc3+KJ|0CPBr1bbNi9ZTH`Xb(qbPUT)zM4K!(szwsDZ-J=@IM2gSK1LAKgA$dCMX5F3ZZ~p=MxupO@(M zH&docD1@fyN=UmuVM#HYbcIe|{M+@f^@PeKC4Oj)-96m?s>$44=b!4BQuisR0)Ljo z*buMnZQoNuxCf&20$aLgJWW-P-Q&9t;uqQ+?X0E0?b@ooM-wxp*o)N1Wy%SItb zml26Wrg&`el>Q@huPi{_r-d0%vaxEkg&Z2*g?|D#Uf@&;8ZvZ8do4imJf=#fN{Q^| zgq1=5^C_%(Ujywi&o5d=^uSGg=B^EgwD*I-A8M)`OYwnl+SjQ1T*70)pLL%9wd&%a@-@0hn%wG(3MmH^ZAm7 zg!ZS!xuOyA2Ju{bCwl#?7AH?LZK9i3B&Nq84s{Q^J;nA`C-2I?%$q9@EwnLiwAS~(4O~>i8R0fRtj7X z3aFoKUQj*N8uK@0Z7K^d@-tBL`$1!EP~Da7x}8C- z$&S>qE4&8t>DHiyaT71BleA~q_|wR%G17eVC$Yz;&u*V9V@nbYJGu}g4h`A7end#% zE7Z4mU3u2-ItNnc+Ke?AV9_VE6o=oKm^Kl?s|V+cJgx`bbcMUK({kauMS=0&azpOk zC|5vgMH<1qQ~IIo@ND!q;2mGINX57}J4sMc9GE@cM5}c+*$xx(hr0PgbxoAsp$Mci z@VGSd?s81(g?e!A1!33g=Nn;dq`L*`Je6>POxD{P*Y9xs-rdZhY-M-jZ1dcym(TmO zF!NSF|2fP@?_2u%CJil3f8Sai>}!2<@PxS=vA$xC8X52ql!O?2m2-T@;hE+5}&7c{?F6sI=pMEtUS@7 z2_H}@#aq}0u?D%Lf+e@3^Z`!`1KZnz?j|(y^e%TB!+|gk6h;AgibrtvGFdH%14m4F z-9J9wO-Kf&(boyJsl)tu^v(973h3uC4hjn_tn|{W-RnrLo|}N~Swh8f$M9YF9Zu$M z2K``d0`xFk4-w)sG&o$v2yB}0>?$C}>)DWwD^gz*F9**J(Po(kROV{ts<} zpE%>-N?duS&tDQkO-141AnBp-D+;?Emc<=4+xbap&F-o@D3vCYe%QNkCo3NBg|v7y z(2_TAgA7$iekXD2+bawyuNE>dp4g^*%d15uK2 z$rW8UP%j+=cpkx>7Z>M^3lRC-yng)^fbeLAx7*$w=XtFtnR;&w!{I zl12zgU`g&^{;8hxxt;`w)7jspBqsuM&b{-{09ju(|8MPJmP2efhrUZiQe=}#d=6g6 z((i5X3Vx>bN3Dy&`3@aGIgLGepQS89;HPM zKb1aqP(Qu1S?FPs6T+S>G!UY#bc3#y_FsM^4hGzf(CoM{;55Pno2AmG)P0HT&9k?C zV9HFOa6c^5I=#O3Yfqo_NAUAuVS%hEN7#q%l-cRfNa6~Px%6UkAUpqoTgdM+Jt^nK7z^fibL0kl8eq z_Sho!PoLPe7b^i@Iv>PzQogP_60<*6hI#YV+j6rc0>P_e>rooRkA2IdMUo~aRG1{2 zu(7SBMVg``DRjM(AoQQ&9-pqM2M87%d}d*Ew>ijXrM4?LPb2Q7KmrSyG5~Yl^3_kE zsx(Ftt5$A!5jPr#``YZ~lecIz6&^1F>9P#v56{d+6KDB>frH@Or^)nRiw891ek0}J zp3{VuSk6J?h}88N-*7W-ey`UZGyqFX;v(Ep%06MVidR{}}C# zMlbEiI5|5INo|)o+ytSH*%D7YaAx}c-9iEae9Wx1l|w;}A&%Dojx}OZQ_WthJp)^u zPEN~zY>e@F?{1s>ibST&HTGz^FzGgO5{b71+eJ=yM&w$-StY%b;ufg00j-p?{3PLo z+rO}b{LJj(SC@H^0Km)(*vp{p4%NNMEvtt9-KG_+a5+~^L{*OY#y)spMfTX(9mG7ZEAwE7M*`pZw5UQPDB`|EL9ay}{98VWcjWW;b+|>S~#{ z622q5db+xra(8vCWB&dqz4DpnmVWyCVV772hBfx*Vsg^YpAWje&X##0pZro5Gm(!2 zA~x5R&8$VPCAN*+MNHT-k03J>ucq^He>q~0SK}5}4&Qz9_6ifzE*c$b&a16^!CO$d z{Ay)V?Py}^KP*|SNbf`n-2H3O$vLM{HvBogu|v&S;AHUbyh!pdKL-P0Yqaa})srh7I<7jLC@M^2tbl77l*iN2&dQJ)iFqd%CU6ZMFL7IrIu)oD0J<1J-`K1x^FqNV+24D1W;tFtx(u+C zyHi`+IVase98btKq~<1SJOZDLU zGlpZ5F9^jU;rw_-^m50tsF#ZMx~emL1%L;Aq&LWZo=ELwM*mX{hn+|?D+s2rr8jk4 zwJua!D-gsy{_az{;N26Ac?bX52{`x=Ru~KKUbcK=Udfj3KPS(e3K$BsmzQF7m-Hzs z>%*QKixX@<1C?ZRhv8qC1&3iJmq*kM`VXQqg-m2HIOox+;TmX4x{$Y6V6Lq-(YyF9 z)l-CY%laYUV(fT6f4oLzEzdZ{-0ha#=3Af-YSt0%`lW_xn~=kpUSMlPP)S*|<|MFn zej#%l)j2-3b6^s7pYkpI4?W9$X|mZHR}f*S%qD{*6+sd zb?RKB|Ge6D*t7a{U?9k#zoSLnOol(#WrbVd8Tk<~Ev3g}E!X;q~YT9itjErSu zgGL60x3&NMO(cC+>pI$(c48dPGj^xE1*49B51?;CF0O@kX%xy=4EB2a=iS{#i(^aV z3nhK>G-`6jW@)z`hvu^=!Sr2~YMG^PJW~R%}bkoA9GtIE*aJfVIy%kVURYP{ijMC3nkoe3-M6~{ z*AJwYE`PTFO2jHIyx9G9oO7Oq@bP=FWPeAYA^-J}9PVQAL2N8(B!@x0$WPWl&UgF; zW#H^936Ua_lA1c&6}E`*jj`l$9}WiUzP9LKeoyqwb_N@N%PTY^ z;XCOP>)UQK9}$joSX5YDIIV2ETUIGJLGONP``5aH_GdM^q6%~EFCF(nR$BQEqS+DsSV`0NEL#V#*IGfqYZ8BxhI&SQ+a>p~ zEM2*0Y>)dJYe{z?w$|0eNHcHes}|>bXx>F{F+>K6QhqV-{LOsY#3fDjdzW`RH8XPA z1QPT{assXbNNwUpK zoagWq0y|W{|1lMDft6Ber%niNtGL=ck$}Q-DtT2SSY{!dhimwB04cj{P*(arb$C3b z=aY$EFza3!s5`aRmRfTrY;0! zxqAY`hLb66{u&&4$J&RX?eN&1Tkp=7AEDDsACN!pEwxt>T|5ybB9+3*hxRAOo*M|r zHPU}m$k*2l>&ZuQmr~2b*N(ohpQmb-AYipQ|5Y)=#K+G3UV%Sg*1 zPT10A}-Ptvh@b zjbv8@0D_@>H@iQW9!0SU9VtpCAp#UHr~X*z*Gm15A`FM^Q(0gQc%j#zYO+@d_8!Up zl;TIJk-@POQ=qO&5H_@=Ow!cX9N_&9ANOhk)F!`UDd`52X>dd-Eqfr@I(m@2-9qNeZ}D81%tU=cMQO^-k2^9%_Up_*U>W8=bam?hS z9V|XR$27pw`&>?lTY~a9qFIJvE}R<<%pAGkr6CZ2>tv=uZaL+Zv}p3M!Ii=+>0>zK zc}FnrPPSq$xvQ1ZZ0o4XD-Z`s-k!jWauoaTe^Pt5#h16~I7}_jd?j!#4-K&YGTe*} z8mn5FIAxAPz}gJ#<%bT&i>!%f;V-USP03In?|>(`b?qZxhsgoK8U4Pyx_J68Sv^yS zCfncltJssay@Z^eB)Xems`AL|h38a2u)LMBDcl2lCIZcYyZDLygld=`+dT`63>218 zEF@f^%%Qxd4*equ-we#?rfMZYVGyL^L-!&<jI8hYg2)FJ;n}t99Y({5MB|F)QfG77#ZA>?(}9s zb-{(y_sTy)kG5h)`K{1=;ND_eVz73U5z4NDq5UP>YYLqzTUnVbn5=l`GVz}CNOE6B z9Qa3+IxozNIL%<{fU*cg64-k6cE2vuSC-j2y`@~Iw6LU6Q0d^1&3%dw&de2*20&pz zrRwck5-I}|7}jz%w;Ga}%?{!h55+3BtR1(}iOufb* z7ylT@2{SZ?)X<%XPOdeoT zAuGrJL~JfLQKEr>M}N6`|NFlOvDz1pW*aAF2I0~K(~P{{p~(TAqs4-0pF?KS@_Lb0 z7gJ_Mkq6<+ZEbcElbi`rnwG!j9KL%|PFzk7c6|4(h4^(&{fQ-8=HiKG5hCvv4-czW z95ELWO4h>3=M=P2_Xd(ZRJ-0#0$#&TDcab$!4jtaJa`keIvKOY6hKS4w6?Y~GbD^( zVvGPHsYXI!a||=tfd$W*7tq&#<6`%BI-=>CZ!I_fZMhtnQ|063bJ~|*5o{Dn$kojL~~85)CM-FQ8Y5ZI3Ap>+f(aH z&vrzCaD`?g;C#iMV@2 zYKLL+4LP0TjVJNnJ8n0*p_!M>QI{wy+zr0BQL&L1zx_Nor=vZ3?lgUelAg$8#*HQ-!@JAsnla80-Cttp4wWX3e>Itp6Wyggav6{tM|W| zY@5M$9Uc;P3W)n?T79@~h2n{KPd{+1t@B$VkOVWBZr;$TN!wGq9ff1{JyHU@^D~v( z5s@%#iA!Td3fF9PzIa8idKzVG#sB2+;8=4q+u>BJr#_)^kn5#n!Yz3 ztLqDADg=~kEWUK}eA(UD@D_(1Vgx5LgJf(1K=oNyM#~x0Caa0?m>HkCD-?KxuPShLbktL#@T@;5*|RJNN!?EX5>&CQ*nzF{%V z8G3}5E!jEG5=Y9v4qx=|n#MFu40rGvU~)A0#4}sSjR=1WC8*U09NHsQsbBhG+|uG7 zsL-dL3YfnP?(!LQI?J%l1!d@g%6%3Y|J#8^C0YuyTBfh-MV>zGQ)hBH6^1lTmBq5L zE5$%TE7rJyu<~=G+cSmdMdv$bxA&e8J>^+h+4fE%U>AJjOi@RhjHT(Yfh9Hp^XX_A zL%fy9OgyL4Y!B)Cq@OdtC9`L2s5p9Xz@cCzETU+_y0Xa_>4- z1?Jq|WJKd`#C-k9x*x-TVQiGAM8v&_#njGFlx#TH#Lo}(moou{RMlwN63B#?>0qA%GIohI(`iIX?1;oSN zaO{P-uPat&ef|#+uS@H8Dron%-l`jcnTc52E6B!!F7}MyDj>f$(BV@?W-kL53RfR% zeQzk4kd?Jq`TOG4J6<9#^Jxe>7P-u{pj}}#|HZs9-+O2)YJv2xV50;X3I8q zmf0RGUb7t{FOw?rF{k|90utTOB8z_>96VvpWe-AQBDI+H$8lKKfyFU>rnfCGl=5q9 zDRp^G$O@sNm^xOr*QUmFOs{IBrGV1*_n-QS-bl=(E4yG`dM!-d`uOJ86DG#>U`;5j z;6Zff(U{K3#?`R;VS2~^j{%t#5+7Up&7hs2N`|i;H3QsDOD9V-JLXznd7N@f&IF2G zBYFXYcJMOUKl^{3o8e*OnzZW41)kS)hxbF{Jy2o#Szt%ntOHIjfh`O3p?M`lsEj$! zFee0)V?88BhfdjKfb2iQfWA~~lhPHeuPvt~>8UWq*%IREoU=LGR)ago?tM9Ds0Q0U zKD7A!VY%CwSv|;-k|K`+)R2OKg0I5xkMVP9Vdk$Zccrq)F6IY&Uu|CGY=vSbGp%@d zmO{fci%N(HSPuCg(|h=H|Kxj<-^t$AzSV->)Pw+?a@Ca*!}4Ov}NKOnE8<3O1sWsLV_{?wnNJMO6$ASCs#B5i5CrbaJ2@@ z;Y90HoO5%y>9>i`;Ee9^nI{ zym`MHTgVaBn;o*{uft5VyL7}5?tJe{rpW4ifZS7giSJo3)u1_^@hXSMUcflp-~S#I zjh0iX#JoUP_(#mQwg&J1Wh{bcjURMqk9fuMz#1E1mrzcSh!glQTKYRy{@e+YW)emt z%QsQDZ-m{rhr^y-iZk7w2$&h~QiURk;i{9zzLLW~wOvkzH~>y4h5pU&QQD$o&EdVf z&^@QiP5uw8UhD;^c9t)6p3ouPxXbt-RnI5!ggK0lp*vtXP2}K%3+FNNKX%p!Cog6f zQL?bycJzbagerZDDw8$V_DpW_ZgaF)ZoSrrVbWRuJK1wKb*eh5Itc_2;FpEF9D>k^ zF7urVFeTd9?K&)lMc~NOR&`m$s)hO(A06~Ua)qiIjyTC3e@fI@U;4}MYGi{r9#^LfX zYi6zoZXrMAeELTQEhm;ld9x*UZ0jxbS<#&TTa?C}){!Nyz0jP#uCi4(J3d?Ql8aa- zm}0nY5SFmoVy$*+OU$OX=xU$d=Qx5Aiaz0T^JBxrnM1ZxFSQFH4#otSBJH!cTxkvc zJF6~$xSaXz3yrlKFq?ZpAXlNh@0b76;bKOjbI-rU<7YH-UW;$bFgF~X-<(HIm{#;b z>Fbpf?p%#P=|sIs)dghs{) zKUTqn652h8&%o-4kV$hXo9WZ{QBGFGvUo@hgh?}r5SEmxF+`-X zW1$?nzW54*{9NOL<9VhT?B7p^F1W$rkj~%9leaoYb;;23zLzUCM4?kOBPDe*4jGiD zG^v#~E#K^%lgMHKUbGzYMknx8087lMT*mJ3OiLO|K3*s(KCieskoHZb1jeH8kPSWi z*|%w40A7*T?zNt7q;IF%geC4KjQ4FSi0+7eRxcI&m;$6o=Mt`BQw>rB);Ld8?%xJJ z?@`6S7cAYT( zWj%KHM}1`>IP=p?ArqM1xj2N4Xh$87+r+eVb)Lk z`bz<_fvh3aepZ6F39wMo?bFn-u;x95%U}d2wK#jwTt61YGt=g`r1 zk}Rz1YJ;QS6%D(To9Y-j#-8p%pW?HQwhJsmLJbvDjgBjHC0>uz0 zO>ZKrKyr_nS&xVnkGXS|9K9DN*y^0XsfQsVzD)$;u9cMf+CEYxQgx>p)pZa>9)XPU zDFoiU;Eah#AGv0`gmK<`t5b3og?Q)YBp?6U-UG|ZWgO^4dy*0NWkb`nphbRl304}Q zeR1XBOI7H-_(+d57y^{)OJVF*hvn=rim&Js$Mh- zOJdNTdkrzshpx3ZWH57`l-Rad%+vjS1(&XvqrENq=@&Yb$k6>C+k4x4UbAy^bF=0J zi@#>w$a6Y#IwLvPb&K9rThU`EK|bZo2=`}ic~6KrUDgkpd0 z7A*Z5HwmdxaE=-`HQQ_|s6GmF*=cFji8x3kUE(Lv#A1FKIzP^jK3oj)58*drw}jmn z!UJ?)wy5y(>zlfbBocr^07aD2C}82|FSXcbEk~LzZ=&c`6-FticbxN{RTmWWt!o*{ zmxe}OGW@)8!`af=aS(L~ds&@_Z=R2^A<7NVE#%>Nua=x0GiXuU_(j7nPexMF9%V>kB0*;nfxLgifJ5 z;mF4EUBxFdli?rQ^Naz0&z34^?pYyD%yT@Oy-G%6*OtEFDpS_C^qSRIjiRd1J5!LO zSCUO)i%L>_p0h+hCnoneyTfs%iN)vLOW7u2#zwiAp3^4gDZOLm_m*EYPS8<4rx8Oy zIq}QbOABcSL3%(Kd)}? zCyR1%MS*lRkM(q?Ia6y@2ZeL`7475;jr~d!n0EnBd2+_sq*Z|WAHwBIO;Y2_bNsZg zbHG*T>ORBFo((4ID(^-PC3_#bN&?7G+#&8O0^#2a=rKERuTX7@OIgD zhA~z9_~%3D`jUk<3s3tUR>cIy-XU|GH?utu{z743scjaT5c$}{FxPwcWKp=b;mzXAJg7m5sNO=91L0eF<4VlpHy)PvKMi`C;*mF`9Z)!3~Whao>G^f>bfJB z_tL%6k4?TXu)lAG|2M(ab_R)+?63W%_p@xHN*B0LRW>zT2+nwW>(lc-#gh1kZBt`s z_!Gp*!pUu2qlBPm^gxEMG{tW9WgORd%5aFE4|f(DPe`JE$1)C>B5;OWrwcrGUJFq$dFQN~T$ zP7YAQD19OMTtM~ypMO~SweJ#bCH5g`-fie|k0pyeqkco8P)9+=Z zfc$4^+SD8J-}5dmmW7DxFAJK{uClVWd5IM$>SdY&jNXS_WqZwm9m#5^abeQ~;gT$2 zH>`fEh`YD7+z3%Y34&F9LL63R38PGfeIMIv*RskVI9zcp#Q8ELWQ#Jp&6st1;5Ta` z3F1X&Ia=wbg*Idbsgd3|r=0_|kzeRUhBLyLMvjB!QO0J(Kg?>u(pTp39a44S0O`ib zpLojBa$&56^Kr}L)H{D4NTWQ`swKAezt2+2C+q4~W=#=6+3VgP1jAb?dHc+GwBO0$ z$?n_z*ww?`%aSR&{cARLzM-@F9{ydN5XBi)pc2Tkf3|fBPmjX_EK{WeyBESZr0(EP zgPnnvts&JCs|<7Va(d$rqo&aJ`q#2##C4LR&T~|qfpkugT+BDJ2Mg8N5)^YhyMFK$ zsy~xOvyaND(~ti&zoO}?*dQOCuJNX+*WFFHtri&&4VDc1F(Dw;9HD)Uw%aki6_}Uu z{+2PK)UowOMP>Cm%HI0&~Sx6C5N?(8^X)t>Zhs|~zd4T|mPQnP^v|IwnpMi0t749`2K zYN25<_W9`SqKp}dMgUoZbYU_Ad}4|XC8n9(B)@aB6QJwvP^>ZhvqLB2chK2E&ri13 z-plHeDwRBFi&xlB{{|RW`kV{ga@gboPGQs@TYZkuK3Wq~n#3|+7wX2;WQf*79}?`> z`uh9KNWaPw)DJ8Q=%yQ&mW9VV_$|n$^uBJLXf?|OWaKpzSK`KoA_kQq$QxV;pxqck z3;ftCzdSsw>YhgK#mv zhF_y|;&Bc*o6OYLJIHB{=NgcqAkL-o7{;~B>0%ZqEJ`yzc->@c4%hnMDV{$xbhI9e zM|~8^t#Y{Q*8Nh~RkEyMcn|g&C8P13(})@m$^hu$A(h1HmL!yE4R&HW*Z0Z$C+*^> z&cdf*E?$24)Zx_-&x{7cCyMUp@!#hzHG!lC{E^vs5Q^0Umnc-`dj)_KQ~w!HY=CePyAImxw+DxS?dZ%D8wuoTy-0@8Dh5y-LhuW+TU zZ2N439pUY{KAY>UeVrWo(j|_l-%DFp-B?{=tc_OKjAguj2{CN!r?Z0rsl{hI={;1# zlzQ!%$k~u!F|g`DRVBdT@&ZN*{+RpgF-N#^IY%O)#R5ru&P zPj{ml-#CkIOIwUJYR$Z1zLd{b+Lt*~CPP%m{Oz_d7gB8i4V8N>&l-yrt;vq&Ips}v zB%xtVb2A>D_u(_0Qu+WvV>GlM657#4iQQK1kj2(%_3$((W0E!gu*x zOec(F_N_-=Szg&zgIeW|;G2Ox4MhOi zNGlpu8(9T*W9)n`o&pHXuneEMt)2wyVPloYd4AI}^W_s|i7U)?Z4!cBjVS902XF?s zZ!k1Ep~n8e!CZUgJ-Kn#|19s#TJcM+@tF$6mnUBh>M9%!xuy`L;Ve&K9B*yr*r_EG zeRe+&UtleBJpNI1aIWh?*vY{;7jI~3p%r%Ih#`^|?w+wspvPQis_D?%F;QCZcP-A1 zS>Bf`%!1gtGw#0>#1BKrwK>W=e95yXjIMtq-Yc`-FArCbpPxLy5hovkN|)bwIZN`~ zn(Y5DY-KVP@#t}wVKRb5RXXO*>9@@vB;1xHnrZH z=h7^>2?0yAxr@&^Q}|iiHV=bm{zuWd|1Yd|3B5_u7=rE>!r{-<5Ypd zp&Bx=A)7Rxs-h%QT=7i-dNs^R5DuRJ{fV#!s0J`dIK3olXgBmx8Ex1Q7mlhUOPiN^ zwvL{Z0DmH|O^FN&7ottkMWgyYnc|`lbkYyMuDTUC8!d*NNF<%|~lG2O*ZG*poV!ugyEM zu?-3JZsYVNcJ|B&**`p#^YCuy&ib@68;tgVPR%)1-?%gNw&s1aRd=FhJ!%C{NWAT| zk^ja35x22S-|Lxq_@bB)6&C+#~KOh=|6C=#-vW|Z0Xgi!s{vc0LULlNv>$VQNXat;lOwhqkMw0i< zb6Z0zV+V8Ffnl2O$(jljA18!*bIUiDr{|yS2(e=5Q!F{sNljK!piQw_`ZP!n;G5SF zy7_)3rpeKpklqvRm?UXsxIBzflfGV&^Q-2XrvN%FtlNmY0`B`>KdwYxElEh{xP!UP zG1nhqeRUG+IhFdT!N^B%zQI<~={xH{LGP^RL)ArOGnN_T^(~V4>Au2^VG{%8-@}&O zOM&MeJZjfWP zMcID7OJsTG_kL!eHhoqTO*6QNLm?j1JhD8GA7@do7NNLT%FE3LGC6n(}ab)X|JvOaik;b3pAj2o`#>+P+xx8Ug9*w9s15W6F#u+#O< za($K9!5ddKreGb>#Rs@I;BCqKaiU9wJ7?=Hhs^kNWCo=w=)u)AkB~ppB~?s{>eAOT zEarO)WXr_EsI!UKHD`654vlg03Yp**RY?jyL8+TMES5ov@Mx(l+; zNOKx#sEr9dS|2Q(Y+EWl?c0}O{ikoXer#!!bhPkaPlnG64E8s@CHAeKOki|vlaU8! z(q0Fz_{9c}yJvQ5Wl|3Y@-MVI_^*(RRREEj%cZN2(AmXaLC`^Ne3 zT|AMM#3BH9X8sEz{h9FASvuc0J-@a+|InAs$WPq~42L9!m-J}9f(p2$6;HMWpp&A1 zv>&k=wx?f}+M{SSHG^nJLJ+-XX-9#|cB1#p2gbzgoj&~6M5>lth6O;PHy3u93XS`E zF)O}JJ3k1GYrW3Bb+&4EEuNiLi>KJjeAN#PG@u-M`ZBW4|D`T1OmAAb!z%AUyY|{R zKk!v<)svrFjyf(SD9coj0z{-unIqYJKg2w;cx#oI&5B=(i#1Jdi&_Qq#*L@7O|EZX z^@lHWzvj9Ep4Oby|5aMEDa;`c%gC`%t^^nxNb5#C&^?(Cu#^)8LtN7}ZL1d2EslS9 z5|U^xph{2zE27)IA`w}aAo{qkgwZp?$DhDK=F-NNI6<4%r|qf2Do^?>EFOIh_7e&L zK&1oJ2K`QpKh$9iGp7BS3)cX`_XHp_otbwY`I0WTR1Q4}jp~rWS6|OOJ2@JQeNfSp z8bXY^bSDmpnq((e)Gy60yN(Wfd&~dh$r1mt-gbMi&rFCq$T66fb9ea%F=D0Uq;v&3 zo253{CZ8;Q_v$-f7g@bH?KpS{jYs#S>1P_vS5xc3fMW$#$zFEB2nm-kHr)R_uH{=A zCrC0ntX@FS(bGS!abdH!F?*15&mXt7v(%9%*T?iZT=zN1K5C0$3LPGf?e(x%-Wwf< zbHy1(^d%M&HNlYzbFKz-C3Qp?vT2;KcWJY9p{B@? z(fzkcP6~2T*^bUDvjSs#y(_<+j{ZpP+GC67 z+4d-{LaQQ3m_@ZuO;ddzMf=^N&&dXz#hRM%l~@^ae;pD$WBzR7@(?u~#T=Bp`}V|b zi>|`QsDMh?+e=}!imav92{T4`L;E%!#RiVRbz5J;9 zXv^%du!)@Tt8=Ml88mS#wMSWH9r&;f`&e(IzU~?Jch8;be&$ustcTYZA09X)r#r_# zJiMViEUhk|()hVA18}bo@p3uzwJnUGOq7^AYY<$rEXh zt`c=Iiuw6Ueb>8;6I_~+O*-bn?xwJB`n3CSZsGH$Y`62$U3jjo|0RxFZCE}GB3}^X zGhFj3JHtydQ+A4bA}qJDf;HUET{zIxExt$9H2>r&G09KJ6bId_96aBt^PVy8Sd zwo`1h`h;#8G5(TDz$JYwN6`x)n}5=??02vrYxPm^741j zFbcNjB+Tx%Ekq8D>8+6!_MofsHngL)l$|U zc*TBsaWnrJM+({wLGE^o=x(4@R09!Dzj^k^af!%e(5-8| zDVPd#Mb?L$)LS4oX_)}e*3~l8*!JIynx?RCi$c_QM$5Ea_I`!ocOVRwduVg89?@hy zw6xoMR$4jaykfJa2{%TcN}Ljyz%zQxv}sG_H9gbw6I;{SLzaKv(ZA;=1|jc+X6joS zdf@b&v=wVMACr_*aK7|~d2LKl*uS(9*Q}TB)S`T?LUyvY+TnW^qXvy0tp8S^X$E{Y za-t;7D|hdHhDVC>3CH&N`6qy}1ox0XvtITn69eo;gDv1vP^Pp@q`)}%o<&U=Ne#M- zj5&yrXSPC~owqR*HITQU&CD480|8A_tE~;YOh`$8JOlu2-c^de#Y&O)mu0Yzw+UmW z2+98Wc-h-3zZG~DD&S?dt%yuiJ1t`%3f#zd`?(Bw?K1jYOvA&Jr67LsNXnK<>)|WiDZ*ud~HY z5t&!^4t$()74sT*CBcnNQM(~W-7)?eI)l__oh^4u~!=?0I`O0ga^)efYYH!ARg7P^asokyyIdTs{A32c+)5TJ z+)pf3?uE@ZzSnZmZ@}j6cw+{<<+zJfpFWo?`hs}S8i5Epam??83oqQ_T6I>&x%fxr zJ%=y&`Hw4W-1&!qYMfe%!kWTP(Q25}>itCMoy<0q4%Z*@7jlan{~5RD)J}O+AxAX% zI4rtvzW`5Q^kD{o8hcB(O+l<>?z%rvbmfHIkEIa-kgocyJUkB2`ZN{yw&q4{+RU*1 zQ26|4uQVhx#T?)!-wAWGRjYLu7@@vB_B<$1Hh=VF?~4pXTgG>Xrg{$dkTITbP@$#! z@4L18E#o|J!D?#HptvGFj3I1XE3+dyhH!HZ69CTkHiY$y1f=AA4ZdTWPH#Ja$)%@J zG>_TZ31Z2uz1LF2Y>^6#aNU&e4sZ5c)fgG4q}Ao%@j%Hxa;gFgBz$qlxLtLb_ZcuiABw3ed&n(- zX`8qkwD)GEk@iJagNLrIx#bz(mLpv3C0_qr=vmX4niAMfaOi07Xy2yzSh7;H#71#B zAgHQ7x9V9$(xZ&YJN|r%h}1N}fP3x5d%S7wud6o+c?WK^@K@3-YZU5>qt-Vr&Yvp_ z?}T&B%&>rQw(p&NvW)T9mePxtgi(9s08F3y#zxU8A~7U`dAHrz3y(jEOKvsmWUy~Wr7M$jp0#I2g?)JM?fWn&B-L4gEwQ_ ziO1$@4)dK4Uc_4pC-gUnhCoo^c0)c;U$;lymw<()e3VhQ&D@UvU zF;34`gWW`H0RPCZa|(SJ7ezLfl>6iHgLUpxe7XU!*gwPG9M5|W)=-MF>0XUDa!sQu z!$NLz_AI|s6mealshYgzPS*Tt*Rz9hi4*rD4m%onp8aTU+O+=0x%u@hUV9X6ux+Cg zK|@x0LNR0)YKy~zsgQ(6*Ir2vMTf*_I+$oIHL+-8*%?*x3UU)QPQu0X$WA#C4@(FZ zjhy`Js@^J=%go$5EPG~(y2ANyw&{oF$LyE-wKw575u?$X&EDQygLu~P-u(PM{8CxD zJ*Ch=jWpswQq)~S_EF-)ui#3;Ihv+}+e;5p)1kuwsqb z;c#DT|Fw$tf3eI%&?C|{wz5b0O5AtqrPoI3?emchC?D!$LemZ3+0-qdU+plOcHiQB zMOf~j-zDD7<wC zFZDpl$dD(vLiz3P0)BuJZ%c=}^h! z0Cq!eWh_Q~*-S`Jw<+o<^ZZApCgXX(+R-a}dy`8wc#Ua%2=`6-Jz_|R!T3g?yw^}0 zwa0R$G|SO(>1T@Aa|F_?Riijf#YHWNvi8JY(08<<{$O|Obo6|NshL>@6AVm+a+lNU zX-i}mHfbmzDyU9^zP}Ng)=DDWS76lq3i!J%)GEZ|)NMt$PpHRl4lge%Ii zCQ#-%Rp0j`ap{t0?tUL&J3+nfzHpd;ft6-+r?#GICy2I`Igvrv`jm#37xSNxF&$^nmx~d2_Oig*TVQdL&{pTab(SL-; zJZ%MHmSeFRZ?{as zYlv%}+{sb=l20D4iCY8((fl&+@g{k@$O?FuE?3)}TMLF~D;C}(R2Up|xW=j4b&4$>oL9pc0}C080n4fWv(bS`=X9jfHY z!)<92_HItY6-?k=7$}}v53=6M+!&Grgi6|LEod^ zrnPmm{lbLB%|RJORhMRnMOLph>fFZ~G*QtF=f8xnX(U@ZqAGdLI7dDqE^ftL;_Nwu z%ZG#z!ul?_bfSBS)6PfL`pv--b zJ1fgwtYmZ+;`>n`wq&5N<~}ml!mVD@+D#D!p2Cm~)bl^ZKVVlsDk_rQ4H7JQu^Offx!uLVfJA}A>(aLH-t!+ znQn̴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

4p)EiAWM(9zrq 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

-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%0A$sTg)b=TE;&C|m>|Z|R>p0xYmzGZd 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